Logging cleanup: BTIF and APPL.

Change-Id: I5b1214642bbb4b9aecc0fd2c899a6ec2c9793286

1 files changed, 60 insertions, 60 deletions

diff --git a/udrv/ulinux/uipc.c b/udrv/ulinux/uipc.c
index 158a053a8..ef57a1393 100644
--- a/udrv/ulinux/uipc.c
+++ b/udrv/ulinux/uipc.c
@@ -64,8 +64,8 @@
 
 #define UIPC_DISCONNECTED (-1)
 
-#define UIPC_LOCK() /*BTIF_TRACE_EVENT1(" %s lock", __FUNCTION__);*/ pthread_mutex_lock(&uipc_main.mutex);
-#define UIPC_UNLOCK() /*BTIF_TRACE_EVENT1("%s unlock", __FUNCTION__);*/ pthread_mutex_unlock(&uipc_main.mutex);
+#define UIPC_LOCK() /*BTIF_TRACE_EVENT(" %s lock", __FUNCTION__);*/ pthread_mutex_lock(&uipc_main.mutex);
+#define UIPC_UNLOCK() /*BTIF_TRACE_EVENT("%s unlock", __FUNCTION__);*/ pthread_mutex_unlock(&uipc_main.mutex);
 
 #define SAFE_FD_ISSET(fd, set) (((fd) == -1) ? FALSE : FD_ISSET((fd), (set)))
 
@@ -147,23 +147,23 @@ static inline int create_server_socket(const char* name)
 {
     int s = socket(AF_LOCAL, SOCK_STREAM, 0);
 
-    BTIF_TRACE_EVENT1("create_server_socket %s", name);
+    BTIF_TRACE_EVENT("create_server_socket %s", name);
 
     if(socket_local_server_bind(s, name, ANDROID_SOCKET_NAMESPACE_ABSTRACT) < 0)
     {
-        BTIF_TRACE_EVENT1("socket failed to create (%s)", strerror(errno));
+        BTIF_TRACE_EVENT("socket failed to create (%s)", strerror(errno));
         close(s);
         return -1;
     }
 
     if(listen(s, 5) < 0)
     {
-        BTIF_TRACE_EVENT1("listen failed", strerror(errno));
+        BTIF_TRACE_EVENT("listen failed", strerror(errno));
         close(s);
         return -1;
     }
 
-    BTIF_TRACE_EVENT1("created socket fd %d", s);
+    BTIF_TRACE_EVENT("created socket fd %d", s);
     return s;
 }
 
@@ -174,7 +174,7 @@ static int accept_server_socket(int sfd)
     int fd;
     socklen_t len = sizeof(struct sockaddr_un);
 
-    BTIF_TRACE_EVENT1("accept fd %d", sfd);
+    BTIF_TRACE_EVENT("accept fd %d", sfd);
 
     /* make sure there is data to process */
     pfd.fd = sfd;
@@ -182,19 +182,19 @@ static int accept_server_socket(int sfd)
 
     if (poll(&pfd, 1, 0) == 0)
     {
-        BTIF_TRACE_EVENT0("accept poll timeout");
+        BTIF_TRACE_EVENT("accept poll timeout");
         return -1;
     }
 
-    //BTIF_TRACE_EVENT1("poll revents 0x%x", pfd.revents);
+    //BTIF_TRACE_EVENT("poll revents 0x%x", pfd.revents);
 
     if ((fd = accept(sfd, (struct sockaddr *)&remote, &len)) == -1)
     {
-         BTIF_TRACE_ERROR1("sock accept failed (%s)", strerror(errno));
+         BTIF_TRACE_ERROR("sock accept failed (%s)", strerror(errno));
          return -1;
     }
 
-    //BTIF_TRACE_EVENT1("new fd %d", fd);
+    //BTIF_TRACE_EVENT("new fd %d", fd);
 
     return fd;
 }
@@ -211,7 +211,7 @@ static int uipc_main_init(void)
     const pthread_mutexattr_t attr = PTHREAD_MUTEX_RECURSIVE;
     pthread_mutex_init(&uipc_main.mutex, &attr);
 
-    BTIF_TRACE_EVENT0("### uipc_main_init ###");
+    BTIF_TRACE_EVENT("### uipc_main_init ###");
 
     /* setup interrupt socket pair */
     if (socketpair(AF_UNIX, SOCK_STREAM, 0, uipc_main.signal_fds) < 0)
@@ -240,7 +240,7 @@ void uipc_main_cleanup(void)
 {
     int i;
 
-    BTIF_TRACE_EVENT0("uipc_main_cleanup");
+    BTIF_TRACE_EVENT("uipc_main_cleanup");
 
     close(uipc_main.signal_fds[0]);
     close(uipc_main.signal_fds[1]);
@@ -259,7 +259,7 @@ static void uipc_check_task_flags_locked(void)
 
     for (i=0; i<UIPC_CH_NUM; i++)
     {
-        //BTIF_TRACE_EVENT2("CHECK TASK FLAGS %x %x",  uipc_main.ch[i].task_evt_flags, UIPC_TASK_FLAG_DISCONNECT_CHAN);
+        //BTIF_TRACE_EVENT("CHECK TASK FLAGS %x %x",  uipc_main.ch[i].task_evt_flags, UIPC_TASK_FLAG_DISCONNECT_CHAN);
         if (uipc_main.ch[i].task_evt_flags & UIPC_TASK_FLAG_DISCONNECT_CHAN)
         {
             uipc_main.ch[i].task_evt_flags &= ~UIPC_TASK_FLAG_DISCONNECT_CHAN;
@@ -277,28 +277,28 @@ static int uipc_check_fd_locked(tUIPC_CH_ID ch_id)
     if (ch_id >= UIPC_CH_NUM)
         return -1;
 
-    //BTIF_TRACE_EVENT2("CHECK SRVFD %d (ch %d)", uipc_main.ch[ch_id].srvfd, ch_id);
+    //BTIF_TRACE_EVENT("CHECK SRVFD %d (ch %d)", uipc_main.ch[ch_id].srvfd, ch_id);
 
     if (SAFE_FD_ISSET(uipc_main.ch[ch_id].srvfd, &uipc_main.read_set))
     {
-        BTIF_TRACE_EVENT1("INCOMING CONNECTION ON CH %d", ch_id);
+        BTIF_TRACE_EVENT("INCOMING CONNECTION ON CH %d", ch_id);
 
         uipc_main.ch[ch_id].fd = accept_server_socket(uipc_main.ch[ch_id].srvfd);
 
-        BTIF_TRACE_EVENT1("NEW FD %d", uipc_main.ch[ch_id].fd);
+        BTIF_TRACE_EVENT("NEW FD %d", uipc_main.ch[ch_id].fd);
 
         if ((uipc_main.ch[ch_id].fd > 0) && uipc_main.ch[ch_id].cback)
         {
             /*  if we have a callback we should add this fd to the active set
                 and notify user with callback event */
-            BTIF_TRACE_EVENT1("ADD FD %d TO ACTIVE SET", uipc_main.ch[ch_id].fd);
+            BTIF_TRACE_EVENT("ADD FD %d TO ACTIVE SET", uipc_main.ch[ch_id].fd);
             FD_SET(uipc_main.ch[ch_id].fd, &uipc_main.active_set);
             uipc_main.max_fd = MAX(uipc_main.max_fd, uipc_main.ch[ch_id].fd);
         }
 
         if (uipc_main.ch[ch_id].fd < 0)
         {
-            BTIF_TRACE_ERROR2("FAILED TO ACCEPT CH %d (%s)", ch_id, strerror(errno));
+            BTIF_TRACE_ERROR("FAILED TO ACCEPT CH %d (%s)", ch_id, strerror(errno));
             return -1;
         }
 
@@ -306,11 +306,11 @@ static int uipc_check_fd_locked(tUIPC_CH_ID ch_id)
             uipc_main.ch[ch_id].cback(ch_id, UIPC_OPEN_EVT);
     }
 
-    //BTIF_TRACE_EVENT2("CHECK FD %d (ch %d)", uipc_main.ch[ch_id].fd, ch_id);
+    //BTIF_TRACE_EVENT("CHECK FD %d (ch %d)", uipc_main.ch[ch_id].fd, ch_id);
 
     if (SAFE_FD_ISSET(uipc_main.ch[ch_id].fd, &uipc_main.read_set))
     {
-        //BTIF_TRACE_EVENT1("INCOMING DATA ON CH %d", ch_id);
+        //BTIF_TRACE_EVENT("INCOMING DATA ON CH %d", ch_id);
 
         if (uipc_main.ch[ch_id].cback)
             uipc_main.ch[ch_id].cback(ch_id, UIPC_RX_DATA_READY_EVT);
@@ -323,7 +323,7 @@ static void uipc_check_interrupt_locked(void)
     if (SAFE_FD_ISSET(uipc_main.signal_fds[0], &uipc_main.read_set))
     {
         char sig_recv = 0;
-        //BTIF_TRACE_EVENT0("UIPC INTERRUPT");
+        //BTIF_TRACE_EVENT("UIPC INTERRUPT");
         recv(uipc_main.signal_fds[0], &sig_recv, sizeof(sig_recv), MSG_WAITALL);
     }
 }
@@ -331,7 +331,7 @@ static void uipc_check_interrupt_locked(void)
 static inline void uipc_wakeup_locked(void)
 {
     char sig_on = 1;
-    BTIF_TRACE_EVENT0("UIPC SEND WAKE UP");
+    BTIF_TRACE_EVENT("UIPC SEND WAKE UP");
     send(uipc_main.signal_fds[1], &sig_on, sizeof(sig_on), 0);
 }
 
@@ -339,7 +339,7 @@ static int uipc_setup_server_locked(tUIPC_CH_ID ch_id, char *name, tUIPC_RCV_CBA
 {
     int fd;
 
-    BTIF_TRACE_EVENT1("SETUP CHANNEL SERVER %d", ch_id);
+    BTIF_TRACE_EVENT("SETUP CHANNEL SERVER %d", ch_id);
 
     if (ch_id >= UIPC_CH_NUM)
         return -1;
@@ -350,12 +350,12 @@ static int uipc_setup_server_locked(tUIPC_CH_ID ch_id, char *name, tUIPC_RCV_CBA
 
     if (fd < 0)
     {
-        BTIF_TRACE_ERROR2("failed to setup %s", name, strerror(errno));
+        BTIF_TRACE_ERROR("failed to setup %s", name, strerror(errno));
         UIPC_UNLOCK();
          return -1;
     }
 
-    BTIF_TRACE_EVENT1("ADD SERVER FD TO ACTIVE SET %d", fd);
+    BTIF_TRACE_EVENT("ADD SERVER FD TO ACTIVE SET %d", fd);
     FD_SET(fd, &uipc_main.active_set);
     uipc_main.max_fd = MAX(uipc_main.max_fd, fd);
 
@@ -386,14 +386,14 @@ static void uipc_flush_ch_locked(tUIPC_CH_ID ch_id)
     while (1)
     {
         ret = poll(&pfd, 1, 1);
-        BTIF_TRACE_EVENT3("uipc_flush_ch_locked polling : fd %d, rxev %x, ret %d", pfd.fd, pfd.revents, ret);
+        BTIF_TRACE_EVENT("uipc_flush_ch_locked polling : fd %d, rxev %x, ret %d", pfd.fd, pfd.revents, ret);
 
         if (pfd.revents & (POLLERR|POLLHUP))
             return;
 
         if (ret <= 0)
         {
-            BTIF_TRACE_EVENT1("uipc_flush_ch_locked : error (%d)", ret);
+            BTIF_TRACE_EVENT("uipc_flush_ch_locked : error (%d)", ret);
             return;
         }
         read(pfd.fd, &buf, 1);
@@ -423,14 +423,14 @@ static int uipc_close_ch_locked(tUIPC_CH_ID ch_id)
 {
     int wakeup = 0;
 
-    BTIF_TRACE_EVENT1("CLOSE CHANNEL %d", ch_id);
+    BTIF_TRACE_EVENT("CLOSE CHANNEL %d", ch_id);
 
     if (ch_id >= UIPC_CH_NUM)
         return -1;
 
     if (uipc_main.ch[ch_id].srvfd != UIPC_DISCONNECTED)
     {
-        BTIF_TRACE_EVENT1("CLOSE SERVER (FD %d)", uipc_main.ch[ch_id].srvfd);
+        BTIF_TRACE_EVENT("CLOSE SERVER (FD %d)", uipc_main.ch[ch_id].srvfd);
         close(uipc_main.ch[ch_id].srvfd);
         FD_CLR(uipc_main.ch[ch_id].srvfd, &uipc_main.active_set);
         uipc_main.ch[ch_id].srvfd = UIPC_DISCONNECTED;
@@ -439,7 +439,7 @@ static int uipc_close_ch_locked(tUIPC_CH_ID ch_id)
 
     if (uipc_main.ch[ch_id].fd != UIPC_DISCONNECTED)
     {
-        BTIF_TRACE_EVENT1("CLOSE CONNECTION (FD %d)", uipc_main.ch[ch_id].fd);
+        BTIF_TRACE_EVENT("CLOSE CONNECTION (FD %d)", uipc_main.ch[ch_id].fd);
         close(uipc_main.ch[ch_id].fd);
         FD_CLR(uipc_main.ch[ch_id].fd, &uipc_main.active_set);
         uipc_main.ch[ch_id].fd = UIPC_DISCONNECTED;
@@ -462,7 +462,7 @@ void uipc_close_locked(tUIPC_CH_ID ch_id)
 {
     if (uipc_main.ch[ch_id].srvfd == UIPC_DISCONNECTED)
     {
-        BTIF_TRACE_EVENT1("CHANNEL %d ALREADY CLOSED", ch_id);
+        BTIF_TRACE_EVENT("CHANNEL %d ALREADY CLOSED", ch_id);
         return;
     }
 
@@ -488,12 +488,12 @@ static void uipc_read_task(void *arg)
 
         if (result == 0)
         {
-            BTIF_TRACE_EVENT0("select timeout");
+            BTIF_TRACE_EVENT("select timeout");
             continue;
         }
         else if (result < 0)
         {
-            BTIF_TRACE_EVENT1("select failed %s", strerror(errno));
+            BTIF_TRACE_EVENT("select failed %s", strerror(errno));
             continue;
         }
 
@@ -518,13 +518,13 @@ static void uipc_read_task(void *arg)
         UIPC_UNLOCK();
     }
 
-    BTIF_TRACE_EVENT0("UIPC READ THREAD EXITING");
+    BTIF_TRACE_EVENT("UIPC READ THREAD EXITING");
 
     uipc_main_cleanup();
 
     uipc_main.tid = 0;
 
-    BTIF_TRACE_EVENT0("UIPC READ THREAD DONE");
+    BTIF_TRACE_EVENT("UIPC READ THREAD DONE");
 }
 
 
@@ -534,7 +534,7 @@ int uipc_start_main_server_thread(void)
 
     if (pthread_create(&uipc_main.tid, (const pthread_attr_t *) NULL, (void*)uipc_read_task, NULL) < 0)
     {
-        BTIF_TRACE_ERROR1("uipc_thread_create pthread_create failed:%d", errno);
+        BTIF_TRACE_ERROR("uipc_thread_create pthread_create failed:%d", errno);
         return -1;
     }
 
@@ -569,7 +569,7 @@ UDRV_API void UIPC_Init(void *p_data)
 {
     UNUSED(p_data);
 
-    BTIF_TRACE_DEBUG0("UIPC_Init");
+    BTIF_TRACE_DEBUG("UIPC_Init");
 
     memset(&uipc_main, 0, sizeof(tUIPC_MAIN));
 
@@ -589,7 +589,7 @@ UDRV_API void UIPC_Init(void *p_data)
  *******************************************************************************/
 UDRV_API BOOLEAN UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK *p_cback)
 {
-    BTIF_TRACE_DEBUG2("UIPC_Open : ch_id %d, p_cback %x", ch_id, p_cback);
+    BTIF_TRACE_DEBUG("UIPC_Open : ch_id %d, p_cback %x", ch_id, p_cback);
 
     UIPC_LOCK();
 
@@ -601,7 +601,7 @@ UDRV_API BOOLEAN UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK *p_cback)
 
     if (uipc_main.ch[ch_id].srvfd != UIPC_DISCONNECTED)
     {
-        BTIF_TRACE_EVENT1("CHANNEL %d ALREADY OPEN", ch_id);
+        BTIF_TRACE_EVENT("CHANNEL %d ALREADY OPEN", ch_id);
         UIPC_UNLOCK();
         return 0;
     }
@@ -634,7 +634,7 @@ UDRV_API BOOLEAN UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK *p_cback)
 
 UDRV_API void UIPC_Close(tUIPC_CH_ID ch_id)
 {
-    BTIF_TRACE_DEBUG1("UIPC_Close : ch_id %d", ch_id);
+    BTIF_TRACE_DEBUG("UIPC_Close : ch_id %d", ch_id);
 
     /* special case handling uipc shutdown */
     if (ch_id != UIPC_CH_ID_ALL)
@@ -645,9 +645,9 @@ UDRV_API void UIPC_Close(tUIPC_CH_ID ch_id)
     }
     else
     {
-        BTIF_TRACE_DEBUG0("UIPC_Close : waiting for shutdown to complete");
+        BTIF_TRACE_DEBUG("UIPC_Close : waiting for shutdown to complete");
         uipc_stop_main_server_thread();
-        BTIF_TRACE_DEBUG0("UIPC_Close : shutdown complete");
+        BTIF_TRACE_DEBUG("UIPC_Close : shutdown complete");
     }
 }
 
@@ -665,7 +665,7 @@ UDRV_API BOOLEAN UIPC_SendBuf(tUIPC_CH_ID ch_id, BT_HDR *p_msg)
 {
     UNUSED(p_msg);
 
-    BTIF_TRACE_DEBUG1("UIPC_SendBuf : ch_id %d NOT IMPLEMENTED", ch_id);
+    BTIF_TRACE_DEBUG("UIPC_SendBuf : ch_id %d NOT IMPLEMENTED", ch_id);
 
     UIPC_LOCK();
 
@@ -691,13 +691,13 @@ UDRV_API BOOLEAN UIPC_Send(tUIPC_CH_ID ch_id, UINT16 msg_evt, UINT8 *p_buf,
     int n;
     UNUSED(msg_evt);
 
-    BTIF_TRACE_DEBUG2("UIPC_Send : ch_id:%d %d bytes", ch_id, msglen);
+    BTIF_TRACE_DEBUG("UIPC_Send : ch_id:%d %d bytes", ch_id, msglen);
 
     UIPC_LOCK();
 
     if (write(uipc_main.ch[ch_id].fd, p_buf, msglen) < 0)
     {
-        BTIF_TRACE_ERROR1("failed to write (%s)", strerror(errno));
+        BTIF_TRACE_ERROR("failed to write (%s)", strerror(errno));
     }
 
     UIPC_UNLOCK();
@@ -718,7 +718,7 @@ UDRV_API void UIPC_ReadBuf(tUIPC_CH_ID ch_id, BT_HDR *p_msg)
 {
     UNUSED(p_msg);
 
-    BTIF_TRACE_DEBUG1("UIPC_ReadBuf : ch_id:%d NOT IMPLEMENTED", ch_id);
+    BTIF_TRACE_DEBUG("UIPC_ReadBuf : ch_id:%d NOT IMPLEMENTED", ch_id);
 
     UIPC_LOCK();
     UIPC_UNLOCK();
@@ -744,17 +744,17 @@ UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UI
 
     if (ch_id >= UIPC_CH_NUM)
     {
-        BTIF_TRACE_ERROR1("UIPC_Read : invalid ch id %d", ch_id);
+        BTIF_TRACE_ERROR("UIPC_Read : invalid ch id %d", ch_id);
         return 0;
     }
 
     if (fd == UIPC_DISCONNECTED)
     {
-        BTIF_TRACE_ERROR1("UIPC_Read : channel %d closed", ch_id);
+        BTIF_TRACE_ERROR("UIPC_Read : channel %d closed", ch_id);
         return 0;
     }
 
-    //BTIF_TRACE_DEBUG4("UIPC_Read : ch_id %d, len %d, fd %d, polltmo %d", ch_id, len,
+    //BTIF_TRACE_DEBUG("UIPC_Read : ch_id %d, len %d, fd %d, polltmo %d", ch_id, len,
     //        fd, uipc_main.ch[ch_id].read_poll_tmo_ms);
 
     while (n_read < (int)len)
@@ -766,15 +766,15 @@ UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UI
            a read for more than poll timeout */
         if (poll(&pfd, 1, uipc_main.ch[ch_id].read_poll_tmo_ms) == 0)
         {
-            BTIF_TRACE_EVENT1("poll timeout (%d ms)", uipc_main.ch[ch_id].read_poll_tmo_ms);
+            BTIF_TRACE_EVENT("poll timeout (%d ms)", uipc_main.ch[ch_id].read_poll_tmo_ms);
             break;
         }
 
-        //BTIF_TRACE_EVENT1("poll revents %x", pfd.revents);
+        //BTIF_TRACE_EVENT("poll revents %x", pfd.revents);
 
         if (pfd.revents & (POLLHUP|POLLNVAL) )
         {
-            BTIF_TRACE_EVENT0("poll : channel detached remotely");
+            BTIF_TRACE_EVENT("poll : channel detached remotely");
             UIPC_LOCK();
             uipc_close_locked(ch_id);
             UIPC_UNLOCK();
@@ -783,11 +783,11 @@ UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UI
 
         n = recv(fd, p_buf+n_read, len-n_read, 0);
 
-        //BTIF_TRACE_EVENT1("read %d bytes", n);
+        //BTIF_TRACE_EVENT("read %d bytes", n);
 
         if (n == 0)
         {
-            BTIF_TRACE_EVENT0("UIPC_Read : channel detached remotely");
+            BTIF_TRACE_EVENT("UIPC_Read : channel detached remotely");
             UIPC_LOCK();
             uipc_close_locked(ch_id);
             UIPC_UNLOCK();
@@ -796,7 +796,7 @@ UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UI
 
         if (n < 0)
         {
-            BTIF_TRACE_EVENT1("UIPC_Read : read failed (%s)", strerror(errno));
+            BTIF_TRACE_EVENT("UIPC_Read : read failed (%s)", strerror(errno));
             return 0;
         }
 
@@ -819,7 +819,7 @@ UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UI
 
 UDRV_API extern BOOLEAN UIPC_Ioctl(tUIPC_CH_ID ch_id, UINT32 request, void *param)
 {
-    BTIF_TRACE_DEBUG2("#### UIPC_Ioctl : ch_id %d, request %d ####", ch_id, request);
+    BTIF_TRACE_DEBUG("#### UIPC_Ioctl : ch_id %d, request %d ####", ch_id, request);
 
     UIPC_LOCK();
 
@@ -830,7 +830,7 @@ UDRV_API extern BOOLEAN UIPC_Ioctl(tUIPC_CH_ID ch_id, UINT32 request, void *para
             break;
 
         case UIPC_REG_CBACK:
-            //BTIF_TRACE_EVENT3("register callback ch %d srvfd %d, fd %d", ch_id, uipc_main.ch[ch_id].srvfd, uipc_main.ch[ch_id].fd);
+            //BTIF_TRACE_EVENT("register callback ch %d srvfd %d, fd %d", ch_id, uipc_main.ch[ch_id].srvfd, uipc_main.ch[ch_id].fd);
             uipc_main.ch[ch_id].cback = (tUIPC_RCV_CBACK*)param;
             break;
 
@@ -849,11 +849,11 @@ UDRV_API extern BOOLEAN UIPC_Ioctl(tUIPC_CH_ID ch_id, UINT32 request, void *para
 
         case UIPC_SET_READ_POLL_TMO:
             uipc_main.ch[ch_id].read_poll_tmo_ms = (int)param;
-            BTIF_TRACE_EVENT2("UIPC_SET_READ_POLL_TMO : CH %d, TMO %d ms", ch_id, uipc_main.ch[ch_id].read_poll_tmo_ms );
+            BTIF_TRACE_EVENT("UIPC_SET_READ_POLL_TMO : CH %d, TMO %d ms", ch_id, uipc_main.ch[ch_id].read_poll_tmo_ms );
             break;
 
         default:
-            BTIF_TRACE_EVENT1("UIPC_Ioctl : request not handled (%d)", request);
+            BTIF_TRACE_EVENT("UIPC_Ioctl : request not handled (%d)", request);
             break;
     }