main/bte_logmsg.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2001-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  Contains the LogMsg wrapper routines for BTE.  It routes calls the
  22  *  appropriate application's LogMsg equivalent.
  23  *
  24  ******************************************************************************/
  25
  26 #include <assert.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdarg.h>
  31
  32 #include "config.h"
  33 #include "gki.h"
  34 #include "bte.h"
  35
  36 #include "bte_appl.h"
  37
  38 #if MMI_INCLUDED == TRUE
  39 #include "mmi.h"
  40 #endif
  41
  42 /* always enable trace framework */
  43
  44 #include "btu.h"
  45 #include "l2c_api.h"
  46 #if (RFCOMM_INCLUDED==TRUE)
  47 #include "port_api.h"
  48 #endif
  49 #if (OBX_INCLUDED==TRUE)
  50 #include "obx_api.h"
  51 #endif
  52 #if (AVCT_INCLUDED==TRUE)
  53 #include "avct_api.h"
  54 #endif
  55 #if (AVDT_INCLUDED==TRUE)
  56 #include "avdt_api.h"
  57 #endif
  58 #if (AVRC_INCLUDED==TRUE)
  59 #include "avrc_api.h"
  60 #endif
  61 #if (AVDT_INCLUDED==TRUE)
  62 #include "avdt_api.h"
  63 #endif
  64 #if (A2D_INCLUDED==TRUE)
  65 #include "a2d_api.h"
  66 #endif
  67 #if (BIP_INCLUDED==TRUE)
  68 #include "bip_api.h"
  69 #endif
  70 #if (BNEP_INCLUDED==TRUE)
  71 #include "bnep_api.h"
  72 #endif
  73 #if (BPP_INCLUDED==TRUE)
  74 #include "bpp_api.h"
  75 #endif
  76 #include "btm_api.h"
  77 #if (DUN_INCLUDED==TRUE)
  78 #include "dun_api.h"
  79 #endif
  80 #if (GAP_INCLUDED==TRUE)
  81 #include "gap_api.h"
  82 #endif
  83 #if (GOEP_INCLUDED==TRUE)
  84 #include "goep_util.h"
  85 #endif
  86 #if (HCRP_INCLUDED==TRUE)
  87 #include "hcrp_api.h"
  88 #endif
  89 #if (PAN_INCLUDED==TRUE)
  90 #include "pan_api.h"
  91 #endif
  92 #include "sdp_api.h"
  93
  94 #if (BLE_INCLUDED==TRUE)
  95 #include "gatt_api.h"
  96 #include "smp_api.h"
  97 #endif
  98
  99     /* LayerIDs for BTA, currently everything maps onto appl_trace_level */
 100 #if (BTA_INCLUDED==TRUE)
 101 #include "bta_api.h"
 102 #endif
 103
 104
 105 #if defined(__CYGWIN__) || defined(__linux__)
 106 #undef RPC_INCLUDED
 107 #define RPC_INCLUDED TRUE
 108
 109 #include <sys/time.h>
 110 #include <time.h>
 111
 112 #if (defined(ANDROID_USE_LOGCAT) && (ANDROID_USE_LOGCAT==TRUE))
 113 const char * const bt_layer_tags[] = {
 114     "bt-btif",
 115     "bt-usb",
 116     "bt-serial",
 117     "bt-socket",
 118     "bt-rs232",
 119     "bt-lc",
 120     "bt-lm",
 121     "bt-hci",
 122     "bt-l2cap",
 123     "bt-rfcomm",
 124     "bt-sdp",
 125     "bt-tcs",
 126     "bt-obex",
 127     "bt-btm",
 128     "bt-gap",
 129     "bt-dun",
 130     "bt-goep",
 131     "bt-icp",
 132     "bt-hsp2",
 133     "bt-spp",
 134     "bt-ctp",
 135     "bt-bpp",
 136     "bt-hcrp",
 137     "bt-ftp",
 138     "bt-opp",
 139     "bt-btu",
 140     "bt-gki",
 141     "bt-bnep",
 142     "bt-pan",
 143     "bt-hfp",
 144     "bt-hid",
 145     "bt-bip",
 146     "bt-avp",
 147     "bt-a2d",
 148     "bt-sap",
 149     "bt-amp",
 150     "bt-mca",
 151     "bt-att",
 152     "bt-smp",
 153     "bt-nfc",
 154     "bt-nci",
 155     "bt-idep",
 156     "bt-ndep",
 157     "bt-llcp",
 158     "bt-rw",
 159     "bt-ce",
 160     "bt-snep",
 161     "bt-ndef",
 162     "bt-nfa",
 163 };
 164
 165 #ifndef LINUX_NATIVE
 166 #include <cutils/log.h>
 167 #define LOGI0(t,s) __android_log_write(ANDROID_LOG_INFO, t, s)
 168 #define LOGD0(t,s) __android_log_write(ANDROID_LOG_DEBUG, t, s)
 169 #define LOGW0(t,s) __android_log_write(ANDROID_LOG_WARN, t, s)
 170 #define LOGE0(t,s) __android_log_write(ANDROID_LOG_ERROR, t, s)
 171
 172 #else
 173 #undef ANDROID_USE_LOGCAT
 174 #endif
 175
 176 #endif
 177
 178
 179 //#include "btl_cfg.h"
 180 #define BTL_GLOBAL_PROP_TRC_FLAG "TRC_BTAPP"
 181 #ifndef DEFAULT_CONF_TRACE_LEVEL
 182 #define DEFAULT_CONF_TRACE_LEVEL BT_TRACE_LEVEL_WARNING
 183 #endif
 184
 185 #ifndef BTE_LOG_BUF_SIZE
 186 #define BTE_LOG_BUF_SIZE  1024
 187 #endif
 188 #define BTE_LOG_MAX_SIZE  (BTE_LOG_BUF_SIZE - 12)
 189
 190
 191 //#define BTE_MAP_TRACE_LEVEL FALSE
 192 /* map by default BTE trace levels onto android trace levels */
 193 #ifndef BTE_MAP_TRACE_LEVEL
 194 #define BTE_MAP_TRACE_LEVEL TRUE
 195 #endif
 196
 197 // #define BTE_ANDROID_INTERNAL_TIMESTAMP TRUE
 198 /* by default no internal timestamp. adb logcate -v time allows having timestamps */
 199 #ifndef BTE_ANDROID_INTERNAL_TIMESTAMP
 200 #define BTE_ANDROID_INTERNAL_TIMESTAMP FALSE
 201 #endif
 202 #if (BTE_ANDROID_INTERNAL_TIMESTAMP==TRUE)
 203 #define MSG_BUFFER_OFFSET strlen(buffer)
 204 #else
 205 #define MSG_BUFFER_OFFSET 0
 206 #endif
 207
 208 //#define DBG_TRACE
 209
 210 #if defined( DBG_TRACE )
 211 #define DBG_TRACE_API0( m ) BT_TRACE( TRACE_LAYER_HCI, TRACE_TYPE_API, m )
 212 #define DBG_TRACE_WARNING2( m, p0, p1 ) BT_TRACE( TRACE_LAYER_BTM, (TRACE_ORG_APPL|TRACE_TYPE_WARNING), m, p0, p1 )
 213 #else
 214 #define DBG_TRACE_API0( m )
 215 #define DBG_TRACE_WARNING2( m, p0, p1 )
 216 #endif
 217 #define DBG_TRACE_DEBUG2( m, p0, p1 ) BT_TRACE( TRACE_LAYER_BTM, (TRACE_ORG_APPL|TRACE_TYPE_DEBUG), m, p0, p1 )
 218
 219 void
 220 LogMsg(UINT32 trace_set_mask, const char *fmt_str, ...)
 221 {
 222         static char buffer[BTE_LOG_BUF_SIZE];
 223     int trace_layer = TRACE_GET_LAYER(trace_set_mask);
 224     if (trace_layer >= TRACE_LAYER_MAX_NUM)
 225         trace_layer = 0;
 226
 227         va_list ap;
 228 #if (BTE_ANDROID_INTERNAL_TIMESTAMP==TRUE)
 229         struct timeval tv;
 230         struct timezone tz;
 231         struct tm *tm;
 232         time_t t;
 233
 234         gettimeofday(&tv, &tz);
 235         time(&t);
 236         tm = localtime(&t);
 237
 238     sprintf(buffer, "%02d:%02d:%02d.%03d ", tm->tm_hour, tm->tm_min, tm->tm_sec,
 239         tv.tv_usec / 1000);
 240 #endif
 241         va_start(ap, fmt_str);
 242         vsnprintf(&buffer[MSG_BUFFER_OFFSET], BTE_LOG_MAX_SIZE, fmt_str, ap);
 243         va_end(ap);
 244
 245 #if (defined(ANDROID_USE_LOGCAT) && (ANDROID_USE_LOGCAT==TRUE))
 246 #if (BTE_MAP_TRACE_LEVEL==TRUE)
 247     switch ( TRACE_GET_TYPE(trace_set_mask) )
 248     {
 249         case TRACE_TYPE_ERROR:
 250             LOGE0(bt_layer_tags[trace_layer], buffer);
 251             break;
 252         case TRACE_TYPE_WARNING:
 253             LOGW0(bt_layer_tags[trace_layer], buffer);
 254             break;
 255         case TRACE_TYPE_API:
 256         case TRACE_TYPE_EVENT:
 257             LOGI0(bt_layer_tags[trace_layer], buffer);
 258             break;
 259         case TRACE_TYPE_DEBUG:
 260             LOGD0(bt_layer_tags[trace_layer], buffer);
 261             break;
 262         default:
 263             LOGE0(bt_layer_tags[trace_layer], buffer);      /* we should never get this */
 264             break;
 265     }
 266 #else
 267     LOGI0(bt_layer_tags[trace_layer], buffer);
 268 #endif
 269 #else
 270         write(2, buffer, strlen(buffer));
 271         write(2, "\n", 1);
 272 #endif
 273 }
 274
 275 void
 276 ScrLog(UINT32 trace_set_mask, const char *fmt_str, ...)
 277 {
 278         static char buffer[BTE_LOG_BUF_SIZE];
 279
 280         va_list ap;
 281         struct timeval tv;
 282         struct timezone tz;
 283         struct tm *tm;
 284         time_t t;
 285     int trace_layer = TRACE_GET_LAYER(trace_set_mask);
 286     if (trace_layer >= TRACE_LAYER_MAX_NUM)
 287         trace_layer = 0;
 288         gettimeofday(&tv, &tz);
 289         time(&t);
 290         tm = localtime(&t);
 291
 292         sprintf(buffer, "%02d:%02d:%02d.%03ld ", tm->tm_hour, tm->tm_min, tm->tm_sec,
 293         tv.tv_usec / 1000);
 294
 295         va_start(ap, fmt_str);
 296         vsnprintf(&buffer[strlen(buffer)], BTE_LOG_MAX_SIZE, fmt_str, ap);
 297         va_end(ap);
 298
 299 #if (defined(ANDROID_USE_LOGCAT) && (ANDROID_USE_LOGCAT==TRUE))
 300     LOGI0(bt_layer_tags[trace_layer], buffer);
 301 #else
 302         write(2, buffer, strlen(buffer));
 303         write(2, "\n", 1);
 304 #endif
 305 }
 306
 307 /* this function should go into BTAPP_DM for example */
 308 BT_API UINT8 BTAPP_SetTraceLevel( UINT8 new_level )
 309 {
 310     if (new_level != 0xFF)
 311         appl_trace_level = new_level;
 312
 313     return (appl_trace_level);
 314 }
 315
 316 BT_API UINT8 BTIF_SetTraceLevel( UINT8 new_level )
 317 {
 318     if (new_level != 0xFF)
 319         btif_trace_level = new_level;
 320
 321     return (btif_trace_level);
 322 }
 323
 324 BTU_API UINT8 BTU_SetTraceLevel( UINT8 new_level )
 325 {
 326     if (new_level != 0xFF)
 327         btu_cb.trace_level = new_level;
 328
 329     return (btu_cb.trace_level);
 330 }
 331
 332 BOOLEAN trace_conf_enabled = FALSE;
 333
 334 void bte_trace_conf(const char *p_conf_name, const char *p_conf_value)
 335 {
 336     tBTTRC_FUNC_MAP *p_f_map = (tBTTRC_FUNC_MAP *) &bttrc_set_level_map[0];
 337
 338     while (p_f_map->trc_name != NULL)
 339     {
 340         if (strcmp(p_f_map->trc_name, (const char *)p_conf_name) == 0)
 341         {
 342             p_f_map->trace_level = (UINT8) atoi(p_conf_value);
 343             break;
 344         }
 345         p_f_map++;
 346     }
 347 }
 348
 349 void bte_trace_conf_config(const config_t *config) {
 350   assert(config != NULL);
 351
 352   for (tBTTRC_FUNC_MAP *functions = &bttrc_set_level_map[0]; functions->trc_name; ++functions) {
 353     int value = config_get_int(config, CONFIG_DEFAULT_SECTION, functions->trc_name, -1);
 354     if (value != -1)
 355       functions->trace_level = value;
 356   }
 357 }
 358
 359 /********************************************************************************
 360  **
 361  **    Function Name:    BTA_SysSetTraceLevel
 362  **
 363  **    Purpose:          set or reads the different Trace Levels of layer IDs (see bt_trace.h,
 364  **                      BTTRC_ID_xxxx
 365  **
 366  **    Input Parameters: Array with trace layers to set to a given level or read. a layer ID of 0
 367  **                      defines the end of the list
 368  **                      WARNING: currently type should be 0-5! or FF for reading!!!!
 369  **
 370  **    Returns:
 371  **                      input array with trace levels for given layer id
 372  **
 373  *********************************************************************************/
 374 BT_API tBTTRC_LEVEL * BTA_SysSetTraceLevel(tBTTRC_LEVEL * p_levels)
 375 {
 376     const tBTTRC_FUNC_MAP *p_f_map;
 377     tBTTRC_LEVEL *p_l = p_levels;
 378
 379     DBG_TRACE_API0( "BTA_SysSetTraceLevel()" );
 380
 381     while (0 != p_l->layer_id)
 382     {
 383         p_f_map = &bttrc_set_level_map[0];
 384
 385         while (0 != p_f_map->layer_id_start)
 386         {
 387             printf("BTA_SysSetTraceLevel - trace id in map start = %d end= %d,  paramter id = %d\r\n", p_f_map->layer_id_start, p_f_map->layer_id_end, p_l->layer_id );
 388             /* as p_f_map is ordered by increasing layer id, go to next map entry as long end id
 389              * is smaller */
 390             //if (p_f_map->layer_id_end < p_l->layer_id)
 391             //{
 392                 //p_f_map++;
 393             //}
 394             //else
 395             {
 396                 /* check if layer_id actually false into a range or if it is note existing in the  map */
 397                 if ((NULL != p_f_map->p_f) && (p_f_map->layer_id_start <= p_l->layer_id) && (p_f_map->layer_id_end >= p_l->layer_id) )
 398                 {
 399                     DBG_TRACE_DEBUG2( "BTA_SysSetTraceLevel( id:%d, level:%d ): setting/reading",
 400                             p_l->layer_id, p_l->type );
 401                     p_l->type = p_f_map->p_f(p_l->type);
 402                     break;
 403                 }
 404                 else
 405                 {
 406                     DBG_TRACE_WARNING2( "BTA_SysSetTraceLevel( id:%d, level:%d ): MISSING Set function OR ID in map!",
 407                             p_l->layer_id, p_l->type );
 408                 }
 409                 /* set/read next trace level by getting out ot map loop */
 410                 //p_l++;
 411                 //break;
 412             }
 413             p_f_map++;
 414         }
 415         //if (0 == p_f_map->layer_id_start)
 416         {
 417             DBG_TRACE_WARNING2( "BTA_SysSetTraceLevel( id:%d, level:%d ): ID NOT FOUND in map. Skip to next",
 418                     p_l->layer_id, p_l->type );
 419             p_l++;
 420         }
 421     }
 422
 423     return p_levels;
 424 } /* BTA_SysSetTraceLevel() */
 425
 426 /* make sure list is order by increasing layer id!!! */
 427 tBTTRC_FUNC_MAP bttrc_set_level_map[] = {
 428     {BTTRC_ID_STK_BTU, BTTRC_ID_STK_HCI, BTU_SetTraceLevel, "TRC_HCI", DEFAULT_CONF_TRACE_LEVEL},
 429     {BTTRC_ID_STK_L2CAP, BTTRC_ID_STK_L2CAP, L2CA_SetTraceLevel, "TRC_L2CAP", DEFAULT_CONF_TRACE_LEVEL},
 430 #if (RFCOMM_INCLUDED==TRUE)
 431     {BTTRC_ID_STK_RFCOMM, BTTRC_ID_STK_RFCOMM_DATA, PORT_SetTraceLevel, "TRC_RFCOMM", DEFAULT_CONF_TRACE_LEVEL},
 432 #endif
 433 #if (OBX_INCLUDED==TRUE)
 434     {BTTRC_ID_STK_OBEX, BTTRC_ID_STK_OBEX, OBX_SetTraceLevel, "TRC_OBEX", DEFAULT_CONF_TRACE_LEVEL},
 435 #endif
 436 #if (AVCT_INCLUDED==TRUE)
 437     //{BTTRC_ID_STK_AVCT, BTTRC_ID_STK_AVCT, NULL, "TRC_AVCT", DEFAULT_CONF_TRACE_LEVEL},
 438 #endif
 439 #if (AVDT_INCLUDED==TRUE)
 440     {BTTRC_ID_STK_AVDT, BTTRC_ID_STK_AVDT, AVDT_SetTraceLevel, "TRC_AVDT", DEFAULT_CONF_TRACE_LEVEL},
 441 #endif
 442 #if (AVRC_INCLUDED==TRUE)
 443     {BTTRC_ID_STK_AVRC, BTTRC_ID_STK_AVRC, AVRC_SetTraceLevel, "TRC_AVRC", DEFAULT_CONF_TRACE_LEVEL},
 444 #endif
 445 #if (AVDT_INCLUDED==TRUE)
 446     //{BTTRC_ID_AVDT_SCB, BTTRC_ID_AVDT_CCB, NULL, "TRC_AVDT_SCB", DEFAULT_CONF_TRACE_LEVEL},
 447 #endif
 448 #if (A2D_INCLUDED==TRUE)
 449     {BTTRC_ID_STK_A2D, BTTRC_ID_STK_A2D, A2D_SetTraceLevel, "TRC_A2D", DEFAULT_CONF_TRACE_LEVEL},
 450 #endif
 451 #if (BIP_INCLUDED==TRUE)
 452     {BTTRC_ID_STK_BIP, BTTRC_ID_STK_BIP, BIP_SetTraceLevel, "TRC_BIP", DEFAULT_CONF_TRACE_LEVEL},
 453 #endif
 454 #if (BNEP_INCLUDED==TRUE)
 455     {BTTRC_ID_STK_BNEP, BTTRC_ID_STK_BNEP, BNEP_SetTraceLevel, "TRC_BNEP", DEFAULT_CONF_TRACE_LEVEL},
 456 #endif
 457 #if (BPP_INCLUDED==TRUE)
 458     {BTTRC_ID_STK_BPP, BTTRC_ID_STK_BPP, BPP_SetTraceLevel, "TRC_BPP", DEFAULT_CONF_TRACE_LEVEL},
 459 #endif
 460     {BTTRC_ID_STK_BTM_ACL, BTTRC_ID_STK_BTM_SEC, BTM_SetTraceLevel, "TRC_BTM", DEFAULT_CONF_TRACE_LEVEL},
 461 #if (DUN_INCLUDED==TRUE)
 462     {BTTRC_ID_STK_DUN, BTTRC_ID_STK_DUN, DUN_SetTraceLevel, "TRC_DUN", DEFAULT_CONF_TRACE_LEVEL},
 463 #endif
 464 #if (GAP_INCLUDED==TRUE)
 465     {BTTRC_ID_STK_GAP, BTTRC_ID_STK_GAP, GAP_SetTraceLevel, "TRC_GAP", DEFAULT_CONF_TRACE_LEVEL},
 466 #endif
 467 #if (GOEP_INCLUDED==TRUE)
 468     {BTTRC_ID_STK_GOEP, BTTRC_ID_STK_GOEP, GOEP_SetTraceLevel, "TRC_GOEP", DEFAULT_CONF_TRACE_LEVEL},
 469 #endif
 470 #if (HCRP_INCLUDED==TRUE)
 471     {BTTRC_ID_STK_HCRP, BTTRC_ID_STK_HCRP, HCRP_SetTraceLevel, "TRC_HCRP", DEFAULT_CONF_TRACE_LEVEL},
 472 #endif
 473 #if (PAN_INCLUDED==TRUE)
 474     {BTTRC_ID_STK_PAN, BTTRC_ID_STK_PAN, PAN_SetTraceLevel, "TRC_PAN", DEFAULT_CONF_TRACE_LEVEL},
 475 #endif
 476 #if (SAP_SERVER_INCLUDED==TRUE)
 477     {BTTRC_ID_STK_SAP, BTTRC_ID_STK_SAP, NULL, "TRC_SAP", DEFAULT_CONF_TRACE_LEVEL},
 478 #endif
 479     {BTTRC_ID_STK_SDP, BTTRC_ID_STK_SDP, SDP_SetTraceLevel, "TRC_SDP", DEFAULT_CONF_TRACE_LEVEL},
 480 #if (BLE_INCLUDED==TRUE)
 481     {BTTRC_ID_STK_GATT, BTTRC_ID_STK_GATT, GATT_SetTraceLevel, "TRC_GATT", DEFAULT_CONF_TRACE_LEVEL},
 482     {BTTRC_ID_STK_SMP, BTTRC_ID_STK_SMP, SMP_SetTraceLevel, "TRC_SMP", DEFAULT_CONF_TRACE_LEVEL},
 483 #endif
 484
 485 #if (BTA_INCLUDED==TRUE)
 486     /* LayerIDs for BTA, currently everything maps onto appl_trace_level.
 487      * BTL_GLOBAL_PROP_TRC_FLAG serves as flag in conf.
 488      */
 489     {BTTRC_ID_BTA_ACC, BTTRC_ID_BTAPP, BTAPP_SetTraceLevel, BTL_GLOBAL_PROP_TRC_FLAG, DEFAULT_CONF_TRACE_LEVEL},
 490 #endif
 491
 492 #if (BT_TRACE_BTIF == TRUE)
 493     {BTTRC_ID_BTA_ACC, BTTRC_ID_BTAPP, BTIF_SetTraceLevel, "TRC_BTIF", DEFAULT_CONF_TRACE_LEVEL},
 494 #endif
 495
 496     {0, 0, NULL, NULL, DEFAULT_CONF_TRACE_LEVEL}
 497 };
 498
 499 const UINT16 bttrc_map_size = sizeof(bttrc_set_level_map)/sizeof(tBTTRC_FUNC_MAP);
 500 #endif
 501
 502 /********************************************************************************
 503  **
 504  **    Function Name:     BTE_InitTraceLevels
 505  **
 506  **    Purpose:           This function can be used to set the boot time reading it from the
 507  **                       platform.
 508  **                       WARNING: it is called under BTU context and it blocks the BTU task
 509  **                       till it returns (sync call)
 510  **
 511  **    Input Parameters:  None, platform to provide levels
 512  **    Returns:
 513  **                       Newly set levels, if any!
 514  **
 515  *********************************************************************************/
 516 BT_API void BTE_InitTraceLevels( void )
 517 {
 518     /* read and set trace levels by calling the different XXX_SetTraceLevel().
 519      */
 520 #if ( BT_USE_TRACES==TRUE )
 521     if (trace_conf_enabled == TRUE)
 522     {
 523         tBTTRC_FUNC_MAP *p_f_map = (tBTTRC_FUNC_MAP *) &bttrc_set_level_map[0];
 524
 525         while (p_f_map->trc_name != NULL)
 526         {
 527             ALOGI("BTE_InitTraceLevels -- %s", p_f_map->trc_name);
 528
 529             if (p_f_map->p_f)
 530                 p_f_map->p_f(p_f_map->trace_level);
 531
 532             p_f_map++;
 533         }
 534     }
 535     else
 536     {
 537         ALOGI("[bttrc] using compile default trace settings");
 538     }
 539 #endif
 540 }