1 /* 2 * Copyright (c) 2020 HiSilicon (Shanghai) Technologies CO., LIMITED. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 * Description: log printf interface 15 * Author: 16 * Create: 2018-12-01 17 */ 18 19 /* 20 * log example: 21 * 22 * #define MUX_PRINT_INFO(log_id, fmt, count, args...) \ 23 * BASE_PRINT_INFO(CONNECT(LOG_OS_MUTEX, log_id), fmt, count, ##args) 24 * 25 * coding: there must be a param for the count of % in fmt 26 * MUX_PRINT_INFO(log_num, "this is an example %d", ONE_ARG, __LINE__); 27 * 28 */ 29 #ifndef LOG_PRINTF_H 30 #define LOG_PRINTF_H 31 32 #include <stdarg.h> 33 #include <stdint.h> 34 #include "common_def.h" 35 #include "chip_definitions.h" 36 #include "log_types.h" 37 #include "platform_types.h" 38 #include "dfx_feature_config.h" 39 #if (defined (BUILD_APPLICATION_STANDARD) || defined (TEST_SUITE) || CORE == CONTROL_CORE) 40 #ifdef SUPPORT_IPC 41 #include "ipc_actions.h" 42 #endif 43 #include "core.h" 44 #endif 45 46 #ifdef __cplusplus 47 #if __cplusplus 48 extern "C" { 49 #endif 50 #endif 51 /** 52 * @defgroup connectivity_libs_log LOG 53 * @ingroup connectivity_libs 54 * @{ 55 */ 56 #define BTC_MAGIC_LOG_CODE 0xCBCBA 57 #define CONNECT(log_mod, log_id) (((log_mod) << 10) | (log_id)) 58 59 enum log_args_number { 60 NO_ARG, 61 ONE_ARG, 62 TWO_ARG, 63 THREE_ARG, 64 FOUR_ARG, 65 FIVE_ARG, 66 SIX_ARG, 67 SEVEN_ARG, 68 }; 69 70 typedef struct { 71 uint32_t log_id : 10; 72 uint32_t sub_module : 6; 73 uint32_t module : 4; 74 uint32_t domain : 4; 75 uint32_t reserved : 8; 76 } compress_log_code_t; 77 78 /* 79 * + 4 Bits + 4 Bits + 6 Bits + 80 * +------------+------------+----------------+ 81 * | domain | module | sub module | 82 * +------------+------------+----------------+ 83 */ 84 #define LOG_DOMAIN_MAX 12 // each core 4 domains 85 #define LIB_LOG_MODULE_MAX 16 86 #define LOG_SUB_MODULE_MAX 32 87 #define log_sub_module_base(domain, module) (((uint32_t)(domain) << 10) | ((uint32_t)(module) << 6)) 88 89 enum log_domain_e { 90 LOG_DOMAIN_ACORE_BEGIN = 0, 91 LOG_DOMAIN_ACORE_PLT = LOG_DOMAIN_ACORE_BEGIN, 92 LOG_DOMAIN_ACORE_DEV, 93 LOG_DOMAIN_ACORE_APP, 94 LOG_DOMAIN_ACORE_END, 95 96 LOG_DOMAIN_BCORE_BEGIN = 4, 97 LOG_DOMAIN_BCORE_PLT = LOG_DOMAIN_BCORE_BEGIN, 98 LOG_DOMAIN_BCORE_BTH, 99 LOG_DOMAIN_BCORE_BTC, 100 LOG_DOMAIN_BCORE_BTS, 101 LOG_DOMAIN_BCORE_END, 102 103 LOG_DOMAIN_DCORE_BEGIN = 8, 104 LOG_DOMAIN_DCORE_END, 105 }; 106 107 /* --------------------- module enums --------------------- */ 108 enum log_domain_acore_plt_module_e { 109 LOG_DOMAIN_ACORE_PLT_MODULE_OS, 110 LOG_DOMAIN_ACORE_PLT_MODULE_BSP_COMMON, 111 LOG_DOMAIN_ACORE_PLT_MODULE_BSP_DRIVER, 112 LOG_DOMAIN_ACORE_PLT_MODULE_BSP_LIB, 113 LOG_DOMAIN_ACORE_PLT_MODULE_FWK, 114 LOG_DOMAIN_ACORE_PLT_MODULE_UTILS, 115 LOG_DOMAIN_ACORE_PLT_MODULE_FS, 116 LOG_DOMAIN_ACORE_PLT_MODULE_HAUI, 117 LOG_DOMAIN_ACORE_PLT_MODULE_MAX, 118 }; 119 120 enum log_domain_acore_dev_module_e { 121 LOG_DOMAIN_ACORE_DEV_MODULE_AUDIO, 122 LOG_DOMAIN_ACORE_DEV_MODULE_BT, 123 LOG_DOMAIN_ACORE_DEV_MODULE_SENSORS, 124 LOG_DOMAIN_ACORE_DEV_MODULE_MAX, 125 }; 126 127 enum log_domain_acore_app_module_e { 128 LOG_DOMAIN_ACORE_APP_MODULE_UX, 129 LOG_DOMAIN_ACORE_APP_MODULE_MANU, 130 LOG_DOMAIN_ACORE_APP_MODULE_FOTA, 131 LOG_DOMAIN_ACORE_APP_MODULE_MT, 132 LOG_DOMAIN_ACORE_APP_MODULE_POWER, 133 LOG_DOMAIN_ACORE_APP_MODULE_LPC, 134 LOG_DOMAIN_ACORE_APP_MODULE_SENSORS, 135 LOG_DOMAIN_ACORE_APP_MODULE_MAX, 136 }; 137 138 enum log_domain_bcore_plt_module_e { 139 LOG_DOMAIN_BCORE_PLT_MODULE_DRIVER, 140 LOG_DOMAIN_BCORE_PLT_MODULE_LIB, 141 LOG_DOMAIN_BCORE_PLT_MODULE_INFO, 142 LOG_DOMAIN_BCORE_PLT_MODULE_LPM, 143 LOG_DOMAIN_BCORE_PLT_MODULE_MAX, 144 }; 145 146 enum log_domain_bcore_bth_module_e { 147 LOG_DOMAIN_BCORE_BTH_MODULE_TL_ADAPTER, 148 LOG_DOMAIN_BCORE_BTH_MODULE_STACK, 149 LOG_DOMAIN_BCORE_BTH_MODULE_STACK_ADAPTER, 150 LOG_DOMAIN_BCORE_BTH_MODULE_SERVICE, 151 LOG_DOMAIN_BCORE_BTH_MODULE_MAX, 152 }; 153 154 enum log_domain_bcore_btc_module_e { 155 LOG_DOMAIN_BCORE_BTC_MODULE_NORMAL, 156 LOG_DOMAIN_BCORE_BTC_MODULE_STATE, 157 LOG_DOMAIN_BCORE_BTC_MODULE_MESG, 158 LOG_DOMAIN_BCORE_BTC_MODULE_MAX, 159 }; 160 161 enum log_domain_bcore_bts_module_e { 162 LOG_DOMAIN_BCORE_BTS_MODULE_WEAR, 163 LOG_DOMAIN_BCORE_BTS_MODULE_MAX, 164 }; 165 166 /* --------------------- sub module enums --------------------- */ 167 enum log_domain_acore_plt_module_os_sub_mudole_e { 168 LOG_ACORE_PLT_OS_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_OS), 169 LOG_OS_TASK = LOG_ACORE_PLT_OS_BEGIN, 170 LOG_OS_TIMER, 171 LOG_OS_MUTEX, 172 LOG_OS_SEM, 173 LOG_OS_MAIL, 174 LOG_OS_MEM, 175 LOG_ACORE_PLT_OS_END, 176 }; 177 178 enum log_domain_acore_plt_module_bsp_common_sub_mudole_e { 179 LOG_ACORE_PLT_BSP_COMMON_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_BSP_COMMON), 180 LOG_ACORE_PLT_BSP = LOG_ACORE_PLT_BSP_COMMON_BEGIN, 181 LOG_ACORE_PLT_BSP_COMMON_END, 182 }; 183 184 enum log_domain_acore_plt_module_bsp_driver_sub_mudole_e { 185 LOG_ACORE_PLT_BSP_DRIVER_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_BSP_DRIVER), 186 LOG_ACORE_PLT_BSP_DRIVER_CLOCK = LOG_ACORE_PLT_BSP_DRIVER_BEGIN, 187 LOG_ACORE_PLT_BSP_DRIVER_DMA, 188 LOG_ACORE_PLT_BSP_DRIVER_EFLASH, 189 LOG_ACORE_PLT_BSP_DRIVER_I2C, 190 LOG_ACORE_PLT_BSP_DRIVER_SPI, 191 LOG_ACORE_PLT_BSP_DRIVER_UART, 192 LOG_ACORE_PLT_BSP_DRIVER_XIP, 193 LOG_ACORE_PLT_BSP_DRIVER_ADC, 194 LOG_ACORE_PLT_BSP_DRIVER_CAPSENSOR, 195 LOG_ACORE_PLT_BSP_DRIVER_GPIO, 196 LOG_ACORE_PLT_BSP_DRIVER_IPC, 197 LOG_ACORE_PLT_BSP_DRIVER_LPC, 198 LOG_ACORE_PLT_BSP_DRIVER_MEM, 199 LOG_ACORE_PLT_BSP_DRIVER_MPU, 200 LOG_ACORE_PLT_BSP_DRIVER_OTP, 201 LOG_ACORE_PLT_BSP_DRIVER_PMU, 202 LOG_ACORE_PLT_BSP_DRIVER_PWM, 203 LOG_ACORE_PLT_BSP_DRIVER_QSPI, 204 LOG_ACORE_PLT_BSP_DRIVER_REBOOT, 205 LOG_ACORE_PLT_BSP_DRIVER_RTC, 206 LOG_ACORE_PLT_BSP_DRIVER_SYSSTATUS, 207 LOG_ACORE_PLT_BSP_DRIVER_SYSTICK, 208 LOG_ACORE_PLT_BSP_DRIVER_TCXO, 209 LOG_ACORE_PLT_BSP_DRIVER_TIMER, 210 LOG_ACORE_PLT_BSP_DRIVER_TSENSOR, 211 LOG_ACORE_PLT_BSP_DRIVER_WATCHDOG, 212 LOG_ACORE_PLT_BSP_DRIVER_END, 213 }; 214 215 enum log_domain_acore_plt_module_bsp_lib_sub_mudole_e { 216 LOG_ACORE_PLT_BSP_LIB_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_BSP_LIB), 217 LOG_ACORE_PLT_BSP_LIB_LOG = LOG_ACORE_PLT_BSP_LIB_BEGIN, 218 LOG_ACORE_PLT_BSP_LIB_CHR, 219 LOG_ACORE_PLT_BSP_LIB_RPC, 220 LOG_ACORE_PLT_BSP_LIB_UTILS, 221 LOG_ACORE_PLT_BSP_LIB_CONNECTIVITY, 222 LOG_ACORE_PLT_BSP_INFO_STACK, 223 LOG_ACORE_PLT_BSP_INFO_HEAP, 224 LOG_ACORE_PLT_BSP_LPM_SLEEP, 225 LOG_ACORE_PLT_BSP_LPM_VETO, 226 LOG_ACORE_PLT_BSP_LPM_SWITCH_CLK, 227 LOG_ACORE_PLT_BSP_LPM_WFI, 228 LOG_ACORE_PLT_BSP_LIB_END, 229 }; 230 231 enum log_domain_acore_plt_module_fwk_sub_mudole_e { 232 LOG_ACORE_PLT_FWK_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_FWK), 233 LOG_FWK_COMMON = LOG_ACORE_PLT_FWK_BEGIN, 234 LOG_FWK_COMMU, 235 LOG_FWK_AM, 236 LOG_FWK_DM, 237 LOG_FWK_MISC_DEV, 238 LOG_FWK_MISC_SYS, 239 LOG_FWK_FDT_GPIO, 240 LOG_ACORE_PLT_FWK_END, 241 }; 242 243 enum log_domain_acore_plt_module_utils_sub_mudole_e { 244 LOG_ACORE_PLT_UTILS_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_UTILS), 245 LOG_ACORE_PLT_UTILS_COMMON = LOG_ACORE_PLT_UTILS_BEGIN, 246 LOG_ACORE_PLT_UTILS_HELP_CODE, 247 LOG_ACORE_PLT_UTILS_INICONFIG, 248 LOG_ACORE_PLT_UTILS_PROPERTY, 249 LOG_ACORE_PLT_UTILS_DAEMON, 250 LOG_ACORE_PLT_UTILS_SHELL, 251 LOG_ACORE_PLT_UTILS_CIRCLE_QUEUE, 252 LOG_ACORE_PLT_UTILS_FILE_EXTEND, 253 LOG_ACORE_PLT_UTILS_FLASH_EXTEND, 254 LOG_ACORE_PLT_UTILS_EFUSE_EXTEND, 255 LOG_ACORE_PLT_UTILS_SAFE_MODE, 256 LOG_ACORE_PLT_UTILS_KVFS, 257 LOG_ACORE_PLT_UTILS_FDT, 258 LOG_ACORE_PLT_UTILS_END, 259 }; 260 261 enum log_domain_acore_plt_module_fs_sub_mudole_e { 262 LOG_ACORE_PLT_FS_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_FS), 263 LOG_ACORE_PLT_FS = LOG_ACORE_PLT_FS_BEGIN, 264 LOG_ACORE_PLT_FS_END, 265 }; 266 267 enum log_domain_acore_plt_module_haui_sub_mudole_e { 268 LOG_ACORE_PLT_HAUI_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_PLT, LOG_DOMAIN_ACORE_PLT_MODULE_HAUI), 269 LOG_ACORE_PLT_HAUI_SECURE = LOG_ACORE_PLT_HAUI_BEGIN, 270 LOG_ACORE_PLT_HAUI_AES, 271 LOG_ACORE_PLT_HAUI_END, 272 }; 273 274 enum log_domain_acore_dev_module_audio_sub_mudole_e { 275 LOG_ACORE_DEV_AUDIO_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_DEV, LOG_DOMAIN_ACORE_DEV_MODULE_AUDIO), 276 LOG_ACORE_DRV = LOG_ACORE_DEV_AUDIO_BEGIN, 277 LOG_ACORE_DEV_AUDIO_END, 278 }; 279 280 enum log_domain_acore_dev_module_bt_sub_mudole_e { 281 LOG_ACORE_DEV_BT_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_DEV, LOG_DOMAIN_ACORE_DEV_MODULE_BT), 282 LOG_ACORE_DRV_BT, 283 LOG_ACORE_DEV_BT_END, 284 }; 285 286 enum log_domain_acore_dev_module_sensors_sub_mudole_e { 287 LOG_ACORE_DEV_SENSORS_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_DEV, LOG_DOMAIN_ACORE_DEV_MODULE_SENSORS), 288 LOG_ACORE_DRV_SENSORS = LOG_ACORE_DEV_SENSORS_BEGIN, 289 LOG_ACORE_DRV_GSENSOR, 290 LOG_ACORE_DRV_PSENSOR, 291 LOG_ACORE_DRV_CAPSENSOR, 292 LOG_ACORE_DRV_VKSENSOR, 293 LOG_ACORE_DRV_CAPPRESSSENSOR, 294 LOG_ACORE_DEV_SENSORS_END, 295 }; 296 297 enum log_domain_acore_app_module_ux_sub_mudole_e { 298 LOG_ACORE_APP_UX_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_UX), 299 LOG_ACORE_APP_UX_COMMON = LOG_ACORE_APP_UX_BEGIN, 300 LOG_ACORE_APP_UX_AUDIO, 301 LOG_ACORE_APP_UX_BT, 302 LOG_ACORE_APP_UX_CONFIG, 303 LOG_ACORE_APP_UX_MANAGER, 304 LOG_ACORE_APP_UX_BOX, 305 LOG_ACORE_APP_UX_CHARGE, 306 LOG_ACORE_APP_UX_SENSOR, 307 LOG_ACORE_APP_UX_SPP, 308 LOG_ACORE_APP_UX_SECURE, 309 LOG_ACORE_APP_UX_MULTIPLE_DEVICE, 310 LOG_ACORE_APP_UX_END, 311 }; 312 313 enum log_domain_acore_app_module_manu_sub_mudole_e { 314 LOG_ACORE_APP_MANU_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_MANU), 315 LOG_ACORE_APP_MANU_COMMON = LOG_ACORE_APP_MANU_BEGIN, 316 LOG_ACORE_APP_MANU_AT_TEST, 317 LOG_ACORE_APP_MANU_AGE_TEST, 318 LOG_ACORE_APP_MANU_PLAFTORM_TEST, 319 LOG_ACORE_APP_MANU_END, 320 }; 321 322 enum log_domain_acore_app_module_fota_sub_mudole_e { 323 LOG_ACORE_APP_FOTA_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_FOTA), 324 LOG_ACORE_APP_FOTA_COMMON = LOG_ACORE_APP_FOTA_BEGIN, 325 LOG_FOTA_MAIN, 326 LOG_FOTA_MBB, 327 LOG_FOTA_PACKAGE, 328 LOG_FOTA_LINKER, 329 LOG_FOTA_SIGN, 330 LOG_FOTA_NOTIF, 331 LOG_FOTA_PORT, 332 LOG_FOTA_TRANSPROT, 333 LOG_ACORE_APP_FOTA_END, 334 }; 335 336 enum log_domain_acore_app_module_mt_sub_mudole_e { 337 LOG_ACORE_APP_MT_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_MT), 338 LOG_ACORE_APP_MT_COMMON = LOG_ACORE_APP_MT_BEGIN, 339 LOG_ACORE_APP_MT_LOG_CONFIG, 340 LOG_ACORE_APP_MT_MASTER, 341 LOG_ACORE_APP_MT_SLAVE, 342 LOG_ACORE_APP_MT_BOX, 343 LOG_ACORE_APP_MASS_UPLOAD, 344 LOG_ACORE_APP_FILE_TRANS, 345 LOG_ACORE_APP_MT_END, 346 }; 347 348 enum log_domain_acore_app_module_power_sub_mudole_e { 349 LOG_ACORE_APP_POWER_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_POWER), 350 LOG_ACORE_APP_POWER = LOG_ACORE_APP_POWER_BEGIN, 351 LOG_ACORE_APP_POWER_CHARGER, 352 LOG_ACORE_APP_POWER_FUELGAUGE, 353 LOG_ACORE_APP_POWER_BATTERY, 354 LOG_ACORE_APP_POWER_END, 355 }; 356 357 enum log_domain_acore_app_module_lpc_sub_mudole_e { 358 LOG_ACORE_APP_LPC_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_LPC), 359 LOG_ACORE_APP_LPC = LOG_ACORE_APP_LPC_BEGIN, 360 LOG_ACORE_APP_LPC_END, 361 }; 362 363 enum log_domain_acore_app_module_sensors_sub_mudole_e { 364 LOG_ACORE_APP_SENSORS_BEGIN = log_sub_module_base(LOG_DOMAIN_ACORE_APP, LOG_DOMAIN_ACORE_APP_MODULE_SENSORS), 365 LOG_ACORE_APP_BASIC_SENSORS = LOG_ACORE_APP_SENSORS_BEGIN, 366 LOG_ACORE_APP_GESTURE, 367 LOG_ACORE_APP_WEAR, 368 LOG_ACORE_APP_PRESS, 369 LOG_ACORE_APP_SENSORS_END, 370 }; 371 372 enum log_domain_bcore_plt_module_driver_sub_mudole_e { 373 LOG_BCORE_PLT_DRIVER_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_PLT, LOG_DOMAIN_BCORE_PLT_MODULE_DRIVER), 374 LOG_BCORE_PLT = LOG_BCORE_PLT_DRIVER_BEGIN, 375 LOG_BCORE_PLT_DRIVER_CLOCK, 376 LOG_BCORE_PLT_DRIVER_DMA, 377 LOG_BCORE_PLT_DRIVER_EFLASH, 378 LOG_BCORE_PLT_DRIVER_I2C, 379 LOG_BCORE_PLT_DRIVER_SPI, 380 LOG_BCORE_PLT_DRIVER_UART, 381 LOG_BCORE_PLT_DRIVER_XIP, 382 LOG_BCORE_PLT_DRIVER_ADC, 383 LOG_BCORE_PLT_DRIVER_CAPSENSOR, 384 LOG_BCORE_PLT_DRIVER_GPIO, 385 LOG_BCORE_PLT_DRIVER_IPC, 386 LOG_BCORE_PLT_DRIVER_LPC, 387 LOG_BCORE_PLT_DRIVER_MEM, 388 LOG_BCORE_PLT_DRIVER_MPU, 389 LOG_BCORE_PLT_DRIVER_OTP, 390 LOG_BCORE_PLT_DRIVER_PMU, 391 LOG_BCORE_PLT_DRIVER_PWM, 392 LOG_BCORE_PLT_DRIVER_QSPI, 393 LOG_BCORE_PLT_DRIVER_REBOOT, 394 LOG_BCORE_PLT_DRIVER_RTC, 395 LOG_BCORE_PLT_DRIVER_SYSSTATUS, 396 LOG_BCORE_PLT_DRIVER_SYSTICK, 397 LOG_BCORE_PLT_DRIVER_TCXO, 398 LOG_BCORE_PLT_DRIVER_TIMER, 399 LOG_BCORE_PLT_DRIVER_TSENSOR, 400 LOG_BCORE_PLT_DRIVER_WATCHDOG, 401 LOG_BCORE_PLT_DRIVER_IR, 402 LOG_BCORE_PLT_DRIVER_END, 403 }; 404 405 enum log_domain_bcore_plt_module_lib_sub_mudole_e { 406 LOG_BCORE_PLT_LIB_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_PLT, LOG_DOMAIN_BCORE_PLT_MODULE_LIB), 407 LOG_BCORE_PLT_LIB_LOG = LOG_BCORE_PLT_LIB_BEGIN, 408 LOG_BCORE_PLT_LIB_RPC, 409 LOG_BCORE_PLT_LIB_UTILS, 410 LOG_BCORE_PLT_LIB_CONNECTIVITY, 411 LOG_BCORE_PLT_LIB_PANIC, 412 LOG_BCORE_PLT_LIB_END, 413 }; 414 415 enum log_domain_bcore_plt_module_info_sub_mudole_e { 416 LOG_BCORE_PLT_INFO_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_PLT, LOG_DOMAIN_BCORE_PLT_MODULE_LPM), 417 LOG_BCORE_PLT_INFO_STACK = LOG_BCORE_PLT_INFO_BEGIN, 418 LOG_BCORE_PLT_INFO_HEAP, 419 LOG_BCORE_PLT_INFO_TRACE, 420 LOG_BCORE_PLT_INFO_CPU_CLK, 421 LOG_BCORE_PLT_INFO_CODEC_REG, 422 LOG_BCORE_PLT_INFO_RST, 423 LOG_BCORE_PLT_INFO_OS, 424 LOG_BCORE_PLT_INFO_SYS, 425 LOG_BCORE_PLT_INFO_END, 426 }; 427 428 enum log_domain_bcore_plt_module_lpm_sub_mudole_e { 429 LOG_BCORE_PLT_LPM_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_PLT, LOG_DOMAIN_BCORE_PLT_MODULE_LPM), 430 LOG_BCORE_PLT_LPM = LOG_BCORE_PLT_LPM_BEGIN, 431 LOG_BCORE_PLT_LPM_SLEEP, 432 LOG_BCORE_PLT_LPM_VETO, 433 LOG_BCORE_PLT_LPM_SWITCH_CLK, 434 LOG_BCORE_PLT_LPM_WFI, 435 LOG_BCORE_PLT_LPM_CODEC_POWER, 436 LOG_BCORE_PLT_LPM_DSP_POWER, 437 LOG_BCORE_PLT_LPM_CLK0_OUTPUT, 438 LOG_BCORE_PLT_LPM_I2S_CLK, 439 LOG_BCORE_PLT_LPM_MAX, 440 LOG_BCORE_PLT_LPM_END, 441 }; 442 443 enum log_domain_bcore_bth_module_tl_adapter_sub_mudole_e { 444 LOG_BTH_TL_ADAPTER_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTH, LOG_DOMAIN_BCORE_BTH_MODULE_TL_ADAPTER), 445 LOG_BTH_H2C = LOG_BTH_TL_ADAPTER_BEGIN, 446 LOG_BTH_C2H, 447 LOG_BTH_TL_ADAPTER_END, 448 }; 449 450 enum log_domain_bcore_bth_module_stack_sub_mudole_e { 451 LOG_BTH_STACK_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTH, LOG_DOMAIN_BCORE_BTH_MODULE_STACK), 452 LOG_BTH_STACK_GAP = LOG_BTH_STACK_BEGIN, 453 LOG_BTH_STACK_SDP, 454 LOG_BTH_STACK_SMP, 455 LOG_BTH_STACK_A2DP, 456 LOG_BTH_STACK_HFP, 457 LOG_BTH_STACK_AVRCP, 458 LOG_BTH_STACK_SPP, 459 LOG_BTH_STACK_GATT, 460 LOG_BTH_STACK_AVDTP, 461 LOG_BTH_STACK_AVCTP, 462 LOG_BTH_STACK_RFCOMM, 463 LOG_BTH_STACK_L2CAP, 464 LOG_BTH_STACK_HCI, 465 LOG_BTH_STACK_ASCP, 466 LOG_BTH_STACK_ASMP, 467 LOG_BTH_STACK_JITWS, 468 LOG_BTH_STACK_SOCTWS, 469 LOG_BTH_STACK_DADP, 470 LOG_BTH_STACK_FSM, 471 LOG_BTH_STACK_COMMON, 472 LOG_BTH_STACK_END, 473 }; 474 475 enum log_domain_bcore_bth_module_stack_adapter_sub_mudole_e { 476 LOG_BTH_STACK_ADPATER_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTH, LOG_DOMAIN_BCORE_BTH_MODULE_STACK_ADAPTER), 477 LOG_BTH_GAP_ADAPTER = LOG_BTH_STACK_ADPATER_BEGIN, 478 LOG_BTH_A2DP_ADAPTER, 479 LOG_BTH_HFP_ADAPTER, 480 LOG_BTH_AVRCP_ADAPTER, 481 LOG_BTH_SPP_ADAPTER, 482 LOG_BTH_SOCTWS_ADAPTER, 483 LOG_BTH_JITWS_ADAPTER, 484 LOG_BTH_STACK_ADPATER_END, 485 }; 486 487 enum log_domain_bcore_bth_module_service_sub_mudole_e { 488 LOG_BTH_SERVICE_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTH, LOG_DOMAIN_BCORE_BTH_MODULE_SERVICE), 489 LOG_BTH_SERVICE_GAP_SERVICE = LOG_BTH_SERVICE_BEGIN, 490 LOG_BTH_SERVICE_PROFILE_SERVICE, 491 LOG_BTH_SERVICE_CONN_MGR, 492 LOG_BTH_SERVICE_SOCTWS_MGR, 493 LOG_BTH_SERVICE_JITWS_MGR, 494 LOG_BTH_SERVICE_TWS_MGR, 495 LOG_BTH_SERVICE_DTS_MGR, 496 LOG_BTH_SERVICE_DATA_MGR, 497 LOG_BTH_SERVICE_UX_ADPATER, 498 LOG_BTH_SERVICE_NEARBY, 499 LOG_BTH_SERVICE_ICARRY, 500 LOG_BTH_SERVICE_SPA, 501 LOG_BTH_SERVICE_IPC, 502 LOG_BTH_SERVICE_FACTORY, 503 LOG_BTH_SERVICE_GATT_MGR, 504 LOG_BTH_SERVICE_END, 505 }; 506 507 enum log_domain_bcore_btc_module_normal_sub_mudole_e { 508 LOG_BTC_NORMAL_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTC, LOG_DOMAIN_BCORE_BTC_MODULE_NORMAL), 509 LOG_BCORE_BTC = LOG_BTC_NORMAL_BEGIN, 510 LOG_BTC_BT_COMMON, 511 LOG_BTC_BLE, 512 LOG_BTC_ACL, 513 LOG_BTC_WLCOEX, 514 LOG_BTC_SCO, 515 LOG_BTC_WBS, 516 LOG_BTC_RS, 517 LOG_BTC_SNIFF, 518 LOG_BTC_IRQ, 519 LOG_BTC_DATA, 520 LOG_BTC_SLEEP, 521 LOG_BTC_CLOSEME, 522 LOG_BTC_CHNLSCAN, 523 LOG_BTC_EA, 524 LOG_BTC_NORMAL_END, 525 }; 526 527 enum log_domain_bcore_btc_module_state_sub_mudole_e { 528 LOG_BTC_STATE_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTC, LOG_DOMAIN_BCORE_BTC_MODULE_STATE), 529 BT_STATE_GET_ID = LOG_BTC_STATE_BEGIN, 530 BT_STATE_SET_ID, 531 BT_SAVED_STATE_ID, 532 LOG_BTC_STATE_END, 533 }; 534 535 enum log_domain_bcore_btc_module_mesg_sub_mudole_e { 536 LOG_BTC_MESG_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTC, LOG_DOMAIN_BCORE_BTC_MODULE_MESG), 537 BTC_BT_MESGID = LOG_BTC_MESG_BEGIN, 538 BTC_BT_HCI_EVT, 539 BTC_BT_HCI_CMD, 540 BTC_BT_SC_CHK, 541 BTC_BT_FEAT_GET, 542 BTC_BT_LMP_RX_NOR, 543 BTC_BT_LMP_RX_EXT, 544 BTC_BT_LMP_TX_NOR, 545 BTC_BT_LMP_TX_EXT, 546 BTC_BT_ACC_GET, 547 BTC_BT_ACC_NOT_GET, 548 BTC_BT_ACC_EXT_GET, 549 BTC_BT_ACC_NOT_EXT_GET, 550 BTC_BT_TX_CFM_OP_GET, 551 BTC_BT_TX_CFM_EXTOP_GET, 552 BTC_BLE_HCI_EVENT, 553 BTC_BLE_LLD_RX, 554 BTC_BLE_LLCP_RX, 555 BTC_BLE_LLCP_TX, 556 BTC_BT_CIRCLE_COUNT, 557 BTC_BT_CIRCLE_COUNT2, 558 LOG_BTC_MESG_END, 559 }; 560 561 enum log_domain_bcore_bts_module_wear_sub_mudole_e { 562 LOG_BTS_WEAR_BEGIN = log_sub_module_base(LOG_DOMAIN_BCORE_BTS, LOG_DOMAIN_BCORE_BTS_MODULE_WEAR), 563 BTS_WEAR_HFP = LOG_BTS_WEAR_BEGIN, 564 BTS_WEAR_DEV, 565 BTS_WEAR_GDK, 566 BTS_WEAR_CONFIG, 567 BTS_WEAR_COMMON, 568 BTS_WEAR_MPC, 569 BTS_WEAR_PBAP, 570 BTS_WEAR_A2DP, 571 BTS_WEAR_AVRCP, 572 BTS_WEAR_SPP, 573 BTS_WEAR_IAP, 574 BTS_WEAR_IOT, 575 BTS_WEAR_BR_SAIS, 576 BTS_WEAR_VENDOR, 577 BTS_WEAR_BR_CONN_MGR, 578 BTS_WEAR_PERIPHERAL_MGR, 579 BTS_WEAR_DATA_ROUTE, 580 BTS_WEAR_ADV, 581 BTS_WEAR_BLE_CONN_MGR, 582 BTS_WEAR_BLE_SAIS, 583 BTS_WEAR_ALIPAY, 584 BTS_WEAR_ANCS, 585 BTS_WEAR_AMS, 586 BTS_WEAR_HID, 587 BTS_WEAR_SOCECHO_SRV, 588 BTS_WEAR_BTIF, 589 LOG_BTS_WEAR_END, 590 }; 591 592 uint32_t get_chr_basegmt_s(void); 593 void set_chr_basegmt_s(uint32_t t); 594 uint64_t get_log_basetime_ms(void); 595 596 #if (defined (BUILD_APPLICATION_STANDARD) || defined (TEST_SUITE)) 597 #if CORE == APPS 598 void set_log_time(uint32_t rtc_time_s); 599 #else 600 #ifdef IPC_NEW 601 #else 602 bool set_log_time_action_handler(ipc_action_t message, const volatile ipc_payload *payload_p, cores_t src, uint32_t id); 603 #endif 604 #endif 605 #endif 606 607 #if (USE_COMPRESS_LOG_INSTEAD_OF_SDT_LOG == YES) 608 /* 609 * + 4 Bits + 4 Bits + 6 Bits + 10 Bits + 4 Bits + 4 Bits + 610 * +--------------+--------------+------------------+----------+-------------+--------------+ 611 * | log_domain | log_module | log_sub_module | log_id | | | 612 * |--------------+--------------+------------------+----------| log_lvl | args_count | 613 * | log_code<24 Bits> | | | 614 * +-----------------------------------------------------------+-------------+--------------+ 615 */ 616 #define press_params(log_code, log_lvl, args_count) \ 617 (((uint32_t)(log_code) << 8) | ((uint32_t)(log_lvl) << 4) | (uint32_t)(args_count)) 618 #define get_log_code(log_header) (((log_header) >> 8) & 0xFFFFFF) 619 #define get_log_domain(log_header) (((log_header) >> 28) & 0xF) 620 #define get_log_module(log_header) (((log_header) >> 24) & 0xF) 621 #define get_log_sub_module(log_header) (((log_header) >> 18) & 0x3F) 622 #define get_log_id(log_header) (((log_header) >> 8) & 0x3FF) 623 #define get_log_lvl(log_header) (((log_header) >> 4) & 0xF) 624 #define get_log_args_cnt(log_header) ((log_header) & 0xF) 625 626 #define link_line(text1, text2) (text1##text2) 627 #define str_name(text) (link_line(text, __LINE__)) 628 629 #ifndef BUILD_IN_ROM 630 #define BASE_PRINT_WITH_MODULE(log_mod, log_id, log_lvl, fmt, args_count, args...) \ 631 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 632 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 633 press_params(CONNECT(log_mod, log_id), log_lvl, args_count), ##args); \ 634 } while (0) 635 #define BASE_PRINT(log_code, log_lvl, fmt, args_count, args...) \ 636 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 637 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 638 press_params(log_code, log_lvl, args_count), ##args); \ 639 } while (0) 640 #define BASE_PRINT_NON_COMPRESS(log_code, log_lvl, fmt, args_count, args...) 641 #define BASE_PRINT_ERR(log_code, fmt, args_count, args...) \ 642 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 643 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 644 press_params(log_code, LOG_LEVEL_ERROR, args_count), ##args); \ 645 } while (0) 646 #define BASE_PRINT_WARN(log_code, fmt, args_count, args...) \ 647 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 648 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 649 press_params(log_code, LOG_LEVEL_WARNING, args_count), ##args); \ 650 } while (0) 651 #define BASE_PRINT_INFO(log_code, fmt, args_count, args...) \ 652 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 653 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 654 press_params(log_code, LOG_LEVEL_INFO, args_count), ##args); \ 655 } while (0) 656 #define BASE_PRINT_DEBUG(log_code, fmt, args_count, args...) \ 657 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 658 compress_printf((uint32_t)(uintptr)str_name(LOGSTR), \ 659 press_params(log_code, LOG_LEVEL_DBG, args_count), ##args); \ 660 } while (0) 661 662 #define BASE_PRINT_BTC_INFO0(fmt, args...) \ 663 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 664 compress_printf_btc_info0((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 665 } while (0) 666 #define BASE_PRINT_BTC_INFO1(fmt, args...) \ 667 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 668 compress_printf_btc_info1((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 669 } while (0) 670 #define BASE_PRINT_BTC_INFO2(fmt, args...) \ 671 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 672 compress_printf_btc_info2((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 673 } while (0) 674 #define BASE_PRINT_BTC_INFO3(fmt, args...) \ 675 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 676 compress_printf_btc_info3((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 677 } while (0) 678 #define BASE_PRINT_BTC_INFO4(fmt, args...) \ 679 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 680 compress_printf_btc_info4((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 681 } while (0) 682 #define BASE_PRINT_BTC_WARN0(fmt, args...) \ 683 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 684 compress_printf_btc_warn0((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 685 } while (0) 686 #define BASE_PRINT_BTC_WARN1(fmt, args...) \ 687 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 688 compress_printf_btc_warn1((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 689 } while (0) 690 #define BASE_PRINT_BTC_WARN2(fmt, args...) \ 691 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 692 compress_printf_btc_warn2((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 693 } while (0) 694 #define BASE_PRINT_BTC_WARN3(fmt, args...) \ 695 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 696 compress_printf_btc_warn3((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 697 } while (0) 698 #define BASE_PRINT_BTC_WARN4(fmt, args...) \ 699 do {__attribute__((used, section(".logstr"))) static char str_name(LOGSTR)[] = fmt; \ 700 compress_printf_btc_warn4((uint32_t)(uintptr)str_name(LOGSTR), ##args); \ 701 } while (0) 702 703 #endif /* BUILD_IN_ROM */ 704 /** 705 * @brief Compression log printing function 706 */ 707 void compress_printf(uint32_t log_addr, uint32_t log_header, ...); 708 709 /* 710 * + 16 Bits + 10 Bits + 4 Bits + 4 Bits + 711 * +--------------+--------------+------------------+----------+-------------+--------------+ 712 * | log_module | log_id | | | 713 * |--------------+--------------+------------------+----------| log_lvl | args_count | 714 * | LOG_BCORE_BTC | 0 | | | 715 * +-----------------------------------------------------------+-------------+--------------+ 716 */ 717 void compress_printf_btc_info0(uint32_t log_addr, ...); 718 void compress_printf_btc_info1(uint32_t log_addr, ...); 719 void compress_printf_btc_info2(uint32_t log_addr, ...); 720 void compress_printf_btc_info3(uint32_t log_addr, ...); 721 void compress_printf_btc_info4(uint32_t log_addr, ...); 722 void compress_printf_btc_warn0(uint32_t log_addr, ...); 723 void compress_printf_btc_warn1(uint32_t log_addr, ...); 724 void compress_printf_btc_warn2(uint32_t log_addr, ...); 725 void compress_printf_btc_warn3(uint32_t log_addr, ...); 726 void compress_printf_btc_warn4(uint32_t log_addr, ...); 727 /** 728 * @brief Initialization of the compression log threshold 729 */ 730 void compress_log_init(void); 731 /** 732 * @brief Set the compression log threshold 733 * Used for the external interface function of the wear product 734 */ 735 void set_compress_log_count_threshold(uint32_t threshold); 736 /** 737 * @brief Check whether the log printing is within the threshold 738 * return true:within the threshold, return false:exceeded the threshold 739 */ 740 bool check_compress_log_printf_threshold(void); 741 742 /** 743 * @brief Query the log module switch 744 * @param domain domain enum value 745 * @param module module enum value 746 * @return true:on, false:off 747 */ 748 bool log_switch_is_open(uint16_t domain, uint16_t module); 749 750 /** 751 * @brief Switch log on or off 752 * @param domain domain enum value 753 * @param module module enum value 754 * @param op true:on, false:off 755 * @return result SUCC or ERR 756 */ 757 int16_t set_log_switch(uint16_t domain, uint16_t module, bool op); 758 759 /** 760 * @brief Reset log switch to all on or off 761 * @param op true:all on, false:all off 762 * @return None 763 */ 764 void reset_log_switch(bool op); 765 766 /** 767 * @brief Called by core APP to remote config bt and hifi. 768 * @param dst dest core enum 769 * @param domain 770 * @param module 771 * @param op true:all on, false:all off 772 * @return enum ipc_status_t 773 */ 774 uint16_t remote_config_log_switch(cores_t dst, uint16_t domain, uint16_t module, bool op); 775 776 /** 777 * @brief Set the log switch action handler object 778 * @param message 779 * @param payload_p see struct log_switch_cmd_t 780 * @param src 781 * @param id 782 * @return should always true 783 */ 784 bool set_log_switch_action_handler(ipc_action_t message, const volatile ipc_payload *payload_p, 785 cores_t src, uint32_t id); 786 787 #else /* USE_COMPRESS_LOG_INSTEAD_OF_SDT_LOG == NO */ 788 789 /* 790 * + 10 Bits + 14 Bits + 4 Bits + 4 Bits + 791 * +-------------+-------------+-------------+--------------+ 792 * | file_id | log_line | log_lvl | args_count | 793 * +-------------+-------------+-------------+--------------+ 794 */ 795 #define press_params(log_lvl, file_id, log_line, args_count) \ 796 (((uint32_t)(file_id) << 22) | ((uint32_t)(log_line) << 8) | ((uint32_t)(log_lvl) << 4) | (uint32_t)(args_count)) 797 #define get_file_id(log_header) (((log_header) >> 22) & 0x3FF) 798 #define get_log_line(log_header) (((log_header) >> 8) & 0x3FFF) 799 #define get_log_lvl(log_header) (((log_header) >> 4) & 0xF) 800 #define get_log_args_cnt(log_header) ((log_header) & 0xF) 801 802 #define get_log_domain(log_code) (((log_code) >> 20) & 0xF) 803 #define get_log_module(log_code) (((log_code) >> 16) & 0xF) 804 #define get_log_sub_module(log_code) (((log_code) >> 10) & 0x3F) 805 806 #ifndef BUILD_IN_ROM 807 #ifdef BT_USER_RELEASE 808 #define BASE_PRINT_WITH_MODULE(log_mod, log_id, log_lvl, fmt, args_count, args...) \ 809 do { compress_printf_nolog(0, ##args); \ 810 } while (0) 811 #else 812 #define BASE_PRINT_WITH_MODULE(log_mod, log_id, log_lvl, fmt, args_count, args...) \ 813 do { compress_printf(press_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), ##args); \ 814 } while (0) 815 #endif 816 #ifdef BT_ATE 817 #define BASE_PRINT(log_code, log_lvl, fmt, args_count, args...) 818 #else 819 #ifdef BT_USER_RELEASE 820 #define BASE_PRINT(log_code, log_lvl, fmt, args_count, args...) \ 821 do { compress_printf_nolog(0, ##args); \ 822 } while (0) 823 #else 824 #define BASE_PRINT(log_code, log_lvl, fmt, args_count, args...) \ 825 do { compress_printf(press_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), ##args); \ 826 } while (0) 827 #endif 828 #endif 829 #ifdef BT_USER_RELEASE 830 #define BASE_PRINT_NON_COMPRESS(log_code, log_lvl, fmt, args_count, args...) \ 831 do { compress_printf_nolog(0, ##args); \ 832 } while (0) 833 #define BASE_PRINT_ERR(log_code, fmt, args_count, args...) \ 834 do { compress_printf_nolog(0, ##args); \ 835 } while (0) 836 #define BASE_PRINT_WARN(log_code, fmt, args_count, args...) \ 837 do { compress_printf_nolog(0, ##args); \ 838 } while (0) 839 #define BASE_PRINT_INFO(log_code, fmt, args_count, args...) \ 840 do { compress_printf_nolog(0, ##args); \ 841 } while (0) 842 #define BASE_PRINT_DEBUG(log_code, fmt, args_count, args...) \ 843 do { compress_printf_nolog(0, ##args); \ 844 } while (0) 845 #else 846 #define BASE_PRINT_NON_COMPRESS(log_code, log_lvl, fmt, args_count, args...) \ 847 do { compress_printf(press_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), ##args); \ 848 } while (0) 849 #define BASE_PRINT_ERR(log_code, fmt, args_count, args...) \ 850 do { compress_printf(press_params(LOG_LEVEL_ERROR, THIS_FILE_ID, __LINE__, args_count), ##args); \ 851 } while (0) 852 #define BASE_PRINT_WARN(log_code, fmt, args_count, args...) \ 853 do { compress_printf(press_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, args_count), ##args); \ 854 } while (0) 855 #define BASE_PRINT_INFO(log_code, fmt, args_count, args...) \ 856 do { compress_printf(press_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, args_count), ##args); \ 857 } while (0) 858 #define BASE_PRINT_DEBUG(log_code, fmt, args_count, args...) \ 859 do { compress_printf(press_params(LOG_LEVEL_DBG, THIS_FILE_ID, __LINE__, args_count), ##args); \ 860 } while (0) 861 #endif 862 #endif /* BUILD_IN_ROM */ 863 864 void compress_printf(uint32_t log_header, ...); 865 void compress_printf_nolog(uint32_t log_header, ...); 866 #endif /* USE_COMPRESS_LOG_INSTEAD_OF_SDT_LOG */ 867 868 #ifdef BUILD_IN_ROM 869 #define press_user_params(log_code, log_lvl, args_count) \ 870 (((uint32_t)(log_code) << 8) | ((uint32_t)(log_lvl) << 4) | (uint32_t)(args_count)) 871 872 #define press_eng_params(log_lvl, file_id, log_line, args_count) \ 873 (((uint32_t)(file_id) << 22) | ((uint32_t)(log_line) << 8) | ((uint32_t)(log_lvl) << 4) | (uint32_t)(args_count)) 874 875 #define link_line(text1, text2) (text1##text2) 876 #define str_name(text) (link_line(text, __LINE__)) 877 878 #define BASE_PRINT_WITH_MODULE(log_mod, log_id, log_lvl, fmt, args_count, args...) \ 879 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 880 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 881 press_user_params(CONNECT(log_mod, log_id), log_lvl, args_count), \ 882 press_eng_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), \ 883 ##args); \ 884 } while (0) 885 #define BASE_PRINT(log_code, log_lvl, fmt, args_count, args...) \ 886 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 887 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 888 press_user_params(log_code, log_lvl, args_count), \ 889 press_eng_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), \ 890 ##args); \ 891 } while (0) 892 #define BASE_PRINT_NON_COMPRESS(log_code, log_lvl, fmt, args_count, args...) \ 893 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 894 compress_log_no_print_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 895 press_user_params(log_code, log_lvl, args_count), \ 896 press_eng_params(log_lvl, THIS_FILE_ID, __LINE__, args_count), \ 897 ##args); \ 898 } while (0) 899 #define BASE_PRINT_ERR(log_code, fmt, args_count, args...) \ 900 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 901 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 902 press_user_params(log_code, LOG_LEVEL_ERROR, args_count), \ 903 press_eng_params(LOG_LEVEL_ERROR, THIS_FILE_ID, __LINE__, args_count), \ 904 ##args); \ 905 } while (0) 906 #define BASE_PRINT_WARN(log_code, fmt, args_count, args...) \ 907 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 908 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 909 press_user_params(log_code, LOG_LEVEL_WARNING, args_count), \ 910 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, args_count), \ 911 ##args); \ 912 } while (0) 913 #define BASE_PRINT_INFO(log_code, fmt, args_count, args...) \ 914 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 915 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 916 press_user_params(log_code, LOG_LEVEL_INFO, args_count), \ 917 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, args_count), \ 918 ##args); \ 919 } while (0) 920 #define BASE_PRINT_DEBUG(log_code, fmt, args_count, args...) \ 921 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 922 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 923 press_user_params(log_code, LOG_LEVEL_DBG, args_count), \ 924 press_eng_params(LOG_LEVEL_DBG, THIS_FILE_ID, __LINE__, args_count), \ 925 ##args); \ 926 } while (0) 927 928 #define BASE_PRINT_BTC_INFO0(fmt, args...) \ 929 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 930 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 931 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_INFO, NO_ARG), \ 932 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, NO_ARG), \ 933 ##args); \ 934 } while (0) 935 #define BASE_PRINT_BTC_INFO1(fmt, args...) \ 936 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 937 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 938 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_INFO, ONE_ARG), \ 939 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, ONE_ARG), \ 940 ##args); \ 941 } while (0) 942 #define BASE_PRINT_BTC_INFO2(fmt, args...) \ 943 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 944 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 945 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_INFO, TWO_ARG), \ 946 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, TWO_ARG), \ 947 ##args); \ 948 } while (0) 949 #define BASE_PRINT_BTC_INFO3(fmt, args...) \ 950 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 951 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 952 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_INFO, THREE_ARG), \ 953 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, THREE_ARG), \ 954 ##args); \ 955 } while (0) 956 #define BASE_PRINT_BTC_INFO4(fmt, args...) \ 957 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 958 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 959 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_INFO, FOUR_ARG), \ 960 press_eng_params(LOG_LEVEL_INFO, THIS_FILE_ID, __LINE__, FOUR_ARG), \ 961 ##args); \ 962 } while (0) 963 #define BASE_PRINT_BTC_WARN0(fmt, args...) \ 964 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 965 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 966 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_WARNING, NO_ARG), \ 967 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, NO_ARG), \ 968 ##args); \ 969 } while (0) 970 #define BASE_PRINT_BTC_WARN1(fmt, args...) \ 971 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 972 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 973 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_WARNING, ONE_ARG), \ 974 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, ONE_ARG), \ 975 ##args); \ 976 } while (0) 977 #define BASE_PRINT_BTC_WARN2(fmt, args...) \ 978 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 979 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 980 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_WARNING, TWO_ARG), \ 981 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, TWO_ARG), \ 982 ##args); \ 983 } while (0) 984 #define BASE_PRINT_BTC_WARN3(fmt, args...) \ 985 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 986 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 987 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_WARNING, THREE_ARG), \ 988 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, THREE_ARG), \ 989 ##args); \ 990 } while (0) 991 #define BASE_PRINT_BTC_WARN4(fmt, args...) \ 992 do {__attribute__((used, section(".rom_logstr"))) static char str_name(LOGSTR)[] = fmt; \ 993 compress_printf_in_rom((uint32_t)(uintptr)str_name(LOGSTR), \ 994 press_user_params(CONNECT((0 + LOG_BCORE_BTC), 0), LOG_LEVEL_WARNING, FOUR_ARG), \ 995 press_eng_params(LOG_LEVEL_WARNING, THIS_FILE_ID, __LINE__, FOUR_ARG), \ 996 ##args); \ 997 } while (0) 998 999 #endif /* BUILD_IN_ROM */ 1000 1001 void compress_printf_in_rom(uint32_t log_addr, uint32_t log_header_user, uint32_t log_header_eng, ...); 1002 void compress_printf_rom_callback(uint32_t log_addr, uint32_t log_header_user, uint32_t log_header_eng, va_list args); 1003 void compress_log_no_print_in_rom(uint32_t log_addr, uint32_t log_header_user, uint32_t log_header_eng, ...); 1004 void compress_log_no_print_rom_callback(uint32_t log_addr, uint32_t log_header_user, 1005 uint32_t log_header_eng, va_list args); 1006 1007 /** 1008 * @} 1009 */ 1010 1011 #ifdef __cplusplus 1012 #if __cplusplus 1013 } 1014 #endif 1015 #endif 1016 1017 #endif 1018