1 /* 2 * Copyright (c) 2014-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /** 21 * DOC: i_qdf_trace.h 22 * 23 * Linux-specific definitions for QDF trace 24 * 25 */ 26 27 #if !defined(__I_QDF_TRACE_H) 28 #define __I_QDF_TRACE_H 29 30 /* older kernels have a bug in kallsyms, so ensure module.h is included */ 31 #include <linux/module.h> 32 #include <linux/kallsyms.h> 33 #ifdef CONFIG_QCA_MINIDUMP 34 #include <linux/minidump_tlv.h> 35 #endif 36 37 /* 38 * The CONFIG_QCOM_MINIDUMP feature can only be used 39 * beginning with kernel version msm-4.19 since that is 40 * when msm_minidump_removerefion() was added. 41 */ 42 #if IS_ENABLED(CONFIG_QCOM_MINIDUMP) && \ 43 (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0)) 44 #if IS_ENABLED(CONFIG_QCOM_VA_MINIDUMP) 45 #define WLAN_QCOM_VA_MINIDUMP 46 #else 47 #define WLAN_QCOM_MINIDUMP 48 #endif 49 50 #include <soc/qcom/minidump.h> 51 #endif 52 53 #if !defined(__printf) 54 #define __printf(a, b) 55 #endif 56 57 /* QDF_TRACE is the macro invoked to add trace messages to code. See the 58 * documenation for qdf_trace_msg() for the parameters etc. for this function. 59 * 60 * NOTE: Code QDF_TRACE() macros into the source code. Do not code directly 61 * to the qdf_trace_msg() function. 62 * 63 * NOTE 2: qdf tracing is totally turned off if WLAN_DEBUG is *not* defined. 64 * This allows us to build 'performance' builds where we can measure performance 65 * without being bogged down by all the tracing in the code 66 */ 67 #if defined(QDF_TRACE_PRINT_ENABLE) 68 #define qdf_trace(log_level, args...) \ 69 do { \ 70 extern int qdf_dbg_mask; \ 71 if (qdf_dbg_mask >= log_level) { \ 72 printk(args); \ 73 printk("\n"); \ 74 } \ 75 } while (0) 76 #endif 77 78 #if defined(WLAN_DEBUG) || defined(DEBUG) || defined(QDF_TRACE_PRINT_ENABLE) 79 #define QDF_TRACE qdf_trace_msg 80 #define QDF_VTRACE qdf_vtrace_msg 81 #define QDF_TRACE_HEX_DUMP qdf_trace_hex_dump 82 #else 83 #define QDF_TRACE(arg ...) __qdf_trace_dummy(arg) 84 #define QDF_VTRACE(arg ...) __qdf_vtrace_dummy(arg) 85 #define QDF_TRACE_HEX_DUMP(arg ...) __qdf_trace_hexdump_dummy(arg) 86 #endif 87 88 #if defined(WLAN_DEBUG) || defined(DEBUG) || defined(QDF_TRACE_PRINT_ENABLE) 89 #define QDF_MAX_LOGS_PER_SEC 2 90 /** 91 * __QDF_TRACE_RATE_LIMITED() - rate limited version of QDF_TRACE 92 * @params: parameters to pass through to QDF_TRACE 93 * 94 * This API prevents logging a message more than QDF_MAX_LOGS_PER_SEC times per 95 * second. This means any subsequent calls to this API from the same location 96 * within 1/QDF_MAX_LOGS_PER_SEC seconds will be dropped. 97 * 98 * Return: None 99 */ 100 #define __QDF_TRACE_RATE_LIMITED(params...)\ 101 do {\ 102 static ulong __last_ticks;\ 103 ulong __ticks = jiffies;\ 104 if (time_after(__ticks,\ 105 __last_ticks + HZ / QDF_MAX_LOGS_PER_SEC)) {\ 106 QDF_TRACE(params);\ 107 __last_ticks = __ticks;\ 108 } \ 109 } while (0) 110 111 #define __QDF_TRACE_HEX_DUMP_RATE_LIMITED(params...)\ 112 do {\ 113 static ulong __last_ticks;\ 114 ulong __ticks = jiffies;\ 115 if (time_after(__ticks,\ 116 __last_ticks + HZ / QDF_MAX_LOGS_PER_SEC)) {\ 117 QDF_TRACE_HEX_DUMP(params);\ 118 __last_ticks = __ticks;\ 119 } \ 120 } while (0) 121 #else 122 #define __QDF_TRACE_RATE_LIMITED(arg ...) 123 #define __QDF_TRACE_HEX_DUMP_RATE_LIMITED(arg ...) 124 #endif 125 126 #define __QDF_TRACE_NO_FL(log_level, module_id, format, args...) \ 127 QDF_TRACE(module_id, log_level, format, ## args) 128 129 #define __QDF_TRACE_FL(log_level, module_id, format, args...) \ 130 QDF_TRACE(module_id, log_level, FL(format), ## args) 131 132 #define __QDF_TRACE_RL(log_level, module_id, format, args...) \ 133 __QDF_TRACE_RATE_LIMITED(module_id, log_level, FL(format), ## args) 134 135 #define __QDF_TRACE_RL_NO_FL(log_level, module_id, format, args...) \ 136 __QDF_TRACE_RATE_LIMITED(module_id, log_level, format, ## args) 137 138 #define __QDF_TRACE_HEX_DUMP_RL(log_level, module_id, args...) \ 139 __QDF_TRACE_HEX_DUMP_RATE_LIMITED(module_id, log_level, ## args) 140 141 static inline void __qdf_trace_noop(QDF_MODULE_ID module, 142 const char *format, ...) { } 143 static inline void __qdf_trace_dummy(QDF_MODULE_ID module, 144 QDF_TRACE_LEVEL level, 145 const char *format, ...) { } 146 static inline void __qdf_vtrace_dummy(QDF_MODULE_ID module, 147 QDF_TRACE_LEVEL level, 148 const char *str_format, va_list val) { } 149 static inline void __qdf_trace_hexdump_dummy(QDF_MODULE_ID module, 150 QDF_TRACE_LEVEL level, 151 void *data, int buf_len) { } 152 153 154 #ifdef WLAN_LOG_FATAL 155 #define QDF_TRACE_FATAL(params...) \ 156 __QDF_TRACE_FL(QDF_TRACE_LEVEL_FATAL, ## params) 157 #define QDF_TRACE_FATAL_NO_FL(params...) \ 158 __QDF_TRACE_NO_FL(QDF_TRACE_LEVEL_FATAL, ## params) 159 #define QDF_TRACE_FATAL_RL(params...) \ 160 __QDF_TRACE_RL(QDF_TRACE_LEVEL_FATAL, ## params) 161 #define QDF_TRACE_FATAL_RL_NO_FL(params...) \ 162 __QDF_TRACE_RL_NO_FL(QDF_TRACE_LEVEL_FATAL, ## params) 163 #define QDF_VTRACE_FATAL(module_id, fmt, args) \ 164 QDF_VTRACE(module_id, QDF_TRACE_LEVEL_FATAL, fmt, args) 165 #define QDF_TRACE_HEX_DUMP_FATAL_RL(params...) \ 166 __QDF_TRACE_HEX_DUMP_RL(QDF_TRACE_LEVEL_FATAL, ## params) 167 #else 168 #define QDF_TRACE_FATAL(params...) __qdf_trace_noop(params) 169 #define QDF_TRACE_FATAL_NO_FL(params...) __qdf_trace_noop(params) 170 #define QDF_TRACE_FATAL_RL(params...) __qdf_trace_noop(params) 171 #define QDF_TRACE_FATAL_RL_NO_FL(params...) __qdf_trace_noop(params) 172 #define QDF_VTRACE_FATAL(params...) __qdf_trace_noop(params) 173 #define QDF_TRACE_HEX_DUMP_FATAL_RL(params...) __qdf_trace_noop(params) 174 #endif 175 176 #ifdef WLAN_LOG_ERROR 177 #define QDF_TRACE_ERROR(params...) \ 178 __QDF_TRACE_FL(QDF_TRACE_LEVEL_ERROR, ## params) 179 #define QDF_TRACE_ERROR_NO_FL(params...) \ 180 __QDF_TRACE_NO_FL(QDF_TRACE_LEVEL_ERROR, ## params) 181 #define QDF_TRACE_ERROR_RL(params...) \ 182 __QDF_TRACE_RL(QDF_TRACE_LEVEL_ERROR, ## params) 183 #define QDF_TRACE_ERROR_RL_NO_FL(params...) \ 184 __QDF_TRACE_RL_NO_FL(QDF_TRACE_LEVEL_ERROR, ## params) 185 #define QDF_VTRACE_ERROR(module_id, fmt, args) \ 186 QDF_VTRACE(module_id, QDF_TRACE_LEVEL_ERROR, fmt, args) 187 #define QDF_TRACE_HEX_DUMP_ERROR_RL(params...) \ 188 __QDF_TRACE_HEX_DUMP_RL(QDF_TRACE_LEVEL_ERROR, ## params) 189 #else 190 #define QDF_TRACE_ERROR(params...) __qdf_trace_noop(params) 191 #define QDF_TRACE_ERROR_NO_FL(params...) __qdf_trace_noop(params) 192 #define QDF_TRACE_ERROR_RL(params...) __qdf_trace_noop(params) 193 #define QDF_TRACE_ERROR_RL_NO_FL(params...) __qdf_trace_noop(params) 194 #define QDF_VTRACE_ERROR(params...) __qdf_trace_noop(params) 195 #define QDF_TRACE_HEX_DUMP_ERROR_RL(params...) __qdf_trace_noop(params) 196 #endif 197 198 #ifdef WLAN_LOG_WARN 199 #define QDF_TRACE_WARN(params...) \ 200 __QDF_TRACE_FL(QDF_TRACE_LEVEL_WARN, ## params) 201 #define QDF_TRACE_WARN_NO_FL(params...) \ 202 __QDF_TRACE_NO_FL(QDF_TRACE_LEVEL_WARN, ## params) 203 #define QDF_TRACE_WARN_RL(params...) \ 204 __QDF_TRACE_RL(QDF_TRACE_LEVEL_WARN, ## params) 205 #define QDF_TRACE_WARN_RL_NO_FL(params...) \ 206 __QDF_TRACE_RL_NO_FL(QDF_TRACE_LEVEL_WARN, ## params) 207 #define QDF_VTRACE_WARN(module_id, fmt, args) \ 208 QDF_VTRACE(module_id, QDF_TRACE_LEVEL_WARN, fmt, args) 209 #define QDF_TRACE_HEX_DUMP_WARN_RL(params...) \ 210 __QDF_TRACE_HEX_DUMP_RL(QDF_TRACE_LEVEL_WARN, ## params) 211 #else 212 #define QDF_TRACE_WARN(params...) __qdf_trace_noop(params) 213 #define QDF_TRACE_WARN_NO_FL(params...) __qdf_trace_noop(params) 214 #define QDF_TRACE_WARN_RL(params...) __qdf_trace_noop(params) 215 #define QDF_TRACE_WARN_RL_NO_FL(params...) __qdf_trace_noop(params) 216 #define QDF_VTRACE_WARN(params...) __qdf_trace_noop(params) 217 #define QDF_TRACE_HEX_DUMP_WARN_RL(params...) __qdf_trace_noop(params) 218 #endif 219 220 #ifdef WLAN_LOG_INFO 221 #define QDF_TRACE_INFO(params...) \ 222 __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO, ## params) 223 #define QDF_TRACE_INFO_NO_FL(params...) \ 224 __QDF_TRACE_NO_FL(QDF_TRACE_LEVEL_INFO, ## params) 225 #define QDF_TRACE_INFO_RL(params...) \ 226 __QDF_TRACE_RL(QDF_TRACE_LEVEL_INFO, ## params) 227 #define QDF_TRACE_INFO_RL_NO_FL(params...) \ 228 __QDF_TRACE_RL_NO_FL(QDF_TRACE_LEVEL_INFO, ## params) 229 #define QDF_VTRACE_INFO(module_id, fmt, args) \ 230 QDF_VTRACE(module_id, QDF_TRACE_LEVEL_INFO, fmt, args) 231 #define QDF_TRACE_HEX_DUMP_INFO_RL(params...) \ 232 __QDF_TRACE_HEX_DUMP_RL(QDF_TRACE_LEVEL_INFO, ## params) 233 #else 234 #define QDF_TRACE_INFO(params...) __qdf_trace_noop(params) 235 #define QDF_TRACE_INFO_NO_FL(params...) __qdf_trace_noop(params) 236 #define QDF_TRACE_INFO_RL(params...) __qdf_trace_noop(params) 237 #define QDF_TRACE_INFO_RL_NO_FL(params...) __qdf_trace_noop(params) 238 #define QDF_VTRACE_INFO(params...) __qdf_trace_noop(params) 239 #define QDF_TRACE_HEX_DUMP_INFO_RL(params...) __qdf_trace_noop(params) 240 #endif 241 242 #ifdef WLAN_LOG_DEBUG 243 #define QDF_TRACE_DEBUG(params...) \ 244 __QDF_TRACE_FL(QDF_TRACE_LEVEL_DEBUG, ## params) 245 #define QDF_TRACE_DEBUG_NO_FL(params...) \ 246 __QDF_TRACE_NO_FL(QDF_TRACE_LEVEL_DEBUG, ## params) 247 #define QDF_TRACE_DEBUG_RL(params...) \ 248 __QDF_TRACE_RL(QDF_TRACE_LEVEL_DEBUG, ## params) 249 #define QDF_TRACE_DEBUG_RL_NO_FL(params...) \ 250 __QDF_TRACE_RL_NO_FL(QDF_TRACE_LEVEL_DEBUG, ## params) 251 #define QDF_VTRACE_DEBUG(module_id, fmt, args) \ 252 QDF_VTRACE(module_id, QDF_TRACE_LEVEL_DEBUG, fmt, args) 253 #define QDF_TRACE_HEX_DUMP_DEBUG_RL(params...) \ 254 __QDF_TRACE_HEX_DUMP_RL(QDF_TRACE_LEVEL_DEBUG, ## params) 255 #else 256 #define QDF_TRACE_DEBUG(params...) __qdf_trace_noop(params) 257 #define QDF_TRACE_DEBUG_NO_FL(params...) __qdf_trace_noop(params) 258 #define QDF_TRACE_DEBUG_RL(params...) __qdf_trace_noop(params) 259 #define QDF_TRACE_DEBUG_RL_NO_FL(params...) __qdf_trace_noop(params) 260 #define QDF_VTRACE_DEBUG(params...) __qdf_trace_noop(params) 261 #define QDF_TRACE_HEX_DUMP_DEBUG_RL(params...) __qdf_trace_noop(params) 262 #endif 263 264 #ifdef WLAN_LOG_ENTER 265 #define QDF_TRACE_ENTER(params...) \ 266 __QDF_TRACE_FL(QDF_TRACE_LEVEL_DEBUG, ## params) 267 #else 268 #define QDF_TRACE_ENTER(params...) __qdf_trace_noop(params) 269 #endif 270 271 #ifdef WLAN_LOG_EXIT 272 #define QDF_TRACE_EXIT(params...) \ 273 __QDF_TRACE_FL(QDF_TRACE_LEVEL_DEBUG, ## params) 274 #else 275 #define QDF_TRACE_EXIT(params...) __qdf_trace_noop(params) 276 #endif 277 278 #define QDF_ENABLE_TRACING 279 #define qdf_scnprintf scnprintf 280 281 #ifdef QDF_ENABLE_TRACING 282 283 #ifdef WLAN_WARN_ON_ASSERT 284 #define QDF_ASSERT(_condition) \ 285 do { \ 286 if (!(_condition)) { \ 287 pr_err("QDF ASSERT in %s Line %d\n", \ 288 __func__, __LINE__); \ 289 WARN_ON(1); \ 290 } \ 291 } while (0) 292 #else 293 #define QDF_ASSERT(_condition) \ 294 do { \ 295 if (!(_condition)) { \ 296 /* no-op */ \ 297 } \ 298 } while (0) 299 #endif /* WLAN_WARN_ON_ASSERT */ 300 /** 301 * qdf_trace_msg()- logging API 302 * @module: Module identifier. A member of the QDF_MODULE_ID enumeration that 303 * identifies the module issuing the trace message. 304 * @level: Trace level. A member of the QDF_TRACE_LEVEL enumeration indicating 305 * the severity of the condition causing the trace message to be issued. 306 * More severe conditions are more likely to be logged. 307 * @str_format: Format string. The message to be logged. This format string 308 * contains printf-like replacement parameters, which follow this 309 * parameter in the variable argument list. 310 * 311 * Users wishing to add tracing information to their code should use 312 * QDF_TRACE. QDF_TRACE() will compile into a call to qdf_trace_msg() when 313 * tracing is enabled. 314 * 315 * Return: nothing 316 * 317 * implemented in qdf_trace.c 318 */ 319 void __printf(3, 4) qdf_trace_msg(QDF_MODULE_ID module, QDF_TRACE_LEVEL level, 320 const char *str_format, ...); 321 322 /** 323 * qdf_vtrace_msg() - the va_list version of qdf_trace_msg 324 * @module: the calling module's Id 325 * @level: the logging level to log using 326 * @str_format: the log format string 327 * @val: the va_list containing the values to format according to str_format 328 * 329 * Return: None 330 */ 331 void qdf_vtrace_msg(QDF_MODULE_ID module, QDF_TRACE_LEVEL level, 332 const char *str_format, va_list val); 333 334 #else 335 336 /* This code will be used for compilation if tracing is to be compiled out */ 337 /* of the code so these functions/macros are 'do nothing' */ 338 static inline void qdf_trace_msg(QDF_MODULE_ID module, QDF_TRACE_LEVEL level, 339 const char *str_format, ...) 340 { 341 } 342 343 #define QDF_ASSERT(_condition) 344 345 #endif 346 347 #ifdef QDF_TRACE_PRINT_ENABLE 348 static inline void qdf_vprint(const char *fmt, va_list args) 349 { 350 QDF_VTRACE_INFO(QDF_MODULE_ID_ANY, fmt, args); 351 } 352 #else /* QDF_TRACE_PRINT_ENABLE */ 353 static inline void qdf_vprint(const char *fmt, va_list args) 354 { 355 QDF_VTRACE_ERROR(QDF_MODULE_ID_QDF, fmt, args); 356 } 357 #endif 358 359 #ifdef PANIC_ON_BUG 360 #ifdef CONFIG_SLUB_DEBUG 361 /** 362 * __qdf_bug() - Calls BUG() when the PANIC_ON_BUG compilation option is enabled 363 * 364 * Note: Calling BUG() can cause a compiler to assume any following code is 365 * unreachable. Because these BUG's may or may not be enabled by the build 366 * configuration, this can cause developers some pain. Consider: 367 * 368 * bool bit; 369 * 370 * if (ptr) 371 * bit = ptr->returns_bool(); 372 * else 373 * __qdf_bug(); 374 * 375 * // do stuff with @bit 376 * 377 * return bit; 378 * 379 * In this case, @bit is potentially uninitialized when we return! However, the 380 * compiler can correctly assume this case is impossible when PANIC_ON_BUG is 381 * enabled. Because developers typically enable this feature, the "maybe 382 * uninitialized" warning will not be emitted, and the bug remains uncaught 383 * until someone tries to make a build without PANIC_ON_BUG. 384 * 385 * A simple workaround for this, is to put the definition of __qdf_bug in 386 * another compilation unit, which prevents the compiler from assuming 387 * subsequent code is unreachable. For CONFIG_SLUB_DEBUG, do this to catch more 388 * bugs. Otherwise, use the typical inlined approach. 389 * 390 * Return: None 391 */ 392 void __qdf_bug(void); 393 #else /* CONFIG_SLUB_DEBUG */ 394 static inline void __qdf_bug(void) 395 { 396 BUG(); 397 } 398 #endif /* CONFIG_SLUB_DEBUG */ 399 400 /** 401 * QDF_DEBUG_PANIC() - In debug builds, panic, otherwise do nothing 402 * @reason_fmt: a format string containing the reason for the panic 403 * @args: zero or more printf compatible logging arguments 404 * 405 * Return: None 406 */ 407 #define QDF_DEBUG_PANIC(reason_fmt, args...) \ 408 QDF_DEBUG_PANIC_FL(__func__, __LINE__, reason_fmt, ## args) 409 410 /** 411 * QDF_DEBUG_PANIC_FL() - In debug builds, panic, otherwise do nothing 412 * @func: origin function name to be logged 413 * @line: origin line number to be logged 414 * @fmt: printf compatible format string to be logged 415 * @args: zero or more printf compatible logging arguments 416 * 417 * Return: None 418 */ 419 #define QDF_DEBUG_PANIC_FL(func, line, fmt, args...) \ 420 do { \ 421 pr_err("WLAN Panic @ %s:%d: " fmt "\n", func, line, ##args); \ 422 __qdf_bug(); \ 423 } while (false) 424 425 #define QDF_BUG(_condition) \ 426 do { \ 427 if (!(_condition)) { \ 428 pr_err("QDF BUG in %s Line %d: Failed assertion '" \ 429 #_condition "'\n", __func__, __LINE__); \ 430 __qdf_bug(); \ 431 } \ 432 } while (0) 433 434 #define QDF_BUG_ON_ASSERT(_condition) \ 435 do { \ 436 if (!(_condition)) { \ 437 __qdf_bug(); \ 438 } \ 439 } while (0) 440 441 #else /* PANIC_ON_BUG */ 442 443 #define QDF_DEBUG_PANIC(reason...) \ 444 do { \ 445 /* no-op */ \ 446 } while (false) 447 448 #define QDF_DEBUG_PANIC_FL(func, line, fmt, args...) \ 449 do { \ 450 /* no-op */ \ 451 } while (false) 452 453 #define QDF_BUG(_condition) \ 454 do { \ 455 if (!(_condition)) { \ 456 /* no-op */ \ 457 } \ 458 } while (0) 459 460 #define QDF_BUG_ON_ASSERT(_condition) \ 461 do { \ 462 if (!(_condition)) { \ 463 /* no-op */ \ 464 } \ 465 } while (0) 466 467 #endif /* PANIC_ON_BUG */ 468 469 #ifdef KSYM_SYMBOL_LEN 470 #define __QDF_SYMBOL_LEN KSYM_SYMBOL_LEN 471 #else 472 #define __QDF_SYMBOL_LEN 1 473 #endif 474 475 #ifdef CONFIG_QCA_MINIDUMP 476 static inline void 477 __qdf_minidump_init(void) 478 { 479 } 480 481 static inline void 482 __qdf_minidump_deinit(void) 483 { 484 } 485 486 static inline void 487 __qdf_minidump_log(void *start_addr, size_t size, const char *name) 488 { 489 if (minidump_fill_segments((const uintptr_t)start_addr, size, 490 QCA_WDT_LOG_DUMP_TYPE_WLAN_MOD, 491 name) < 0) 492 QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO, 493 "%s: failed to log %pK (%s)\n", 494 __func__, start_addr, name); 495 } 496 497 static inline void 498 __qdf_minidump_remove(void *addr, size_t size, const char *name) 499 { 500 minidump_remove_segments((const uintptr_t)addr); 501 } 502 503 #elif defined(WLAN_QCOM_MINIDUMP) 504 #define MAX_WLAN_MINIDUMP_ENTRIES 4 505 506 enum minidump_log_type { 507 MD_HTC_CREDIT = 0, 508 MD_WLAN_LOGS, 509 MD_WMI_TX_CMP, 510 MD_HAL_SOC, 511 }; 512 513 static const char *minidump_table[MAX_WLAN_MINIDUMP_ENTRIES]; 514 515 static int qdf_get_name_idx(const char *name) 516 { 517 int i; 518 static const char * const wlan_str[] = { 519 [MD_HTC_CREDIT] = "htc_credit", 520 [MD_WLAN_LOGS] = "wlan_logs", 521 [MD_WMI_TX_CMP] = "wmi_tx_cmp", 522 [MD_HAL_SOC] = "hal_soc" 523 }; 524 525 for (i = 0; i < ARRAY_SIZE(wlan_str); i++) { 526 if (strncmp(name, wlan_str[i], strlen(wlan_str[i])) == 0) 527 return i; 528 } 529 530 return -EINVAL; 531 } 532 533 static inline void 534 __qdf_minidump_log(void *start_addr, const size_t size, 535 const char *name) 536 { 537 struct md_region md_entry; 538 int ret, index; 539 540 index = qdf_get_name_idx(name); 541 if (index < 0) { 542 QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_QDF, 543 "%s: invalid entry %s\n", 544 __func__, name); 545 QDF_DEBUG_PANIC("Unknown minidump entry"); 546 return; 547 } 548 snprintf(md_entry.name, sizeof(md_entry.name), name); 549 md_entry.virt_addr = (uintptr_t)start_addr; 550 md_entry.phys_addr = virt_to_phys(start_addr); 551 md_entry.size = size; 552 ret = msm_minidump_add_region(&md_entry); 553 if (ret < 0) { 554 QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_QDF, 555 "%s: failed to log %pK (%s)\n", 556 __func__, start_addr, name); 557 minidump_table[index] = NULL; 558 } else { 559 minidump_table[index] = name; 560 } 561 } 562 563 static inline void 564 __qdf_minidump_remove(void *start_addr, const size_t size, 565 const char *name) 566 { 567 struct md_region md_entry; 568 int index; 569 570 index = qdf_get_name_idx(name); 571 if (index < 0 || !minidump_table[index]) { 572 QDF_TRACE_ERROR_NO_FL(QDF_MODULE_ID_QDF, 573 "%s: entry was not added", 574 __func__); 575 return; 576 } 577 snprintf(md_entry.name, sizeof(md_entry.name), name); 578 md_entry.virt_addr = (uintptr_t)start_addr; 579 md_entry.phys_addr = virt_to_phys(start_addr); 580 md_entry.size = size; 581 msm_minidump_remove_region(&md_entry); 582 minidump_table[index] = NULL; 583 } 584 585 static inline void 586 __qdf_minidump_init(void) 587 { 588 } 589 590 static inline void 591 __qdf_minidump_deinit(void) 592 { 593 } 594 595 #elif defined(WLAN_QCOM_VA_MINIDUMP) 596 void __qdf_minidump_init(void); 597 598 void __qdf_minidump_deinit(void); 599 600 void __qdf_minidump_log(void *start_addr, size_t size, const char *name); 601 602 void __qdf_minidump_remove(void *addr, size_t size, const char *name); 603 #else 604 static inline 605 void __qdf_minidump_init(void) 606 { 607 } 608 609 static inline 610 void __qdf_minidump_deinit(void) 611 { 612 } 613 614 static inline 615 void __qdf_minidump_log(void *start_addr, size_t size, const char *name) 616 { 617 } 618 619 static inline 620 void __qdf_minidump_remove(void *addr, size_t size, const char *name) 621 { 622 } 623 #endif 624 #endif /* __I_QDF_TRACE_H */ 625