?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / net / wireless / ath / ath10k / debug.c
blob3d65594fa098a40f638f73499d423e80d2a64a7e
1 /*
2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include <linux/module.h>
19 #include <linux/debugfs.h>
20
21 #include "core.h"
22 #include "debug.h"
23
24 static int ath10k_printk(const char *level, const char *fmt, ...)
25 {
26 struct va_format vaf;
27 va_list args;
28 int rtn;
29
30 va_start(args, fmt);
31
32 vaf.fmt = fmt;
33 vaf.va = &args;
34
35 rtn = printk("%sath10k: %pV", level, &vaf);
36
37 va_end(args);
38
39 return rtn;
40 }
41
42 int ath10k_info(const char *fmt, ...)
43 {
44 struct va_format vaf = {
45 .fmt = fmt,
46 };
47 va_list args;
48 int ret;
49
50 va_start(args, fmt);
51 vaf.va = &args;
52 ret = ath10k_printk(KERN_INFO, "%pV", &vaf);
53 trace_ath10k_log_info(&vaf);
54 va_end(args);
55
56 return ret;
57 }
58 EXPORT_SYMBOL(ath10k_info);
59
60 int ath10k_err(const char *fmt, ...)
61 {
62 struct va_format vaf = {
63 .fmt = fmt,
64 };
65 va_list args;
66 int ret;
67
68 va_start(args, fmt);
69 vaf.va = &args;
70 ret = ath10k_printk(KERN_ERR, "%pV", &vaf);
71 trace_ath10k_log_err(&vaf);
72 va_end(args);
73
74 return ret;
75 }
76 EXPORT_SYMBOL(ath10k_err);
77
78 int ath10k_warn(const char *fmt, ...)
79 {
80 struct va_format vaf = {
81 .fmt = fmt,
82 };
83 va_list args;
84 int ret = 0;
85
86 va_start(args, fmt);
87 vaf.va = &args;
88
89 if (net_ratelimit())
90 ret = ath10k_printk(KERN_WARNING, "%pV", &vaf);
91
92 trace_ath10k_log_warn(&vaf);
93
94 va_end(args);
95
96 return ret;
97 }
98 EXPORT_SYMBOL(ath10k_warn);
99
100 #ifdef CONFIG_ATH10K_DEBUGFS
101
102 void ath10k_debug_read_service_map(struct ath10k *ar,
103 void *service_map,
104 size_t map_size)
105 {
106 memcpy(ar->debug.wmi_service_bitmap, service_map, map_size);
107 }
108
109 static ssize_t ath10k_read_wmi_services(struct file *file,
110 char __user *user_buf,
111 size_t count, loff_t *ppos)
112 {
113 struct ath10k *ar = file->private_data;
114 char *buf;
115 unsigned int len = 0, buf_len = 1500;
116 const char *status;
117 ssize_t ret_cnt;
118 int i;
119
120 buf = kzalloc(buf_len, GFP_KERNEL);
121 if (!buf)
122 return -ENOMEM;
123
124 mutex_lock(&ar->conf_mutex);
125
126 if (len > buf_len)
127 len = buf_len;
128
129 for (i = 0; i < WMI_SERVICE_LAST; i++) {
130 if (WMI_SERVICE_IS_ENABLED(ar->debug.wmi_service_bitmap, i))
131 status = "enabled";
132 else
133 status = "disabled";
134
135 len += scnprintf(buf + len, buf_len - len,
136 "0x%02x - %20s - %s\n",
137 i, wmi_service_name(i), status);
138 }
139
140 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
141
142 mutex_unlock(&ar->conf_mutex);
143
144 kfree(buf);
145 return ret_cnt;
146 }
147
148 static const struct file_operations fops_wmi_services = {
149 .read = ath10k_read_wmi_services,
150 .open = simple_open,
151 .owner = THIS_MODULE,
152 .llseek = default_llseek,
153 };
154
155 void ath10k_debug_read_target_stats(struct ath10k *ar,
156 struct wmi_stats_event *ev)
157 {
158 u8 *tmp = ev->data;
159 struct ath10k_target_stats *stats;
160 int num_pdev_stats, num_vdev_stats, num_peer_stats;
161 struct wmi_pdev_stats *ps;
162 int i;
163
164 spin_lock_bh(&ar->data_lock);
165
166 stats = &ar->debug.target_stats;
167
168 num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats); /* 0 or 1 */
169 num_vdev_stats = __le32_to_cpu(ev->num_vdev_stats); /* 0 or max vdevs */
170 num_peer_stats = __le32_to_cpu(ev->num_peer_stats); /* 0 or max peers */
171
172 if (num_pdev_stats) {
173 ps = (struct wmi_pdev_stats *)tmp;
174
175 stats->ch_noise_floor = __le32_to_cpu(ps->chan_nf);
176 stats->tx_frame_count = __le32_to_cpu(ps->tx_frame_count);
177 stats->rx_frame_count = __le32_to_cpu(ps->rx_frame_count);
178 stats->rx_clear_count = __le32_to_cpu(ps->rx_clear_count);
179 stats->cycle_count = __le32_to_cpu(ps->cycle_count);
180 stats->phy_err_count = __le32_to_cpu(ps->phy_err_count);
181 stats->chan_tx_power = __le32_to_cpu(ps->chan_tx_pwr);
182
183 stats->comp_queued = __le32_to_cpu(ps->wal.tx.comp_queued);
184 stats->comp_delivered =
185 __le32_to_cpu(ps->wal.tx.comp_delivered);
186 stats->msdu_enqued = __le32_to_cpu(ps->wal.tx.msdu_enqued);
187 stats->mpdu_enqued = __le32_to_cpu(ps->wal.tx.mpdu_enqued);
188 stats->wmm_drop = __le32_to_cpu(ps->wal.tx.wmm_drop);
189 stats->local_enqued = __le32_to_cpu(ps->wal.tx.local_enqued);
190 stats->local_freed = __le32_to_cpu(ps->wal.tx.local_freed);
191 stats->hw_queued = __le32_to_cpu(ps->wal.tx.hw_queued);
192 stats->hw_reaped = __le32_to_cpu(ps->wal.tx.hw_reaped);
193 stats->underrun = __le32_to_cpu(ps->wal.tx.underrun);
194 stats->tx_abort = __le32_to_cpu(ps->wal.tx.tx_abort);
195 stats->mpdus_requed = __le32_to_cpu(ps->wal.tx.mpdus_requed);
196 stats->tx_ko = __le32_to_cpu(ps->wal.tx.tx_ko);
197 stats->data_rc = __le32_to_cpu(ps->wal.tx.data_rc);
198 stats->self_triggers = __le32_to_cpu(ps->wal.tx.self_triggers);
199 stats->sw_retry_failure =
200 __le32_to_cpu(ps->wal.tx.sw_retry_failure);
201 stats->illgl_rate_phy_err =
202 __le32_to_cpu(ps->wal.tx.illgl_rate_phy_err);
203 stats->pdev_cont_xretry =
204 __le32_to_cpu(ps->wal.tx.pdev_cont_xretry);
205 stats->pdev_tx_timeout =
206 __le32_to_cpu(ps->wal.tx.pdev_tx_timeout);
207 stats->pdev_resets = __le32_to_cpu(ps->wal.tx.pdev_resets);
208 stats->phy_underrun = __le32_to_cpu(ps->wal.tx.phy_underrun);
209 stats->txop_ovf = __le32_to_cpu(ps->wal.tx.txop_ovf);
210
211 stats->mid_ppdu_route_change =
212 __le32_to_cpu(ps->wal.rx.mid_ppdu_route_change);
213 stats->status_rcvd = __le32_to_cpu(ps->wal.rx.status_rcvd);
214 stats->r0_frags = __le32_to_cpu(ps->wal.rx.r0_frags);
215 stats->r1_frags = __le32_to_cpu(ps->wal.rx.r1_frags);
216 stats->r2_frags = __le32_to_cpu(ps->wal.rx.r2_frags);
217 stats->r3_frags = __le32_to_cpu(ps->wal.rx.r3_frags);
218 stats->htt_msdus = __le32_to_cpu(ps->wal.rx.htt_msdus);
219 stats->htt_mpdus = __le32_to_cpu(ps->wal.rx.htt_mpdus);
220 stats->loc_msdus = __le32_to_cpu(ps->wal.rx.loc_msdus);
221 stats->loc_mpdus = __le32_to_cpu(ps->wal.rx.loc_mpdus);
222 stats->oversize_amsdu =
223 __le32_to_cpu(ps->wal.rx.oversize_amsdu);
224 stats->phy_errs = __le32_to_cpu(ps->wal.rx.phy_errs);
225 stats->phy_err_drop = __le32_to_cpu(ps->wal.rx.phy_err_drop);
226 stats->mpdu_errs = __le32_to_cpu(ps->wal.rx.mpdu_errs);
227
228 tmp += sizeof(struct wmi_pdev_stats);
229 }
230
231 /* 0 or max vdevs */
232 /* Currently firmware does not support VDEV stats */
233 if (num_vdev_stats) {
234 struct wmi_vdev_stats *vdev_stats;
235
236 for (i = 0; i < num_vdev_stats; i++) {
237 vdev_stats = (struct wmi_vdev_stats *)tmp;
238 tmp += sizeof(struct wmi_vdev_stats);
239 }
240 }
241
242 if (num_peer_stats) {
243 struct wmi_peer_stats *peer_stats;
244 struct ath10k_peer_stat *s;
245
246 stats->peers = num_peer_stats;
247
248 for (i = 0; i < num_peer_stats; i++) {
249 peer_stats = (struct wmi_peer_stats *)tmp;
250 s = &stats->peer_stat[i];
251
252 WMI_MAC_ADDR_TO_CHAR_ARRAY(&peer_stats->peer_macaddr,
253 s->peer_macaddr);
254 s->peer_rssi = __le32_to_cpu(peer_stats->peer_rssi);
255 s->peer_tx_rate =
256 __le32_to_cpu(peer_stats->peer_tx_rate);
257
258 tmp += sizeof(struct wmi_peer_stats);
259 }
260 }
261
262 spin_unlock_bh(&ar->data_lock);
263 mutex_unlock(&ar->conf_mutex);
264 complete(&ar->debug.event_stats_compl);
265 }
266
267 static ssize_t ath10k_read_fw_stats(struct file *file, char __user *user_buf,
268 size_t count, loff_t *ppos)
269 {
270 struct ath10k *ar = file->private_data;
271 struct ath10k_target_stats *fw_stats;
272 char *buf = NULL;
273 unsigned int len = 0, buf_len = 2500;
274 ssize_t ret_cnt = 0;
275 long left;
276 int i;
277 int ret;
278
279 fw_stats = &ar->debug.target_stats;
280
281 mutex_lock(&ar->conf_mutex);
282
283 if (ar->state != ATH10K_STATE_ON)
284 goto exit;
285
286 buf = kzalloc(buf_len, GFP_KERNEL);
287 if (!buf)
288 goto exit;
289
290 ret = ath10k_wmi_request_stats(ar, WMI_REQUEST_PEER_STAT);
291 if (ret) {
292 ath10k_warn("could not request stats (%d)\n", ret);
293 goto exit;
294 }
295
296 left = wait_for_completion_timeout(&ar->debug.event_stats_compl, 1*HZ);
297 if (left <= 0)
298 goto exit;
299
300 spin_lock_bh(&ar->data_lock);
301 len += scnprintf(buf + len, buf_len - len, "\n");
302 len += scnprintf(buf + len, buf_len - len, "%30s\n",
303 "ath10k PDEV stats");
304 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
305 "=================");
306
307 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
308 "Channel noise floor", fw_stats->ch_noise_floor);
309 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
310 "Channel TX power", fw_stats->chan_tx_power);
311 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
312 "TX frame count", fw_stats->tx_frame_count);
313 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
314 "RX frame count", fw_stats->rx_frame_count);
315 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
316 "RX clear count", fw_stats->rx_clear_count);
317 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
318 "Cycle count", fw_stats->cycle_count);
319 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
320 "PHY error count", fw_stats->phy_err_count);
321
322 len += scnprintf(buf + len, buf_len - len, "\n");
323 len += scnprintf(buf + len, buf_len - len, "%30s\n",
324 "ath10k PDEV TX stats");
325 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
326 "=================");
327
328 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
329 "HTT cookies queued", fw_stats->comp_queued);
330 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
331 "HTT cookies disp.", fw_stats->comp_delivered);
332 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
333 "MSDU queued", fw_stats->msdu_enqued);
334 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
335 "MPDU queued", fw_stats->mpdu_enqued);
336 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
337 "MSDUs dropped", fw_stats->wmm_drop);
338 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
339 "Local enqued", fw_stats->local_enqued);
340 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
341 "Local freed", fw_stats->local_freed);
342 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
343 "HW queued", fw_stats->hw_queued);
344 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
345 "PPDUs reaped", fw_stats->hw_reaped);
346 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
347 "Num underruns", fw_stats->underrun);
348 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
349 "PPDUs cleaned", fw_stats->tx_abort);
350 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
351 "MPDUs requed", fw_stats->mpdus_requed);
352 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
353 "Excessive retries", fw_stats->tx_ko);
354 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
355 "HW rate", fw_stats->data_rc);
356 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
357 "Sched self tiggers", fw_stats->self_triggers);
358 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
359 "Dropped due to SW retries",
360 fw_stats->sw_retry_failure);
361 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
362 "Illegal rate phy errors",
363 fw_stats->illgl_rate_phy_err);
364 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
365 "Pdev continous xretry", fw_stats->pdev_cont_xretry);
366 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
367 "TX timeout", fw_stats->pdev_tx_timeout);
368 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
369 "PDEV resets", fw_stats->pdev_resets);
370 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
371 "PHY underrun", fw_stats->phy_underrun);
372 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
373 "MPDU is more than txop limit", fw_stats->txop_ovf);
374
375 len += scnprintf(buf + len, buf_len - len, "\n");
376 len += scnprintf(buf + len, buf_len - len, "%30s\n",
377 "ath10k PDEV RX stats");
378 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
379 "=================");
380
381 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
382 "Mid PPDU route change",
383 fw_stats->mid_ppdu_route_change);
384 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
385 "Tot. number of statuses", fw_stats->status_rcvd);
386 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
387 "Extra frags on rings 0", fw_stats->r0_frags);
388 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
389 "Extra frags on rings 1", fw_stats->r1_frags);
390 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
391 "Extra frags on rings 2", fw_stats->r2_frags);
392 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
393 "Extra frags on rings 3", fw_stats->r3_frags);
394 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
395 "MSDUs delivered to HTT", fw_stats->htt_msdus);
396 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
397 "MPDUs delivered to HTT", fw_stats->htt_mpdus);
398 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
399 "MSDUs delivered to stack", fw_stats->loc_msdus);
400 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
401 "MPDUs delivered to stack", fw_stats->loc_mpdus);
402 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
403 "Oversized AMSUs", fw_stats->oversize_amsdu);
404 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
405 "PHY errors", fw_stats->phy_errs);
406 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
407 "PHY errors drops", fw_stats->phy_err_drop);
408 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
409 "MPDU errors (FCS, MIC, ENC)", fw_stats->mpdu_errs);
410
411 len += scnprintf(buf + len, buf_len - len, "\n");
412 len += scnprintf(buf + len, buf_len - len, "%30s\n",
413 "ath10k PEER stats");
414 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
415 "=================");
416
417 for (i = 0; i < fw_stats->peers; i++) {
418 len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
419 "Peer MAC address",
420 fw_stats->peer_stat[i].peer_macaddr);
421 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
422 "Peer RSSI", fw_stats->peer_stat[i].peer_rssi);
423 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
424 "Peer TX rate",
425 fw_stats->peer_stat[i].peer_tx_rate);
426 len += scnprintf(buf + len, buf_len - len, "\n");
427 }
428 spin_unlock_bh(&ar->data_lock);
429
430 if (len > buf_len)
431 len = buf_len;
432
433 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
434
435 exit:
436 mutex_unlock(&ar->conf_mutex);
437 kfree(buf);
438 return ret_cnt;
439 }
440
441 static const struct file_operations fops_fw_stats = {
442 .read = ath10k_read_fw_stats,
443 .open = simple_open,
444 .owner = THIS_MODULE,
445 .llseek = default_llseek,
446 };
447
448 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
449 char __user *user_buf,
450 size_t count, loff_t *ppos)
451 {
452 const char buf[] = "To simulate firmware crash write the keyword"
453 " `crash` to this file.\nThis will force firmware"
454 " to report a crash to the host system.\n";
455 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
456 }
457
458 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
459 const char __user *user_buf,
460 size_t count, loff_t *ppos)
461 {
462 struct ath10k *ar = file->private_data;
463 char buf[32] = {};
464 int ret;
465
466 mutex_lock(&ar->conf_mutex);
467
468 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
469 if (strcmp(buf, "crash") && strcmp(buf, "crash\n")) {
470 ret = -EINVAL;
471 goto exit;
472 }
473
474 if (ar->state != ATH10K_STATE_ON &&
475 ar->state != ATH10K_STATE_RESTARTED) {
476 ret = -ENETDOWN;
477 goto exit;
478 }
479
480 ath10k_info("simulating firmware crash\n");
481
482 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
483 if (ret)
484 ath10k_warn("failed to force fw hang (%d)\n", ret);
485
486 if (ret == 0)
487 ret = count;
488
489 exit:
490 mutex_unlock(&ar->conf_mutex);
491 return ret;
492 }
493
494 static const struct file_operations fops_simulate_fw_crash = {
495 .read = ath10k_read_simulate_fw_crash,
496 .write = ath10k_write_simulate_fw_crash,
497 .open = simple_open,
498 .owner = THIS_MODULE,
499 .llseek = default_llseek,
500 };
501
502 int ath10k_debug_create(struct ath10k *ar)
503 {
504 ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
505 ar->hw->wiphy->debugfsdir);
506
507 if (!ar->debug.debugfs_phy)
508 return -ENOMEM;
509
510 init_completion(&ar->debug.event_stats_compl);
511
512 debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
513 &fops_fw_stats);
514
515 debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
516 &fops_wmi_services);
517
518 debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
519 ar, &fops_simulate_fw_crash);
520
521 return 0;
522 }
523 #endif /* CONFIG_ATH10K_DEBUGFS */
524
525 #ifdef CONFIG_ATH10K_DEBUG
526 void ath10k_dbg(enum ath10k_debug_mask mask, const char *fmt, ...)
527 {
528 struct va_format vaf;
529 va_list args;
530
531 va_start(args, fmt);
532
533 vaf.fmt = fmt;
534 vaf.va = &args;
535
536 if (ath10k_debug_mask & mask)
537 ath10k_printk(KERN_DEBUG, "%pV", &vaf);
538
539 trace_ath10k_log_dbg(mask, &vaf);
540
541 va_end(args);
542 }
543 EXPORT_SYMBOL(ath10k_dbg);
544
545 void ath10k_dbg_dump(enum ath10k_debug_mask mask,
546 const char *msg, const char *prefix,
547 const void *buf, size_t len)
548 {
549 if (ath10k_debug_mask & mask) {
550 if (msg)
551 ath10k_dbg(mask, "%s\n", msg);
552
553 print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
554 }
555
556 /* tracing code doesn't like null strings :/ */
557 trace_ath10k_log_dbg_dump(msg ? msg : "", prefix ? prefix : "",
558 buf, len);
559 }
560 EXPORT_SYMBOL(ath10k_dbg_dump);
561
562 #endif /* CONFIG_ATH10K_DEBUG */
Linux with added FPC-III support