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