?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: mm: Recreate kernel mappings in early_paging_init()
[linux/fpc-iii.git] / drivers / net / wireless / ath / carl9170 / debug.c
blob3d70cd277fd73745b96eeb0fe2042eb9789b68f4
1 /*
2 * Atheros CARL9170 driver
3 *
4 * debug(fs) probing
5 *
6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
7 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; see the file COPYING. If not, see
21 * http://www.gnu.org/licenses/.
22 *
23 * This file incorporates work covered by the following copyright and
24 * permission notice:
25 * Copyright (c) 2008-2009 Atheros Communications, Inc.
26 *
27 * Permission to use, copy, modify, and/or distribute this software for any
28 * purpose with or without fee is hereby granted, provided that the above
29 * copyright notice and this permission notice appear in all copies.
30 *
31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
38 */
39
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/module.h>
43 #include <linux/seq_file.h>
44 #include <linux/vmalloc.h>
45 #include "carl9170.h"
46 #include "cmd.h"
47
48 #define ADD(buf, off, max, fmt, args...) \
49 off += snprintf(&buf[off], max - off, fmt, ##args);
50
51
52 struct carl9170_debugfs_fops {
53 unsigned int read_bufsize;
54 umode_t attr;
55 char *(*read)(struct ar9170 *ar, char *buf, size_t bufsize,
56 ssize_t *len);
57 ssize_t (*write)(struct ar9170 *aru, const char *buf, size_t size);
58 const struct file_operations fops;
59
60 enum carl9170_device_state req_dev_state;
61 };
62
63 static ssize_t carl9170_debugfs_read(struct file *file, char __user *userbuf,
64 size_t count, loff_t *ppos)
65 {
66 struct carl9170_debugfs_fops *dfops;
67 struct ar9170 *ar;
68 char *buf = NULL, *res_buf = NULL;
69 ssize_t ret = 0;
70 int err = 0;
71
72 if (!count)
73 return 0;
74
75 ar = file->private_data;
76
77 if (!ar)
78 return -ENODEV;
79 dfops = container_of(file->f_op, struct carl9170_debugfs_fops, fops);
80
81 if (!dfops->read)
82 return -ENOSYS;
83
84 if (dfops->read_bufsize) {
85 buf = vmalloc(dfops->read_bufsize);
86 if (!buf)
87 return -ENOMEM;
88 }
89
90 mutex_lock(&ar->mutex);
91 if (!CHK_DEV_STATE(ar, dfops->req_dev_state)) {
92 err = -ENODEV;
93 res_buf = buf;
94 goto out_free;
95 }
96
97 res_buf = dfops->read(ar, buf, dfops->read_bufsize, &ret);
98
99 if (ret > 0)
100 err = simple_read_from_buffer(userbuf, count, ppos,
101 res_buf, ret);
102 else
103 err = ret;
104
105 WARN_ON_ONCE(dfops->read_bufsize && (res_buf != buf));
106
107 out_free:
108 vfree(res_buf);
109 mutex_unlock(&ar->mutex);
110 return err;
111 }
112
113 static ssize_t carl9170_debugfs_write(struct file *file,
114 const char __user *userbuf, size_t count, loff_t *ppos)
115 {
116 struct carl9170_debugfs_fops *dfops;
117 struct ar9170 *ar;
118 char *buf = NULL;
119 int err = 0;
120
121 if (!count)
122 return 0;
123
124 if (count > PAGE_SIZE)
125 return -E2BIG;
126
127 ar = file->private_data;
128
129 if (!ar)
130 return -ENODEV;
131 dfops = container_of(file->f_op, struct carl9170_debugfs_fops, fops);
132
133 if (!dfops->write)
134 return -ENOSYS;
135
136 buf = vmalloc(count);
137 if (!buf)
138 return -ENOMEM;
139
140 if (copy_from_user(buf, userbuf, count)) {
141 err = -EFAULT;
142 goto out_free;
143 }
144
145 if (mutex_trylock(&ar->mutex) == 0) {
146 err = -EAGAIN;
147 goto out_free;
148 }
149
150 if (!CHK_DEV_STATE(ar, dfops->req_dev_state)) {
151 err = -ENODEV;
152 goto out_unlock;
153 }
154
155 err = dfops->write(ar, buf, count);
156 if (err)
157 goto out_unlock;
158
159 out_unlock:
160 mutex_unlock(&ar->mutex);
161
162 out_free:
163 vfree(buf);
164 return err;
165 }
166
167 #define __DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, \
168 _attr, _dstate) \
169 static const struct carl9170_debugfs_fops carl_debugfs_##name ##_ops = {\
170 .read_bufsize = _read_bufsize, \
171 .read = _read, \
172 .write = _write, \
173 .attr = _attr, \
174 .req_dev_state = _dstate, \
175 .fops = { \
176 .open = simple_open, \
177 .read = carl9170_debugfs_read, \
178 .write = carl9170_debugfs_write, \
179 .owner = THIS_MODULE \
180 }, \
181 }
182
183 #define DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, _attr) \
184 __DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, \
185 _attr, CARL9170_STARTED) \
186
187 #define DEBUGFS_DECLARE_RO_FILE(name, _read_bufsize) \
188 DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \
189 NULL, _read_bufsize, S_IRUSR)
190
191 #define DEBUGFS_DECLARE_WO_FILE(name) \
192 DEBUGFS_DECLARE_FILE(name, NULL, carl9170_debugfs_##name ##_write,\
193 0, S_IWUSR)
194
195 #define DEBUGFS_DECLARE_RW_FILE(name, _read_bufsize) \
196 DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \
197 carl9170_debugfs_##name ##_write, \
198 _read_bufsize, S_IRUSR | S_IWUSR)
199
200 #define __DEBUGFS_DECLARE_RW_FILE(name, _read_bufsize, _dstate) \
201 __DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \
202 carl9170_debugfs_##name ##_write, \
203 _read_bufsize, S_IRUSR | S_IWUSR, _dstate)
204
205 #define DEBUGFS_READONLY_FILE(name, _read_bufsize, fmt, value...) \
206 static char *carl9170_debugfs_ ##name ## _read(struct ar9170 *ar, \
207 char *buf, size_t buf_size,\
208 ssize_t *len) \
209 { \
210 ADD(buf, *len, buf_size, fmt "\n", ##value); \
211 return buf; \
212 } \
213 DEBUGFS_DECLARE_RO_FILE(name, _read_bufsize)
214
215 static char *carl9170_debugfs_mem_usage_read(struct ar9170 *ar, char *buf,
216 size_t bufsize, ssize_t *len)
217 {
218 ADD(buf, *len, bufsize, "jar: [");
219
220 spin_lock_bh(&ar->mem_lock);
221
222 *len += bitmap_scnprintf(&buf[*len], bufsize - *len,
223 ar->mem_bitmap, ar->fw.mem_blocks);
224
225 ADD(buf, *len, bufsize, "]\n");
226
227 ADD(buf, *len, bufsize, "cookies: used:%3d / total:%3d, allocs:%d\n",
228 bitmap_weight(ar->mem_bitmap, ar->fw.mem_blocks),
229 ar->fw.mem_blocks, atomic_read(&ar->mem_allocs));
230
231 ADD(buf, *len, bufsize, "memory: free:%3d (%3d KiB) / total:%3d KiB)\n",
232 atomic_read(&ar->mem_free_blocks),
233 (atomic_read(&ar->mem_free_blocks) * ar->fw.mem_block_size) / 1024,
234 (ar->fw.mem_blocks * ar->fw.mem_block_size) / 1024);
235
236 spin_unlock_bh(&ar->mem_lock);
237
238 return buf;
239 }
240 DEBUGFS_DECLARE_RO_FILE(mem_usage, 512);
241
242 static char *carl9170_debugfs_qos_stat_read(struct ar9170 *ar, char *buf,
243 size_t bufsize, ssize_t *len)
244 {
245 ADD(buf, *len, bufsize, "%s QoS AC\n", modparam_noht ? "Hardware" :
246 "Software");
247
248 ADD(buf, *len, bufsize, "[ VO VI "
249 " BE BK ]\n");
250
251 spin_lock_bh(&ar->tx_stats_lock);
252 ADD(buf, *len, bufsize, "[length/limit length/limit "
253 "length/limit length/limit ]\n"
254 "[ %3d/%3d %3d/%3d "
255 " %3d/%3d %3d/%3d ]\n\n",
256 ar->tx_stats[0].len, ar->tx_stats[0].limit,
257 ar->tx_stats[1].len, ar->tx_stats[1].limit,
258 ar->tx_stats[2].len, ar->tx_stats[2].limit,
259 ar->tx_stats[3].len, ar->tx_stats[3].limit);
260
261 ADD(buf, *len, bufsize, "[ total total "
262 " total total ]\n"
263 "[%10d %10d %10d %10d ]\n\n",
264 ar->tx_stats[0].count, ar->tx_stats[1].count,
265 ar->tx_stats[2].count, ar->tx_stats[3].count);
266
267 spin_unlock_bh(&ar->tx_stats_lock);
268
269 ADD(buf, *len, bufsize, "[ pend/waittx pend/waittx "
270 " pend/waittx pend/waittx]\n"
271 "[ %3d/%3d %3d/%3d "
272 " %3d/%3d %3d/%3d ]\n\n",
273 skb_queue_len(&ar->tx_pending[0]),
274 skb_queue_len(&ar->tx_status[0]),
275 skb_queue_len(&ar->tx_pending[1]),
276 skb_queue_len(&ar->tx_status[1]),
277 skb_queue_len(&ar->tx_pending[2]),
278 skb_queue_len(&ar->tx_status[2]),
279 skb_queue_len(&ar->tx_pending[3]),
280 skb_queue_len(&ar->tx_status[3]));
281
282 return buf;
283 }
284 DEBUGFS_DECLARE_RO_FILE(qos_stat, 512);
285
286 static void carl9170_debugfs_format_frame(struct ar9170 *ar,
287 struct sk_buff *skb, const char *prefix, char *buf,
288 ssize_t *off, ssize_t bufsize)
289 {
290 struct _carl9170_tx_superframe *txc = (void *) skb->data;
291 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
292 struct carl9170_tx_info *arinfo = (void *) txinfo->rate_driver_data;
293 struct ieee80211_hdr *hdr = (void *) txc->frame_data;
294
295 ADD(buf, *off, bufsize, "%s %p, c:%2x, DA:%pM, sq:%4d, mc:%.4x, "
296 "pc:%.8x, to:%d ms\n", prefix, skb, txc->s.cookie,
297 ieee80211_get_DA(hdr), get_seq_h(hdr),
298 le16_to_cpu(txc->f.mac_control), le32_to_cpu(txc->f.phy_control),
299 jiffies_to_msecs(jiffies - arinfo->timeout));
300 }
301
302
303 static char *carl9170_debugfs_ampdu_state_read(struct ar9170 *ar, char *buf,
304 size_t bufsize, ssize_t *len)
305 {
306 struct carl9170_sta_tid *iter;
307 struct sk_buff *skb;
308 int cnt = 0, fc;
309 int offset;
310
311 rcu_read_lock();
312 list_for_each_entry_rcu(iter, &ar->tx_ampdu_list, list) {
313
314 spin_lock_bh(&iter->lock);
315 ADD(buf, *len, bufsize, "Entry: #%2d TID:%1d, BSN:%4d, "
316 "SNX:%4d, HSN:%4d, BAW:%2d, state:%1d, toggles:%d\n",
317 cnt, iter->tid, iter->bsn, iter->snx, iter->hsn,
318 iter->max, iter->state, iter->counter);
319
320 ADD(buf, *len, bufsize, "\tWindow: [");
321
322 *len += bitmap_scnprintf(&buf[*len], bufsize - *len,
323 iter->bitmap, CARL9170_BAW_BITS);
324
325 #define BM_STR_OFF(offset) \
326 ((CARL9170_BAW_BITS - (offset) - 1) / 4 + \
327 (CARL9170_BAW_BITS - (offset) - 1) / 32 + 1)
328
329 ADD(buf, *len, bufsize, ",W]\n");
330
331 offset = BM_STR_OFF(0);
332 ADD(buf, *len, bufsize, "\tBase Seq: %*s\n", offset, "T");
333
334 offset = BM_STR_OFF(SEQ_DIFF(iter->snx, iter->bsn));
335 ADD(buf, *len, bufsize, "\tNext Seq: %*s\n", offset, "W");
336
337 offset = BM_STR_OFF(((int)iter->hsn - (int)iter->bsn) %
338 CARL9170_BAW_BITS);
339 ADD(buf, *len, bufsize, "\tLast Seq: %*s\n", offset, "N");
340
341 ADD(buf, *len, bufsize, "\tPre-Aggregation reorder buffer: "
342 " currently queued:%d\n", skb_queue_len(&iter->queue));
343
344 fc = 0;
345 skb_queue_walk(&iter->queue, skb) {
346 char prefix[32];
347
348 snprintf(prefix, sizeof(prefix), "\t\t%3d :", fc);
349 carl9170_debugfs_format_frame(ar, skb, prefix, buf,
350 len, bufsize);
351
352 fc++;
353 }
354 spin_unlock_bh(&iter->lock);
355 cnt++;
356 }
357 rcu_read_unlock();
358
359 return buf;
360 }
361 DEBUGFS_DECLARE_RO_FILE(ampdu_state, 8000);
362
363 static void carl9170_debugfs_queue_dump(struct ar9170 *ar, char *buf,
364 ssize_t *len, size_t bufsize, struct sk_buff_head *queue)
365 {
366 struct sk_buff *skb;
367 char prefix[16];
368 int fc = 0;
369
370 spin_lock_bh(&queue->lock);
371 skb_queue_walk(queue, skb) {
372 snprintf(prefix, sizeof(prefix), "%3d :", fc);
373 carl9170_debugfs_format_frame(ar, skb, prefix, buf,
374 len, bufsize);
375 fc++;
376 }
377 spin_unlock_bh(&queue->lock);
378 }
379
380 #define DEBUGFS_QUEUE_DUMP(q, qi) \
381 static char *carl9170_debugfs_##q ##_##qi ##_read(struct ar9170 *ar, \
382 char *buf, size_t bufsize, ssize_t *len) \
383 { \
384 carl9170_debugfs_queue_dump(ar, buf, len, bufsize, &ar->q[qi]); \
385 return buf; \
386 } \
387 DEBUGFS_DECLARE_RO_FILE(q##_##qi, 8000);
388
389 static char *carl9170_debugfs_sta_psm_read(struct ar9170 *ar, char *buf,
390 size_t bufsize, ssize_t *len)
391 {
392 ADD(buf, *len, bufsize, "psm state: %s\n", (ar->ps.off_override ?
393 "FORCE CAM" : (ar->ps.state ? "PSM" : "CAM")));
394
395 ADD(buf, *len, bufsize, "sleep duration: %d ms.\n", ar->ps.sleep_ms);
396 ADD(buf, *len, bufsize, "last power-state transition: %d ms ago.\n",
397 jiffies_to_msecs(jiffies - ar->ps.last_action));
398 ADD(buf, *len, bufsize, "last CAM->PSM transition: %d ms ago.\n",
399 jiffies_to_msecs(jiffies - ar->ps.last_slept));
400
401 return buf;
402 }
403 DEBUGFS_DECLARE_RO_FILE(sta_psm, 160);
404
405 static char *carl9170_debugfs_tx_stuck_read(struct ar9170 *ar, char *buf,
406 size_t bufsize, ssize_t *len)
407 {
408 int i;
409
410 for (i = 0; i < ar->hw->queues; i++) {
411 ADD(buf, *len, bufsize, "TX queue [%d]: %10d max:%10d ms.\n",
412 i, ieee80211_queue_stopped(ar->hw, i) ?
413 jiffies_to_msecs(jiffies - ar->queue_stop_timeout[i]) : 0,
414 jiffies_to_msecs(ar->max_queue_stop_timeout[i]));
415
416 ar->max_queue_stop_timeout[i] = 0;
417 }
418
419 return buf;
420 }
421 DEBUGFS_DECLARE_RO_FILE(tx_stuck, 180);
422
423 static char *carl9170_debugfs_phy_noise_read(struct ar9170 *ar, char *buf,
424 size_t bufsize, ssize_t *len)
425 {
426 int err;
427
428 err = carl9170_get_noisefloor(ar);
429 if (err) {
430 *len = err;
431 return buf;
432 }
433
434 ADD(buf, *len, bufsize, "Chain 0: %10d dBm, ext. chan.:%10d dBm\n",
435 ar->noise[0], ar->noise[2]);
436 ADD(buf, *len, bufsize, "Chain 2: %10d dBm, ext. chan.:%10d dBm\n",
437 ar->noise[1], ar->noise[3]);
438
439 return buf;
440 }
441 DEBUGFS_DECLARE_RO_FILE(phy_noise, 180);
442
443 static char *carl9170_debugfs_vif_dump_read(struct ar9170 *ar, char *buf,
444 size_t bufsize, ssize_t *len)
445 {
446 struct carl9170_vif_info *iter;
447 int i = 0;
448
449 ADD(buf, *len, bufsize, "registered VIFs:%d \\ %d\n",
450 ar->vifs, ar->fw.vif_num);
451
452 ADD(buf, *len, bufsize, "VIF bitmap: [");
453
454 *len += bitmap_scnprintf(&buf[*len], bufsize - *len,
455 &ar->vif_bitmap, ar->fw.vif_num);
456
457 ADD(buf, *len, bufsize, "]\n");
458
459 rcu_read_lock();
460 list_for_each_entry_rcu(iter, &ar->vif_list, list) {
461 struct ieee80211_vif *vif = carl9170_get_vif(iter);
462 ADD(buf, *len, bufsize, "\t%d = [%s VIF, id:%d, type:%x "
463 " mac:%pM %s]\n", i, (carl9170_get_main_vif(ar) == vif ?
464 "Master" : " Slave"), iter->id, vif->type, vif->addr,
465 iter->enable_beacon ? "beaconing " : "");
466 i++;
467 }
468 rcu_read_unlock();
469
470 return buf;
471 }
472 DEBUGFS_DECLARE_RO_FILE(vif_dump, 8000);
473
474 #define UPDATE_COUNTER(ar, name) ({ \
475 u32 __tmp[ARRAY_SIZE(name##_regs)]; \
476 unsigned int __i, __err = -ENODEV; \
477 \
478 for (__i = 0; __i < ARRAY_SIZE(name##_regs); __i++) { \
479 __tmp[__i] = name##_regs[__i].reg; \
480 ar->debug.stats.name##_counter[__i] = 0; \
481 } \
482 \
483 if (IS_STARTED(ar)) \
484 __err = carl9170_read_mreg(ar, ARRAY_SIZE(name##_regs), \
485 __tmp, ar->debug.stats.name##_counter); \
486 (__err); })
487
488 #define TALLY_SUM_UP(ar, name) do { \
489 unsigned int __i; \
490 \
491 for (__i = 0; __i < ARRAY_SIZE(name##_regs); __i++) { \
492 ar->debug.stats.name##_sum[__i] += \
493 ar->debug.stats.name##_counter[__i]; \
494 } \
495 } while (0)
496
497 #define DEBUGFS_HW_TALLY_FILE(name, f) \
498 static char *carl9170_debugfs_##name ## _read(struct ar9170 *ar, \
499 char *dum, size_t bufsize, ssize_t *ret) \
500 { \
501 char *buf; \
502 int i, max_len, err; \
503 \
504 max_len = ARRAY_SIZE(name##_regs) * 80; \
505 buf = vmalloc(max_len); \
506 if (!buf) \
507 return NULL; \
508 \
509 err = UPDATE_COUNTER(ar, name); \
510 if (err) { \
511 *ret = err; \
512 return buf; \
513 } \
514 \
515 TALLY_SUM_UP(ar, name); \
516 \
517 for (i = 0; i < ARRAY_SIZE(name##_regs); i++) { \
518 ADD(buf, *ret, max_len, "%22s = %" f "[+%" f "]\n", \
519 name##_regs[i].nreg, ar->debug.stats.name ##_sum[i],\
520 ar->debug.stats.name ##_counter[i]); \
521 } \
522 \
523 return buf; \
524 } \
525 DEBUGFS_DECLARE_RO_FILE(name, 0);
526
527 #define DEBUGFS_HW_REG_FILE(name, f) \
528 static char *carl9170_debugfs_##name ## _read(struct ar9170 *ar, \
529 char *dum, size_t bufsize, ssize_t *ret) \
530 { \
531 char *buf; \
532 int i, max_len, err; \
533 \
534 max_len = ARRAY_SIZE(name##_regs) * 80; \
535 buf = vmalloc(max_len); \
536 if (!buf) \
537 return NULL; \
538 \
539 err = UPDATE_COUNTER(ar, name); \
540 if (err) { \
541 *ret = err; \
542 return buf; \
543 } \
544 \
545 for (i = 0; i < ARRAY_SIZE(name##_regs); i++) { \
546 ADD(buf, *ret, max_len, "%22s = %" f "\n", \
547 name##_regs[i].nreg, \
548 ar->debug.stats.name##_counter[i]); \
549 } \
550 \
551 return buf; \
552 } \
553 DEBUGFS_DECLARE_RO_FILE(name, 0);
554
555 static ssize_t carl9170_debugfs_hw_ioread32_write(struct ar9170 *ar,
556 const char *buf, size_t count)
557 {
558 int err = 0, i, n = 0, max_len = 32, res;
559 unsigned int reg, tmp;
560
561 if (!count)
562 return 0;
563
564 if (count > max_len)
565 return -E2BIG;
566
567 res = sscanf(buf, "0x%X %d", &reg, &n);
568 if (res < 1) {
569 err = -EINVAL;
570 goto out;
571 }
572
573 if (res == 1)
574 n = 1;
575
576 if (n > 15) {
577 err = -EMSGSIZE;
578 goto out;
579 }
580
581 if ((reg >= 0x280000) || ((reg + (n << 2)) >= 0x280000)) {
582 err = -EADDRNOTAVAIL;
583 goto out;
584 }
585
586 if (reg & 3) {
587 err = -EINVAL;
588 goto out;
589 }
590
591 for (i = 0; i < n; i++) {
592 err = carl9170_read_reg(ar, reg + (i << 2), &tmp);
593 if (err)
594 goto out;
595
596 ar->debug.ring[ar->debug.ring_tail].reg = reg + (i << 2);
597 ar->debug.ring[ar->debug.ring_tail].value = tmp;
598 ar->debug.ring_tail++;
599 ar->debug.ring_tail %= CARL9170_DEBUG_RING_SIZE;
600 }
601
602 out:
603 return err ? err : count;
604 }
605
606 static char *carl9170_debugfs_hw_ioread32_read(struct ar9170 *ar, char *buf,
607 size_t bufsize, ssize_t *ret)
608 {
609 int i = 0;
610
611 while (ar->debug.ring_head != ar->debug.ring_tail) {
612 ADD(buf, *ret, bufsize, "%.8x = %.8x\n",
613 ar->debug.ring[ar->debug.ring_head].reg,
614 ar->debug.ring[ar->debug.ring_head].value);
615
616 ar->debug.ring_head++;
617 ar->debug.ring_head %= CARL9170_DEBUG_RING_SIZE;
618
619 if (i++ == 64)
620 break;
621 }
622 ar->debug.ring_head = ar->debug.ring_tail;
623 return buf;
624 }
625 DEBUGFS_DECLARE_RW_FILE(hw_ioread32, CARL9170_DEBUG_RING_SIZE * 40);
626
627 static ssize_t carl9170_debugfs_bug_write(struct ar9170 *ar, const char *buf,
628 size_t count)
629 {
630 int err;
631
632 if (count < 1)
633 return -EINVAL;
634
635 switch (buf[0]) {
636 case 'F':
637 ar->needs_full_reset = true;
638 break;
639
640 case 'R':
641 if (!IS_STARTED(ar)) {
642 err = -EAGAIN;
643 goto out;
644 }
645
646 ar->needs_full_reset = false;
647 break;
648
649 case 'M':
650 err = carl9170_mac_reset(ar);
651 if (err < 0)
652 count = err;
653
654 goto out;
655
656 case 'P':
657 err = carl9170_set_channel(ar, ar->hw->conf.chandef.chan,
658 cfg80211_get_chandef_type(&ar->hw->conf.chandef));
659 if (err < 0)
660 count = err;
661
662 goto out;
663
664 default:
665 return -EINVAL;
666 }
667
668 carl9170_restart(ar, CARL9170_RR_USER_REQUEST);
669
670 out:
671 return count;
672 }
673
674 static char *carl9170_debugfs_bug_read(struct ar9170 *ar, char *buf,
675 size_t bufsize, ssize_t *ret)
676 {
677 ADD(buf, *ret, bufsize, "[P]hy reinit, [R]estart, [F]ull usb reset, "
678 "[M]ac reset\n");
679 ADD(buf, *ret, bufsize, "firmware restarts:%d, last reason:%d\n",
680 ar->restart_counter, ar->last_reason);
681 ADD(buf, *ret, bufsize, "phy reinit errors:%d (%d)\n",
682 ar->total_chan_fail, ar->chan_fail);
683 ADD(buf, *ret, bufsize, "reported firmware errors:%d\n",
684 ar->fw.err_counter);
685 ADD(buf, *ret, bufsize, "reported firmware BUGs:%d\n",
686 ar->fw.bug_counter);
687 ADD(buf, *ret, bufsize, "pending restart requests:%d\n",
688 atomic_read(&ar->pending_restarts));
689 return buf;
690 }
691 __DEBUGFS_DECLARE_RW_FILE(bug, 400, CARL9170_STOPPED);
692
693 static const char *const erp_modes[] = {
694 [CARL9170_ERP_INVALID] = "INVALID",
695 [CARL9170_ERP_AUTO] = "Automatic",
696 [CARL9170_ERP_MAC80211] = "Set by MAC80211",
697 [CARL9170_ERP_OFF] = "Force Off",
698 [CARL9170_ERP_RTS] = "Force RTS",
699 [CARL9170_ERP_CTS] = "Force CTS"
700 };
701
702 static char *carl9170_debugfs_erp_read(struct ar9170 *ar, char *buf,
703 size_t bufsize, ssize_t *ret)
704 {
705 ADD(buf, *ret, bufsize, "ERP Setting: (%d) -> %s\n", ar->erp_mode,
706 erp_modes[ar->erp_mode]);
707 return buf;
708 }
709
710 static ssize_t carl9170_debugfs_erp_write(struct ar9170 *ar, const char *buf,
711 size_t count)
712 {
713 int res, val;
714
715 if (count < 1)
716 return -EINVAL;
717
718 res = sscanf(buf, "%d", &val);
719 if (res != 1)
720 return -EINVAL;
721
722 if (!((val > CARL9170_ERP_INVALID) &&
723 (val < __CARL9170_ERP_NUM)))
724 return -EINVAL;
725
726 ar->erp_mode = val;
727 return count;
728 }
729
730 DEBUGFS_DECLARE_RW_FILE(erp, 80);
731
732 static ssize_t carl9170_debugfs_hw_iowrite32_write(struct ar9170 *ar,
733 const char *buf, size_t count)
734 {
735 int err = 0, max_len = 22, res;
736 u32 reg, val;
737
738 if (!count)
739 return 0;
740
741 if (count > max_len)
742 return -E2BIG;
743
744 res = sscanf(buf, "0x%X 0x%X", &reg, &val);
745 if (res != 2) {
746 err = -EINVAL;
747 goto out;
748 }
749
750 if (reg <= 0x100000 || reg >= 0x280000) {
751 err = -EADDRNOTAVAIL;
752 goto out;
753 }
754
755 if (reg & 3) {
756 err = -EINVAL;
757 goto out;
758 }
759
760 err = carl9170_write_reg(ar, reg, val);
761 if (err)
762 goto out;
763
764 out:
765 return err ? err : count;
766 }
767 DEBUGFS_DECLARE_WO_FILE(hw_iowrite32);
768
769 DEBUGFS_HW_TALLY_FILE(hw_tx_tally, "u");
770 DEBUGFS_HW_TALLY_FILE(hw_rx_tally, "u");
771 DEBUGFS_HW_TALLY_FILE(hw_phy_errors, "u");
772 DEBUGFS_HW_REG_FILE(hw_wlan_queue, ".8x");
773 DEBUGFS_HW_REG_FILE(hw_pta_queue, ".8x");
774 DEBUGFS_HW_REG_FILE(hw_ampdu_info, ".8x");
775 DEBUGFS_QUEUE_DUMP(tx_status, 0);
776 DEBUGFS_QUEUE_DUMP(tx_status, 1);
777 DEBUGFS_QUEUE_DUMP(tx_status, 2);
778 DEBUGFS_QUEUE_DUMP(tx_status, 3);
779 DEBUGFS_QUEUE_DUMP(tx_pending, 0);
780 DEBUGFS_QUEUE_DUMP(tx_pending, 1);
781 DEBUGFS_QUEUE_DUMP(tx_pending, 2);
782 DEBUGFS_QUEUE_DUMP(tx_pending, 3);
783 DEBUGFS_READONLY_FILE(usb_tx_anch_urbs, 20, "%d",
784 atomic_read(&ar->tx_anch_urbs));
785 DEBUGFS_READONLY_FILE(usb_rx_anch_urbs, 20, "%d",
786 atomic_read(&ar->rx_anch_urbs));
787 DEBUGFS_READONLY_FILE(usb_rx_work_urbs, 20, "%d",
788 atomic_read(&ar->rx_work_urbs));
789 DEBUGFS_READONLY_FILE(usb_rx_pool_urbs, 20, "%d",
790 atomic_read(&ar->rx_pool_urbs));
791
792 DEBUGFS_READONLY_FILE(tx_total_queued, 20, "%d",
793 atomic_read(&ar->tx_total_queued));
794 DEBUGFS_READONLY_FILE(tx_ampdu_scheduler, 20, "%d",
795 atomic_read(&ar->tx_ampdu_scheduler));
796
797 DEBUGFS_READONLY_FILE(tx_total_pending, 20, "%d",
798 atomic_read(&ar->tx_total_pending));
799
800 DEBUGFS_READONLY_FILE(tx_ampdu_list_len, 20, "%d",
801 ar->tx_ampdu_list_len);
802
803 DEBUGFS_READONLY_FILE(tx_ampdu_upload, 20, "%d",
804 atomic_read(&ar->tx_ampdu_upload));
805
806 DEBUGFS_READONLY_FILE(tx_janitor_last_run, 64, "last run:%d ms ago",
807 jiffies_to_msecs(jiffies - ar->tx_janitor_last_run));
808
809 DEBUGFS_READONLY_FILE(tx_dropped, 20, "%d", ar->tx_dropped);
810
811 DEBUGFS_READONLY_FILE(rx_dropped, 20, "%d", ar->rx_dropped);
812
813 DEBUGFS_READONLY_FILE(sniffer_enabled, 20, "%d", ar->sniffer_enabled);
814 DEBUGFS_READONLY_FILE(rx_software_decryption, 20, "%d",
815 ar->rx_software_decryption);
816 DEBUGFS_READONLY_FILE(ampdu_factor, 20, "%d",
817 ar->current_factor);
818 DEBUGFS_READONLY_FILE(ampdu_density, 20, "%d",
819 ar->current_density);
820
821 DEBUGFS_READONLY_FILE(beacon_int, 20, "%d TU", ar->global_beacon_int);
822 DEBUGFS_READONLY_FILE(pretbtt, 20, "%d TU", ar->global_pretbtt);
823
824 void carl9170_debugfs_register(struct ar9170 *ar)
825 {
826 ar->debug_dir = debugfs_create_dir(KBUILD_MODNAME,
827 ar->hw->wiphy->debugfsdir);
828
829 #define DEBUGFS_ADD(name) \
830 debugfs_create_file(#name, carl_debugfs_##name ##_ops.attr, \
831 ar->debug_dir, ar, \
832 &carl_debugfs_##name ## _ops.fops);
833
834 DEBUGFS_ADD(usb_tx_anch_urbs);
835 DEBUGFS_ADD(usb_rx_pool_urbs);
836 DEBUGFS_ADD(usb_rx_anch_urbs);
837 DEBUGFS_ADD(usb_rx_work_urbs);
838
839 DEBUGFS_ADD(tx_total_queued);
840 DEBUGFS_ADD(tx_total_pending);
841 DEBUGFS_ADD(tx_dropped);
842 DEBUGFS_ADD(tx_stuck);
843 DEBUGFS_ADD(tx_ampdu_upload);
844 DEBUGFS_ADD(tx_ampdu_scheduler);
845 DEBUGFS_ADD(tx_ampdu_list_len);
846
847 DEBUGFS_ADD(rx_dropped);
848 DEBUGFS_ADD(sniffer_enabled);
849 DEBUGFS_ADD(rx_software_decryption);
850
851 DEBUGFS_ADD(mem_usage);
852 DEBUGFS_ADD(qos_stat);
853 DEBUGFS_ADD(sta_psm);
854 DEBUGFS_ADD(ampdu_state);
855
856 DEBUGFS_ADD(hw_tx_tally);
857 DEBUGFS_ADD(hw_rx_tally);
858 DEBUGFS_ADD(hw_phy_errors);
859 DEBUGFS_ADD(phy_noise);
860
861 DEBUGFS_ADD(hw_wlan_queue);
862 DEBUGFS_ADD(hw_pta_queue);
863 DEBUGFS_ADD(hw_ampdu_info);
864
865 DEBUGFS_ADD(ampdu_density);
866 DEBUGFS_ADD(ampdu_factor);
867
868 DEBUGFS_ADD(tx_janitor_last_run);
869
870 DEBUGFS_ADD(tx_status_0);
871 DEBUGFS_ADD(tx_status_1);
872 DEBUGFS_ADD(tx_status_2);
873 DEBUGFS_ADD(tx_status_3);
874
875 DEBUGFS_ADD(tx_pending_0);
876 DEBUGFS_ADD(tx_pending_1);
877 DEBUGFS_ADD(tx_pending_2);
878 DEBUGFS_ADD(tx_pending_3);
879
880 DEBUGFS_ADD(hw_ioread32);
881 DEBUGFS_ADD(hw_iowrite32);
882 DEBUGFS_ADD(bug);
883
884 DEBUGFS_ADD(erp);
885
886 DEBUGFS_ADD(vif_dump);
887
888 DEBUGFS_ADD(beacon_int);
889 DEBUGFS_ADD(pretbtt);
890
891 #undef DEBUGFS_ADD
892 }
893
894 void carl9170_debugfs_unregister(struct ar9170 *ar)
895 {
896 debugfs_remove_recursive(ar->debug_dir);
897 }
Linux with added FPC-III support