1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 5 * 6 */ 7 8 #include <linux/vmalloc.h> 9 #include "core.h" 10 #include "debug.h" 11 12 void ath12k_info(struct ath12k_base *ab, const char *fmt, ...) 13 { 14 struct va_format vaf = { 15 .fmt = fmt, 16 }; 17 va_list args; 18 19 va_start(args, fmt); 20 vaf.va = &args; 21 #if defined(__linux__) 22 dev_info(ab->dev, "%pV", &vaf); 23 #elif defined(__FreeBSD__) 24 { 25 char *str; 26 vasprintf(&str, M_KMALLOC, fmt, args); 27 dev_printk(KERN_INFO, ab->dev, "%s", str); 28 free(str, M_KMALLOC); 29 } 30 #endif 31 /* TODO: Trace the log */ 32 va_end(args); 33 } 34 EXPORT_SYMBOL(ath12k_info); 35 36 void ath12k_err(struct ath12k_base *ab, const char *fmt, ...) 37 { 38 struct va_format vaf = { 39 .fmt = fmt, 40 }; 41 va_list args; 42 43 va_start(args, fmt); 44 vaf.va = &args; 45 #if defined(__linux__) 46 dev_err(ab->dev, "%pV", &vaf); 47 #elif defined(__FreeBSD__) 48 { 49 char *str; 50 vasprintf(&str, M_KMALLOC, fmt, args); 51 dev_printk(KERN_ERR, ab->dev, "%s", str); 52 free(str, M_KMALLOC); 53 } 54 #endif 55 /* TODO: Trace the log */ 56 va_end(args); 57 } 58 EXPORT_SYMBOL(ath12k_err); 59 60 void __ath12k_warn(struct device *dev, const char *fmt, ...) 61 { 62 struct va_format vaf = { 63 .fmt = fmt, 64 }; 65 va_list args; 66 67 va_start(args, fmt); 68 vaf.va = &args; 69 #if defined(__linux__) 70 dev_warn_ratelimited(dev, "%pV", &vaf); 71 #elif defined(__FreeBSD__) 72 { 73 static linux_ratelimit_t __ratelimited; 74 75 if (linux_ratelimited(&__ratelimited)) { 76 char *str; 77 vasprintf(&str, M_KMALLOC, fmt, args); 78 dev_printk(KERN_WARN, dev, "%s", str); 79 free(str, M_KMALLOC); 80 } 81 } 82 #endif 83 /* TODO: Trace the log */ 84 va_end(args); 85 } 86 EXPORT_SYMBOL(__ath12k_warn); 87 88 #ifdef CONFIG_ATH12K_DEBUG 89 90 void __ath12k_dbg(struct ath12k_base *ab, enum ath12k_debug_mask mask, 91 const char *fmt, ...) 92 { 93 struct va_format vaf; 94 va_list args; 95 96 va_start(args, fmt); 97 98 vaf.fmt = fmt; 99 vaf.va = &args; 100 101 #if defined(__linux__) 102 if (likely(ab)) 103 dev_printk(KERN_DEBUG, ab->dev, "%pV", &vaf); 104 else 105 printk(KERN_DEBUG "ath12k: %pV", &vaf); 106 #elif defined(__FreeBSD__) 107 { 108 char *str; 109 vasprintf(&str, M_KMALLOC, fmt, args); 110 if (likely(ab)) 111 dev_printk(KERN_DEBUG, ab->dev, "%s", str); 112 else 113 printk(KERN_DEBUG "ath12k: %s", str); 114 free(str, M_KMALLOC); 115 } 116 #endif 117 118 /* TODO: trace log */ 119 120 va_end(args); 121 } 122 EXPORT_SYMBOL(__ath12k_dbg); 123 124 void ath12k_dbg_dump(struct ath12k_base *ab, 125 enum ath12k_debug_mask mask, 126 const char *msg, const char *prefix, 127 const void *buf, size_t len) 128 { 129 #if defined(__linux__) 130 char linebuf[256]; 131 size_t linebuflen; 132 const void *ptr; 133 #elif defined(__FreeBSD__) 134 struct sbuf *sb; 135 int rc; 136 #endif 137 138 if (ath12k_debug_mask & mask) { 139 if (msg) 140 __ath12k_dbg(ab, mask, "%s\n", msg); 141 142 #if defined(__linux__) 143 for (ptr = buf; (ptr - buf) < len; ptr += 16) { 144 linebuflen = 0; 145 linebuflen += scnprintf(linebuf + linebuflen, 146 sizeof(linebuf) - linebuflen, 147 "%s%08x: ", 148 (prefix ? prefix : ""), 149 (unsigned int)(ptr - buf)); 150 hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1, 151 linebuf + linebuflen, 152 sizeof(linebuf) - linebuflen, true); 153 dev_dbg(ab->dev, "%s\n", linebuf); 154 } 155 #elif defined(__FreeBSD__) 156 sb = sbuf_new_auto(); 157 if (sb == NULL) 158 goto trace; 159 160 sbuf_hexdump(sb, buf, len, prefix, 0); 161 sbuf_trim(sb); 162 rc = sbuf_finish(sb); 163 if (rc == 0) 164 dev_printk(KERN_DEBUG, ab->dev, "%s\n", sbuf_data(sb)); 165 sbuf_delete(sb); 166 trace: ; 167 #endif 168 } 169 } 170 EXPORT_SYMBOL(ath12k_dbg_dump); 171 172 #endif /* CONFIG_ATH12K_DEBUG */ 173