Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
debug.c
Go to the documentation of this file.
1 /*
2  * Atheros CARL9170 driver
3  *
4  * debug(fs) probing
5  *
6  * Copyright 2008, Johannes Berg <[email protected]>
7  * Copyright 2009, 2010, Christian Lamparter <[email protected]>
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 
53  unsigned int read_bufsize;
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 
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",
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) %
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,
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 }
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.channel,
658  ar->hw->conf.channel_type, CARL9170_RFI_COLD);
659  if (err < 0)
660  count = err;
661 
662  goto out;
663 
664  default:
665  return -EINVAL;
666  }
667 
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",
689  return buf;
690 }
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");
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",
794 DEBUGFS_READONLY_FILE(tx_ampdu_scheduler, 20, "%d",
796 
797 DEBUGFS_READONLY_FILE(tx_total_pending, 20, "%d",
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",
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 
810 
812 
813 DEBUGFS_READONLY_FILE(sniffer_enabled, 20, "%d", ar->sniffer_enabled);
814 DEBUGFS_READONLY_FILE(rx_software_decryption, 20, "%d",
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 
822 DEBUGFS_READONLY_FILE(pretbtt, 20, "%d TU", ar->global_pretbtt);
823 
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);
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 
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 
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 
889  DEBUGFS_ADD(pretbtt);
890 
891 #undef DEBUGFS_ADD
892 }
893 
895 {
896  debugfs_remove_recursive(ar->debug_dir);
897 }