2 * Copyright (c) 2008-2011 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
19 #include <asm/unaligned.h>
23 #define REG_WRITE_D(_ah, _reg, _val) \
24 ath9k_hw_common(_ah)->ops->write((_ah), (_val), (_reg))
25 #define REG_READ_D(_ah, _reg) \
26 ath9k_hw_common(_ah)->ops->read((_ah), (_reg))
28 static int ath9k_debugfs_open(struct inode
*inode
, struct file
*file
)
30 file
->private_data
= inode
->i_private
;
34 static ssize_t
ath9k_debugfs_read_buf(struct file
*file
, char __user
*user_buf
,
35 size_t count
, loff_t
*ppos
)
37 u8
*buf
= file
->private_data
;
38 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, strlen(buf
));
41 static int ath9k_debugfs_release_buf(struct inode
*inode
, struct file
*file
)
43 vfree(file
->private_data
);
47 #ifdef CONFIG_ATH_DEBUG
49 static ssize_t
read_file_debug(struct file
*file
, char __user
*user_buf
,
50 size_t count
, loff_t
*ppos
)
52 struct ath_softc
*sc
= file
->private_data
;
53 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
57 len
= sprintf(buf
, "0x%08x\n", common
->debug_mask
);
58 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
61 static ssize_t
write_file_debug(struct file
*file
, const char __user
*user_buf
,
62 size_t count
, loff_t
*ppos
)
64 struct ath_softc
*sc
= file
->private_data
;
65 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
70 len
= min(count
, sizeof(buf
) - 1);
71 if (copy_from_user(buf
, user_buf
, len
))
75 if (strict_strtoul(buf
, 0, &mask
))
78 common
->debug_mask
= mask
;
82 static const struct file_operations fops_debug
= {
83 .read
= read_file_debug
,
84 .write
= write_file_debug
,
85 .open
= ath9k_debugfs_open
,
87 .llseek
= default_llseek
,
92 #define DMA_BUF_LEN 1024
94 static ssize_t
read_file_tx_chainmask(struct file
*file
, char __user
*user_buf
,
95 size_t count
, loff_t
*ppos
)
97 struct ath_softc
*sc
= file
->private_data
;
98 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
102 len
= sprintf(buf
, "0x%08x\n", common
->tx_chainmask
);
103 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
106 static ssize_t
write_file_tx_chainmask(struct file
*file
, const char __user
*user_buf
,
107 size_t count
, loff_t
*ppos
)
109 struct ath_softc
*sc
= file
->private_data
;
110 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
115 len
= min(count
, sizeof(buf
) - 1);
116 if (copy_from_user(buf
, user_buf
, len
))
120 if (strict_strtoul(buf
, 0, &mask
))
123 common
->tx_chainmask
= mask
;
124 sc
->sc_ah
->caps
.tx_chainmask
= mask
;
128 static const struct file_operations fops_tx_chainmask
= {
129 .read
= read_file_tx_chainmask
,
130 .write
= write_file_tx_chainmask
,
131 .open
= ath9k_debugfs_open
,
132 .owner
= THIS_MODULE
,
133 .llseek
= default_llseek
,
137 static ssize_t
read_file_rx_chainmask(struct file
*file
, char __user
*user_buf
,
138 size_t count
, loff_t
*ppos
)
140 struct ath_softc
*sc
= file
->private_data
;
141 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
145 len
= sprintf(buf
, "0x%08x\n", common
->rx_chainmask
);
146 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
149 static ssize_t
write_file_rx_chainmask(struct file
*file
, const char __user
*user_buf
,
150 size_t count
, loff_t
*ppos
)
152 struct ath_softc
*sc
= file
->private_data
;
153 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
158 len
= min(count
, sizeof(buf
) - 1);
159 if (copy_from_user(buf
, user_buf
, len
))
163 if (strict_strtoul(buf
, 0, &mask
))
166 common
->rx_chainmask
= mask
;
167 sc
->sc_ah
->caps
.rx_chainmask
= mask
;
171 static const struct file_operations fops_rx_chainmask
= {
172 .read
= read_file_rx_chainmask
,
173 .write
= write_file_rx_chainmask
,
174 .open
= ath9k_debugfs_open
,
175 .owner
= THIS_MODULE
,
176 .llseek
= default_llseek
,
179 static ssize_t
read_file_disable_ani(struct file
*file
, char __user
*user_buf
,
180 size_t count
, loff_t
*ppos
)
182 struct ath_softc
*sc
= file
->private_data
;
183 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
187 len
= sprintf(buf
, "%d\n", common
->disable_ani
);
188 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
191 static ssize_t
write_file_disable_ani(struct file
*file
,
192 const char __user
*user_buf
,
193 size_t count
, loff_t
*ppos
)
195 struct ath_softc
*sc
= file
->private_data
;
196 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
197 unsigned long disable_ani
;
201 len
= min(count
, sizeof(buf
) - 1);
202 if (copy_from_user(buf
, user_buf
, len
))
206 if (strict_strtoul(buf
, 0, &disable_ani
))
209 common
->disable_ani
= !!disable_ani
;
212 sc
->sc_flags
&= ~SC_OP_ANI_RUN
;
213 del_timer_sync(&common
->ani
.timer
);
215 sc
->sc_flags
|= SC_OP_ANI_RUN
;
216 ath_start_ani(common
);
222 static const struct file_operations fops_disable_ani
= {
223 .read
= read_file_disable_ani
,
224 .write
= write_file_disable_ani
,
225 .open
= ath9k_debugfs_open
,
226 .owner
= THIS_MODULE
,
227 .llseek
= default_llseek
,
230 static ssize_t
read_file_dma(struct file
*file
, char __user
*user_buf
,
231 size_t count
, loff_t
*ppos
)
233 struct ath_softc
*sc
= file
->private_data
;
234 struct ath_hw
*ah
= sc
->sc_ah
;
237 unsigned int len
= 0;
238 u32 val
[ATH9K_NUM_DMA_DEBUG_REGS
];
239 int i
, qcuOffset
= 0, dcuOffset
= 0;
240 u32
*qcuBase
= &val
[0], *dcuBase
= &val
[4];
242 buf
= kmalloc(DMA_BUF_LEN
, GFP_KERNEL
);
248 REG_WRITE_D(ah
, AR_MACMISC
,
249 ((AR_MACMISC_DMA_OBS_LINE_8
<< AR_MACMISC_DMA_OBS_S
) |
250 (AR_MACMISC_MISC_OBS_BUS_1
<<
251 AR_MACMISC_MISC_OBS_BUS_MSB_S
)));
253 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
254 "Raw DMA Debug values:\n");
256 for (i
= 0; i
< ATH9K_NUM_DMA_DEBUG_REGS
; i
++) {
258 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
, "\n");
260 val
[i
] = REG_READ_D(ah
, AR_DMADBG_0
+ (i
* sizeof(u32
)));
261 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
, "%d: %08x ",
265 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
, "\n\n");
266 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
267 "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
269 for (i
= 0; i
< ATH9K_NUM_QUEUES
; i
++, qcuOffset
+= 4, dcuOffset
+= 5) {
280 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
281 "%2d %2x %1x %2x %2x\n",
282 i
, (*qcuBase
& (0x7 << qcuOffset
)) >> qcuOffset
,
283 (*qcuBase
& (0x8 << qcuOffset
)) >> (qcuOffset
+ 3),
284 val
[2] & (0x7 << (i
* 3)) >> (i
* 3),
285 (*dcuBase
& (0x1f << dcuOffset
)) >> dcuOffset
);
288 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
, "\n");
290 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
291 "qcu_stitch state: %2x qcu_fetch state: %2x\n",
292 (val
[3] & 0x003c0000) >> 18, (val
[3] & 0x03c00000) >> 22);
293 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
294 "qcu_complete state: %2x dcu_complete state: %2x\n",
295 (val
[3] & 0x1c000000) >> 26, (val
[6] & 0x3));
296 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
297 "dcu_arb state: %2x dcu_fp state: %2x\n",
298 (val
[5] & 0x06000000) >> 25, (val
[5] & 0x38000000) >> 27);
299 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
300 "chan_idle_dur: %3d chan_idle_dur_valid: %1d\n",
301 (val
[6] & 0x000003fc) >> 2, (val
[6] & 0x00000400) >> 10);
302 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
303 "txfifo_valid_0: %1d txfifo_valid_1: %1d\n",
304 (val
[6] & 0x00000800) >> 11, (val
[6] & 0x00001000) >> 12);
305 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
306 "txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n",
307 (val
[6] & 0x0001e000) >> 13, (val
[6] & 0x001e0000) >> 17);
309 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
, "pcu observe: 0x%x\n",
310 REG_READ_D(ah
, AR_OBS_BUS_1
));
311 len
+= snprintf(buf
+ len
, DMA_BUF_LEN
- len
,
312 "AR_CR: 0x%x\n", REG_READ_D(ah
, AR_CR
));
314 ath9k_ps_restore(sc
);
316 if (len
> DMA_BUF_LEN
)
319 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
324 static const struct file_operations fops_dma
= {
325 .read
= read_file_dma
,
326 .open
= ath9k_debugfs_open
,
327 .owner
= THIS_MODULE
,
328 .llseek
= default_llseek
,
332 void ath_debug_stat_interrupt(struct ath_softc
*sc
, enum ath9k_int status
)
335 sc
->debug
.stats
.istats
.total
++;
336 if (sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_EDMA
) {
337 if (status
& ATH9K_INT_RXLP
)
338 sc
->debug
.stats
.istats
.rxlp
++;
339 if (status
& ATH9K_INT_RXHP
)
340 sc
->debug
.stats
.istats
.rxhp
++;
341 if (status
& ATH9K_INT_BB_WATCHDOG
)
342 sc
->debug
.stats
.istats
.bb_watchdog
++;
344 if (status
& ATH9K_INT_RX
)
345 sc
->debug
.stats
.istats
.rxok
++;
347 if (status
& ATH9K_INT_RXEOL
)
348 sc
->debug
.stats
.istats
.rxeol
++;
349 if (status
& ATH9K_INT_RXORN
)
350 sc
->debug
.stats
.istats
.rxorn
++;
351 if (status
& ATH9K_INT_TX
)
352 sc
->debug
.stats
.istats
.txok
++;
353 if (status
& ATH9K_INT_TXURN
)
354 sc
->debug
.stats
.istats
.txurn
++;
355 if (status
& ATH9K_INT_MIB
)
356 sc
->debug
.stats
.istats
.mib
++;
357 if (status
& ATH9K_INT_RXPHY
)
358 sc
->debug
.stats
.istats
.rxphyerr
++;
359 if (status
& ATH9K_INT_RXKCM
)
360 sc
->debug
.stats
.istats
.rx_keycache_miss
++;
361 if (status
& ATH9K_INT_SWBA
)
362 sc
->debug
.stats
.istats
.swba
++;
363 if (status
& ATH9K_INT_BMISS
)
364 sc
->debug
.stats
.istats
.bmiss
++;
365 if (status
& ATH9K_INT_BNR
)
366 sc
->debug
.stats
.istats
.bnr
++;
367 if (status
& ATH9K_INT_CST
)
368 sc
->debug
.stats
.istats
.cst
++;
369 if (status
& ATH9K_INT_GTT
)
370 sc
->debug
.stats
.istats
.gtt
++;
371 if (status
& ATH9K_INT_TIM
)
372 sc
->debug
.stats
.istats
.tim
++;
373 if (status
& ATH9K_INT_CABEND
)
374 sc
->debug
.stats
.istats
.cabend
++;
375 if (status
& ATH9K_INT_DTIMSYNC
)
376 sc
->debug
.stats
.istats
.dtimsync
++;
377 if (status
& ATH9K_INT_DTIM
)
378 sc
->debug
.stats
.istats
.dtim
++;
379 if (status
& ATH9K_INT_TSFOOR
)
380 sc
->debug
.stats
.istats
.tsfoor
++;
383 static ssize_t
read_file_interrupt(struct file
*file
, char __user
*user_buf
,
384 size_t count
, loff_t
*ppos
)
386 struct ath_softc
*sc
= file
->private_data
;
388 unsigned int len
= 0;
390 if (sc
->sc_ah
->caps
.hw_caps
& ATH9K_HW_CAP_EDMA
) {
391 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
392 "%8s: %10u\n", "RXLP", sc
->debug
.stats
.istats
.rxlp
);
393 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
394 "%8s: %10u\n", "RXHP", sc
->debug
.stats
.istats
.rxhp
);
395 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
396 "%8s: %10u\n", "WATCHDOG",
397 sc
->debug
.stats
.istats
.bb_watchdog
);
399 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
400 "%8s: %10u\n", "RX", sc
->debug
.stats
.istats
.rxok
);
402 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
403 "%8s: %10u\n", "RXEOL", sc
->debug
.stats
.istats
.rxeol
);
404 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
405 "%8s: %10u\n", "RXORN", sc
->debug
.stats
.istats
.rxorn
);
406 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
407 "%8s: %10u\n", "TX", sc
->debug
.stats
.istats
.txok
);
408 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
409 "%8s: %10u\n", "TXURN", sc
->debug
.stats
.istats
.txurn
);
410 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
411 "%8s: %10u\n", "MIB", sc
->debug
.stats
.istats
.mib
);
412 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
413 "%8s: %10u\n", "RXPHY", sc
->debug
.stats
.istats
.rxphyerr
);
414 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
415 "%8s: %10u\n", "RXKCM", sc
->debug
.stats
.istats
.rx_keycache_miss
);
416 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
417 "%8s: %10u\n", "SWBA", sc
->debug
.stats
.istats
.swba
);
418 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
419 "%8s: %10u\n", "BMISS", sc
->debug
.stats
.istats
.bmiss
);
420 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
421 "%8s: %10u\n", "BNR", sc
->debug
.stats
.istats
.bnr
);
422 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
423 "%8s: %10u\n", "CST", sc
->debug
.stats
.istats
.cst
);
424 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
425 "%8s: %10u\n", "GTT", sc
->debug
.stats
.istats
.gtt
);
426 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
427 "%8s: %10u\n", "TIM", sc
->debug
.stats
.istats
.tim
);
428 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
429 "%8s: %10u\n", "CABEND", sc
->debug
.stats
.istats
.cabend
);
430 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
431 "%8s: %10u\n", "DTIMSYNC", sc
->debug
.stats
.istats
.dtimsync
);
432 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
433 "%8s: %10u\n", "DTIM", sc
->debug
.stats
.istats
.dtim
);
434 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
435 "%8s: %10u\n", "TSFOOR", sc
->debug
.stats
.istats
.tsfoor
);
436 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
437 "%8s: %10u\n", "TOTAL", sc
->debug
.stats
.istats
.total
);
440 if (len
> sizeof(buf
))
443 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
446 static const struct file_operations fops_interrupt
= {
447 .read
= read_file_interrupt
,
448 .open
= ath9k_debugfs_open
,
449 .owner
= THIS_MODULE
,
450 .llseek
= default_llseek
,
453 static const char *channel_type_str(enum nl80211_channel_type t
)
456 case NL80211_CHAN_NO_HT
:
458 case NL80211_CHAN_HT20
:
460 case NL80211_CHAN_HT40MINUS
:
462 case NL80211_CHAN_HT40PLUS
:
469 static ssize_t
read_file_wiphy(struct file
*file
, char __user
*user_buf
,
470 size_t count
, loff_t
*ppos
)
472 struct ath_softc
*sc
= file
->private_data
;
473 struct ieee80211_channel
*chan
= sc
->hw
->conf
.channel
;
474 struct ieee80211_conf
*conf
= &(sc
->hw
->conf
);
476 unsigned int len
= 0;
480 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
481 "%s (chan=%d center-freq: %d MHz channel-type: %d (%s))\n",
482 wiphy_name(sc
->hw
->wiphy
),
483 ieee80211_frequency_to_channel(chan
->center_freq
),
486 channel_type_str(conf
->channel_type
));
489 put_unaligned_le32(REG_READ_D(sc
->sc_ah
, AR_STA_ID0
), addr
);
490 put_unaligned_le16(REG_READ_D(sc
->sc_ah
, AR_STA_ID1
) & 0xffff, addr
+ 4);
491 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
492 "addr: %pM\n", addr
);
493 put_unaligned_le32(REG_READ_D(sc
->sc_ah
, AR_BSSMSKL
), addr
);
494 put_unaligned_le16(REG_READ_D(sc
->sc_ah
, AR_BSSMSKU
) & 0xffff, addr
+ 4);
495 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
496 "addrmask: %pM\n", addr
);
497 tmp
= ath9k_hw_getrxfilter(sc
->sc_ah
);
498 ath9k_ps_restore(sc
);
499 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
,
501 if (tmp
& ATH9K_RX_FILTER_UCAST
)
502 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " UCAST");
503 if (tmp
& ATH9K_RX_FILTER_MCAST
)
504 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " MCAST");
505 if (tmp
& ATH9K_RX_FILTER_BCAST
)
506 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " BCAST");
507 if (tmp
& ATH9K_RX_FILTER_CONTROL
)
508 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " CONTROL");
509 if (tmp
& ATH9K_RX_FILTER_BEACON
)
510 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " BEACON");
511 if (tmp
& ATH9K_RX_FILTER_PROM
)
512 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " PROM");
513 if (tmp
& ATH9K_RX_FILTER_PROBEREQ
)
514 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " PROBEREQ");
515 if (tmp
& ATH9K_RX_FILTER_PHYERR
)
516 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " PHYERR");
517 if (tmp
& ATH9K_RX_FILTER_MYBEACON
)
518 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " MYBEACON");
519 if (tmp
& ATH9K_RX_FILTER_COMP_BAR
)
520 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " COMP_BAR");
521 if (tmp
& ATH9K_RX_FILTER_PSPOLL
)
522 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " PSPOLL");
523 if (tmp
& ATH9K_RX_FILTER_PHYRADAR
)
524 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " PHYRADAR");
525 if (tmp
& ATH9K_RX_FILTER_MCAST_BCAST_ALL
)
526 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, " MCAST_BCAST_ALL\n");
528 len
+= snprintf(buf
+ len
, sizeof(buf
) - len
, "\n");
530 if (len
> sizeof(buf
))
533 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
536 static const struct file_operations fops_wiphy
= {
537 .read
= read_file_wiphy
,
538 .open
= ath9k_debugfs_open
,
539 .owner
= THIS_MODULE
,
540 .llseek
= default_llseek
,
543 #define PR_QNUM(_n) sc->tx.txq_map[_n]->axq_qnum
544 #define PR(str, elem) \
546 len += snprintf(buf + len, size - len, \
547 "%s%13u%11u%10u%10u\n", str, \
548 sc->debug.stats.txstats[PR_QNUM(WME_AC_BE)].elem, \
549 sc->debug.stats.txstats[PR_QNUM(WME_AC_BK)].elem, \
550 sc->debug.stats.txstats[PR_QNUM(WME_AC_VI)].elem, \
551 sc->debug.stats.txstats[PR_QNUM(WME_AC_VO)].elem); \
556 #define PRX(str, elem) \
558 len += snprintf(buf + len, size - len, \
559 "%s%13u%11u%10u%10u\n", str, \
560 (unsigned int)(sc->tx.txq_map[WME_AC_BE]->elem), \
561 (unsigned int)(sc->tx.txq_map[WME_AC_BK]->elem), \
562 (unsigned int)(sc->tx.txq_map[WME_AC_VI]->elem), \
563 (unsigned int)(sc->tx.txq_map[WME_AC_VO]->elem)); \
568 #define PRQLE(str, elem) \
570 len += snprintf(buf + len, size - len, \
571 "%s%13i%11i%10i%10i\n", str, \
572 list_empty(&sc->tx.txq_map[WME_AC_BE]->elem), \
573 list_empty(&sc->tx.txq_map[WME_AC_BK]->elem), \
574 list_empty(&sc->tx.txq_map[WME_AC_VI]->elem), \
575 list_empty(&sc->tx.txq_map[WME_AC_VO]->elem)); \
580 static ssize_t
read_file_xmit(struct file
*file
, char __user
*user_buf
,
581 size_t count
, loff_t
*ppos
)
583 struct ath_softc
*sc
= file
->private_data
;
585 unsigned int len
= 0, size
= 8000;
590 buf
= kzalloc(size
, GFP_KERNEL
);
594 len
+= sprintf(buf
, "Num-Tx-Queues: %i tx-queues-setup: 0x%x"
595 " poll-work-seen: %u\n"
596 "%30s %10s%10s%10s\n\n",
597 ATH9K_NUM_TX_QUEUES
, sc
->tx
.txqsetup
,
598 sc
->tx_complete_poll_work_seen
,
599 "BE", "BK", "VI", "VO");
601 PR("MPDUs Queued: ", queued
);
602 PR("MPDUs Completed: ", completed
);
603 PR("MPDUs XRetried: ", xretries
);
604 PR("Aggregates: ", a_aggr
);
605 PR("AMPDUs Queued HW:", a_queued_hw
);
606 PR("AMPDUs Queued SW:", a_queued_sw
);
607 PR("AMPDUs Completed:", a_completed
);
608 PR("AMPDUs Retried: ", a_retries
);
609 PR("AMPDUs XRetried: ", a_xretries
);
610 PR("FIFO Underrun: ", fifo_underrun
);
611 PR("TXOP Exceeded: ", xtxop
);
612 PR("TXTIMER Expiry: ", timer_exp
);
613 PR("DESC CFG Error: ", desc_cfg_err
);
614 PR("DATA Underrun: ", data_underrun
);
615 PR("DELIM Underrun: ", delim_underrun
);
616 PR("TX-Pkts-All: ", tx_pkts_all
);
617 PR("TX-Bytes-All: ", tx_bytes_all
);
618 PR("hw-put-tx-buf: ", puttxbuf
);
619 PR("hw-tx-start: ", txstart
);
620 PR("hw-tx-proc-desc: ", txprocdesc
);
621 len
+= snprintf(buf
+ len
, size
- len
,
622 "%s%11p%11p%10p%10p\n", "txq-memory-address:",
623 sc
->tx
.txq_map
[WME_AC_BE
],
624 sc
->tx
.txq_map
[WME_AC_BK
],
625 sc
->tx
.txq_map
[WME_AC_VI
],
626 sc
->tx
.txq_map
[WME_AC_VO
]);
630 PRX("axq-qnum: ", axq_qnum
);
631 PRX("axq-depth: ", axq_depth
);
632 PRX("axq-ampdu_depth: ", axq_ampdu_depth
);
633 PRX("axq-stopped ", stopped
);
634 PRX("tx-in-progress ", axq_tx_inprogress
);
635 PRX("pending-frames ", pending_frames
);
636 PRX("txq_headidx: ", txq_headidx
);
637 PRX("txq_tailidx: ", txq_headidx
);
639 PRQLE("axq_q empty: ", axq_q
);
640 PRQLE("axq_acq empty: ", axq_acq
);
641 for (i
= 0; i
< ATH_TXFIFO_DEPTH
; i
++) {
642 snprintf(tmp
, sizeof(tmp
) - 1, "txq_fifo[%i] empty: ", i
);
643 PRQLE(tmp
, txq_fifo
[i
]);
646 /* Print out more detailed queue-info */
647 for (i
= 0; i
<= WME_AC_BK
; i
++) {
648 struct ath_txq
*txq
= &(sc
->tx
.txq
[i
]);
649 struct ath_atx_ac
*ac
;
650 struct ath_atx_tid
*tid
;
653 spin_lock_bh(&txq
->axq_lock
);
654 if (!list_empty(&txq
->axq_acq
)) {
655 ac
= list_first_entry(&txq
->axq_acq
, struct ath_atx_ac
,
657 len
+= snprintf(buf
+ len
, size
- len
,
658 "txq[%i] first-ac: %p sched: %i\n",
660 if (list_empty(&ac
->tid_q
) || (len
>= size
))
662 tid
= list_first_entry(&ac
->tid_q
, struct ath_atx_tid
,
664 len
+= snprintf(buf
+ len
, size
- len
,
665 " first-tid: %p sched: %i paused: %i\n",
666 tid
, tid
->sched
, tid
->paused
);
669 spin_unlock_bh(&txq
->axq_lock
);
676 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
682 static ssize_t
read_file_stations(struct file
*file
, char __user
*user_buf
,
683 size_t count
, loff_t
*ppos
)
685 struct ath_softc
*sc
= file
->private_data
;
687 unsigned int len
= 0, size
= 64000;
688 struct ath_node
*an
= NULL
;
692 buf
= kzalloc(size
, GFP_KERNEL
);
696 len
+= snprintf(buf
+ len
, size
- len
,
698 " tid: addr sched paused buf_q-empty an ac\n"
699 " ac: addr sched tid_q-empty txq\n");
701 spin_lock(&sc
->nodes_lock
);
702 list_for_each_entry(an
, &sc
->nodes
, list
) {
703 len
+= snprintf(buf
+ len
, size
- len
,
704 "%pM\n", an
->sta
->addr
);
708 for (q
= 0; q
< WME_NUM_TID
; q
++) {
709 struct ath_atx_tid
*tid
= &(an
->tid
[q
]);
710 len
+= snprintf(buf
+ len
, size
- len
,
711 " tid: %p %s %s %i %p %p\n",
712 tid
, tid
->sched
? "sched" : "idle",
713 tid
->paused
? "paused" : "running",
714 list_empty(&tid
->buf_q
),
720 for (q
= 0; q
< WME_NUM_AC
; q
++) {
721 struct ath_atx_ac
*ac
= &(an
->ac
[q
]);
722 len
+= snprintf(buf
+ len
, size
- len
,
723 " ac: %p %s %i %p\n",
724 ac
, ac
->sched
? "sched" : "idle",
725 list_empty(&ac
->tid_q
), ac
->txq
);
732 spin_unlock(&sc
->nodes_lock
);
736 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
742 static ssize_t
read_file_misc(struct file
*file
, char __user
*user_buf
,
743 size_t count
, loff_t
*ppos
)
745 struct ath_softc
*sc
= file
->private_data
;
746 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
747 struct ath_hw
*ah
= sc
->sc_ah
;
748 struct ieee80211_hw
*hw
= sc
->hw
;
750 unsigned int len
= 0, size
= 8000;
753 struct ath9k_vif_iter_data iter_data
;
755 ath9k_calculate_iter_data(hw
, NULL
, &iter_data
);
757 buf
= kzalloc(size
, GFP_KERNEL
);
762 len
+= snprintf(buf
+ len
, size
- len
,
765 "Beacon-Timer-Register: 0x%x\n",
767 ath_opmode_to_string(sc
->sc_ah
->opmode
),
768 (int)(sc
->sc_ah
->opmode
),
769 REG_READ(ah
, AR_BEACON_PERIOD
));
771 reg
= REG_READ(ah
, AR_TIMER_MODE
);
772 ath9k_ps_restore(sc
);
773 len
+= snprintf(buf
+ len
, size
- len
, "Timer-Mode-Register: 0x%x (",
775 if (reg
& AR_TBTT_TIMER_EN
)
776 len
+= snprintf(buf
+ len
, size
- len
, "TBTT ");
777 if (reg
& AR_DBA_TIMER_EN
)
778 len
+= snprintf(buf
+ len
, size
- len
, "DBA ");
779 if (reg
& AR_SWBA_TIMER_EN
)
780 len
+= snprintf(buf
+ len
, size
- len
, "SWBA ");
781 if (reg
& AR_HCF_TIMER_EN
)
782 len
+= snprintf(buf
+ len
, size
- len
, "HCF ");
783 if (reg
& AR_TIM_TIMER_EN
)
784 len
+= snprintf(buf
+ len
, size
- len
, "TIM ");
785 if (reg
& AR_DTIM_TIMER_EN
)
786 len
+= snprintf(buf
+ len
, size
- len
, "DTIM ");
787 len
+= snprintf(buf
+ len
, size
- len
, ")\n");
789 reg
= sc
->sc_ah
->imask
;
790 len
+= snprintf(buf
+ len
, size
- len
, "imask: 0x%x (", reg
);
791 if (reg
& ATH9K_INT_SWBA
)
792 len
+= snprintf(buf
+ len
, size
- len
, "SWBA ");
793 if (reg
& ATH9K_INT_BMISS
)
794 len
+= snprintf(buf
+ len
, size
- len
, "BMISS ");
795 if (reg
& ATH9K_INT_CST
)
796 len
+= snprintf(buf
+ len
, size
- len
, "CST ");
797 if (reg
& ATH9K_INT_RX
)
798 len
+= snprintf(buf
+ len
, size
- len
, "RX ");
799 if (reg
& ATH9K_INT_RXHP
)
800 len
+= snprintf(buf
+ len
, size
- len
, "RXHP ");
801 if (reg
& ATH9K_INT_RXLP
)
802 len
+= snprintf(buf
+ len
, size
- len
, "RXLP ");
803 if (reg
& ATH9K_INT_BB_WATCHDOG
)
804 len
+= snprintf(buf
+ len
, size
- len
, "BB_WATCHDOG ");
805 /* there are other IRQs if one wanted to add them. */
806 len
+= snprintf(buf
+ len
, size
- len
, ")\n");
808 len
+= snprintf(buf
+ len
, size
- len
,
809 "VIF Counts: AP: %i STA: %i MESH: %i WDS: %i"
810 " ADHOC: %i OTHER: %i nvifs: %hi beacon-vifs: %hi\n",
811 iter_data
.naps
, iter_data
.nstations
, iter_data
.nmeshes
,
812 iter_data
.nwds
, iter_data
.nadhocs
, iter_data
.nothers
,
813 sc
->nvifs
, sc
->nbcnvifs
);
815 len
+= snprintf(buf
+ len
, size
- len
,
816 "Calculated-BSSID-Mask: %pM\n",
822 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
828 void ath_debug_stat_tx(struct ath_softc
*sc
, struct ath_buf
*bf
,
829 struct ath_tx_status
*ts
, struct ath_txq
*txq
)
831 #define TX_SAMP_DBG(c) (sc->debug.bb_mac_samp[sc->debug.sampidx].ts\
833 int qnum
= txq
->axq_qnum
;
835 TX_STAT_INC(qnum
, tx_pkts_all
);
836 sc
->debug
.stats
.txstats
[qnum
].tx_bytes_all
+= bf
->bf_mpdu
->len
;
838 if (bf_isampdu(bf
)) {
839 if (bf_isxretried(bf
))
840 TX_STAT_INC(qnum
, a_xretries
);
842 TX_STAT_INC(qnum
, a_completed
);
844 if (bf_isxretried(bf
))
845 TX_STAT_INC(qnum
, xretries
);
847 TX_STAT_INC(qnum
, completed
);
850 if (ts
->ts_status
& ATH9K_TXERR_FIFO
)
851 TX_STAT_INC(qnum
, fifo_underrun
);
852 if (ts
->ts_status
& ATH9K_TXERR_XTXOP
)
853 TX_STAT_INC(qnum
, xtxop
);
854 if (ts
->ts_status
& ATH9K_TXERR_TIMER_EXPIRED
)
855 TX_STAT_INC(qnum
, timer_exp
);
856 if (ts
->ts_flags
& ATH9K_TX_DESC_CFG_ERR
)
857 TX_STAT_INC(qnum
, desc_cfg_err
);
858 if (ts
->ts_flags
& ATH9K_TX_DATA_UNDERRUN
)
859 TX_STAT_INC(qnum
, data_underrun
);
860 if (ts
->ts_flags
& ATH9K_TX_DELIM_UNDERRUN
)
861 TX_STAT_INC(qnum
, delim_underrun
);
863 spin_lock(&sc
->debug
.samp_lock
);
864 TX_SAMP_DBG(jiffies
) = jiffies
;
865 TX_SAMP_DBG(rssi_ctl0
) = ts
->ts_rssi_ctl0
;
866 TX_SAMP_DBG(rssi_ctl1
) = ts
->ts_rssi_ctl1
;
867 TX_SAMP_DBG(rssi_ctl2
) = ts
->ts_rssi_ctl2
;
868 TX_SAMP_DBG(rssi_ext0
) = ts
->ts_rssi_ext0
;
869 TX_SAMP_DBG(rssi_ext1
) = ts
->ts_rssi_ext1
;
870 TX_SAMP_DBG(rssi_ext2
) = ts
->ts_rssi_ext2
;
871 TX_SAMP_DBG(rateindex
) = ts
->ts_rateindex
;
872 TX_SAMP_DBG(isok
) = !!(ts
->ts_status
& ATH9K_TXERR_MASK
);
873 TX_SAMP_DBG(rts_fail_cnt
) = ts
->ts_shortretry
;
874 TX_SAMP_DBG(data_fail_cnt
) = ts
->ts_longretry
;
875 TX_SAMP_DBG(rssi
) = ts
->ts_rssi
;
876 TX_SAMP_DBG(tid
) = ts
->tid
;
877 TX_SAMP_DBG(qid
) = ts
->qid
;
878 sc
->debug
.tsidx
= (sc
->debug
.tsidx
+ 1) % ATH_DBG_MAX_SAMPLES
;
879 spin_unlock(&sc
->debug
.samp_lock
);
884 static const struct file_operations fops_xmit
= {
885 .read
= read_file_xmit
,
886 .open
= ath9k_debugfs_open
,
887 .owner
= THIS_MODULE
,
888 .llseek
= default_llseek
,
891 static const struct file_operations fops_stations
= {
892 .read
= read_file_stations
,
893 .open
= ath9k_debugfs_open
,
894 .owner
= THIS_MODULE
,
895 .llseek
= default_llseek
,
898 static const struct file_operations fops_misc
= {
899 .read
= read_file_misc
,
900 .open
= ath9k_debugfs_open
,
901 .owner
= THIS_MODULE
,
902 .llseek
= default_llseek
,
905 static ssize_t
read_file_recv(struct file
*file
, char __user
*user_buf
,
906 size_t count
, loff_t
*ppos
)
908 #define PHY_ERR(s, p) \
909 len += snprintf(buf + len, size - len, "%18s : %10u\n", s, \
910 sc->debug.stats.rxstats.phy_err_stats[p]);
912 struct ath_softc
*sc
= file
->private_data
;
914 unsigned int len
= 0, size
= 1400;
917 buf
= kzalloc(size
, GFP_KERNEL
);
921 len
+= snprintf(buf
+ len
, size
- len
,
922 "%18s : %10u\n", "CRC ERR",
923 sc
->debug
.stats
.rxstats
.crc_err
);
924 len
+= snprintf(buf
+ len
, size
- len
,
925 "%18s : %10u\n", "DECRYPT CRC ERR",
926 sc
->debug
.stats
.rxstats
.decrypt_crc_err
);
927 len
+= snprintf(buf
+ len
, size
- len
,
928 "%18s : %10u\n", "PHY ERR",
929 sc
->debug
.stats
.rxstats
.phy_err
);
930 len
+= snprintf(buf
+ len
, size
- len
,
931 "%18s : %10u\n", "MIC ERR",
932 sc
->debug
.stats
.rxstats
.mic_err
);
933 len
+= snprintf(buf
+ len
, size
- len
,
934 "%18s : %10u\n", "PRE-DELIM CRC ERR",
935 sc
->debug
.stats
.rxstats
.pre_delim_crc_err
);
936 len
+= snprintf(buf
+ len
, size
- len
,
937 "%18s : %10u\n", "POST-DELIM CRC ERR",
938 sc
->debug
.stats
.rxstats
.post_delim_crc_err
);
939 len
+= snprintf(buf
+ len
, size
- len
,
940 "%18s : %10u\n", "DECRYPT BUSY ERR",
941 sc
->debug
.stats
.rxstats
.decrypt_busy_err
);
943 len
+= snprintf(buf
+ len
, size
- len
,
944 "%18s : %10d\n", "RSSI-CTL0",
945 sc
->debug
.stats
.rxstats
.rs_rssi_ctl0
);
947 len
+= snprintf(buf
+ len
, size
- len
,
948 "%18s : %10d\n", "RSSI-CTL1",
949 sc
->debug
.stats
.rxstats
.rs_rssi_ctl1
);
951 len
+= snprintf(buf
+ len
, size
- len
,
952 "%18s : %10d\n", "RSSI-CTL2",
953 sc
->debug
.stats
.rxstats
.rs_rssi_ctl2
);
955 len
+= snprintf(buf
+ len
, size
- len
,
956 "%18s : %10d\n", "RSSI-EXT0",
957 sc
->debug
.stats
.rxstats
.rs_rssi_ext0
);
959 len
+= snprintf(buf
+ len
, size
- len
,
960 "%18s : %10d\n", "RSSI-EXT1",
961 sc
->debug
.stats
.rxstats
.rs_rssi_ext1
);
963 len
+= snprintf(buf
+ len
, size
- len
,
964 "%18s : %10d\n", "RSSI-EXT2",
965 sc
->debug
.stats
.rxstats
.rs_rssi_ext2
);
967 len
+= snprintf(buf
+ len
, size
- len
,
968 "%18s : %10d\n", "Rx Antenna",
969 sc
->debug
.stats
.rxstats
.rs_antenna
);
971 PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN
);
972 PHY_ERR("TIMING", ATH9K_PHYERR_TIMING
);
973 PHY_ERR("PARITY", ATH9K_PHYERR_PARITY
);
974 PHY_ERR("RATE", ATH9K_PHYERR_RATE
);
975 PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH
);
976 PHY_ERR("RADAR", ATH9K_PHYERR_RADAR
);
977 PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE
);
978 PHY_ERR("TOR", ATH9K_PHYERR_TOR
);
979 PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING
);
980 PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY
);
981 PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL
);
982 PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL
);
983 PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP
);
984 PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE
);
985 PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART
);
986 PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT
);
987 PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING
);
988 PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC
);
989 PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL
);
990 PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE
);
991 PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART
);
992 PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL
);
993 PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP
);
994 PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR
);
995 PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL
);
996 PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL
);
998 len
+= snprintf(buf
+ len
, size
- len
,
999 "%18s : %10u\n", "RX-Pkts-All",
1000 sc
->debug
.stats
.rxstats
.rx_pkts_all
);
1001 len
+= snprintf(buf
+ len
, size
- len
,
1002 "%18s : %10u\n", "RX-Bytes-All",
1003 sc
->debug
.stats
.rxstats
.rx_bytes_all
);
1008 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1016 void ath_debug_stat_rx(struct ath_softc
*sc
, struct ath_rx_status
*rs
)
1018 #define RX_STAT_INC(c) sc->debug.stats.rxstats.c++
1019 #define RX_PHY_ERR_INC(c) sc->debug.stats.rxstats.phy_err_stats[c]++
1020 #define RX_SAMP_DBG(c) (sc->debug.bb_mac_samp[sc->debug.sampidx].rs\
1021 [sc->debug.rsidx].c)
1025 RX_STAT_INC(rx_pkts_all
);
1026 sc
->debug
.stats
.rxstats
.rx_bytes_all
+= rs
->rs_datalen
;
1028 if (rs
->rs_status
& ATH9K_RXERR_CRC
)
1029 RX_STAT_INC(crc_err
);
1030 if (rs
->rs_status
& ATH9K_RXERR_DECRYPT
)
1031 RX_STAT_INC(decrypt_crc_err
);
1032 if (rs
->rs_status
& ATH9K_RXERR_MIC
)
1033 RX_STAT_INC(mic_err
);
1034 if (rs
->rs_status
& ATH9K_RX_DELIM_CRC_PRE
)
1035 RX_STAT_INC(pre_delim_crc_err
);
1036 if (rs
->rs_status
& ATH9K_RX_DELIM_CRC_POST
)
1037 RX_STAT_INC(post_delim_crc_err
);
1038 if (rs
->rs_status
& ATH9K_RX_DECRYPT_BUSY
)
1039 RX_STAT_INC(decrypt_busy_err
);
1041 if (rs
->rs_status
& ATH9K_RXERR_PHY
) {
1042 RX_STAT_INC(phy_err
);
1043 phyerr
= rs
->rs_phyerr
& 0x24;
1044 RX_PHY_ERR_INC(phyerr
);
1047 sc
->debug
.stats
.rxstats
.rs_rssi_ctl0
= rs
->rs_rssi_ctl0
;
1048 sc
->debug
.stats
.rxstats
.rs_rssi_ctl1
= rs
->rs_rssi_ctl1
;
1049 sc
->debug
.stats
.rxstats
.rs_rssi_ctl2
= rs
->rs_rssi_ctl2
;
1051 sc
->debug
.stats
.rxstats
.rs_rssi_ext0
= rs
->rs_rssi_ext0
;
1052 sc
->debug
.stats
.rxstats
.rs_rssi_ext1
= rs
->rs_rssi_ext1
;
1053 sc
->debug
.stats
.rxstats
.rs_rssi_ext2
= rs
->rs_rssi_ext2
;
1055 sc
->debug
.stats
.rxstats
.rs_antenna
= rs
->rs_antenna
;
1057 spin_lock(&sc
->debug
.samp_lock
);
1058 RX_SAMP_DBG(jiffies
) = jiffies
;
1059 RX_SAMP_DBG(rssi_ctl0
) = rs
->rs_rssi_ctl0
;
1060 RX_SAMP_DBG(rssi_ctl1
) = rs
->rs_rssi_ctl1
;
1061 RX_SAMP_DBG(rssi_ctl2
) = rs
->rs_rssi_ctl2
;
1062 RX_SAMP_DBG(rssi_ext0
) = rs
->rs_rssi_ext0
;
1063 RX_SAMP_DBG(rssi_ext1
) = rs
->rs_rssi_ext1
;
1064 RX_SAMP_DBG(rssi_ext2
) = rs
->rs_rssi_ext2
;
1065 RX_SAMP_DBG(antenna
) = rs
->rs_antenna
;
1066 RX_SAMP_DBG(rssi
) = rs
->rs_rssi
;
1067 RX_SAMP_DBG(rate
) = rs
->rs_rate
;
1068 RX_SAMP_DBG(is_mybeacon
) = rs
->is_mybeacon
;
1070 sc
->debug
.rsidx
= (sc
->debug
.rsidx
+ 1) % ATH_DBG_MAX_SAMPLES
;
1071 spin_unlock(&sc
->debug
.samp_lock
);
1074 #undef RX_PHY_ERR_INC
1078 static const struct file_operations fops_recv
= {
1079 .read
= read_file_recv
,
1080 .open
= ath9k_debugfs_open
,
1081 .owner
= THIS_MODULE
,
1082 .llseek
= default_llseek
,
1085 static ssize_t
read_file_regidx(struct file
*file
, char __user
*user_buf
,
1086 size_t count
, loff_t
*ppos
)
1088 struct ath_softc
*sc
= file
->private_data
;
1092 len
= sprintf(buf
, "0x%08x\n", sc
->debug
.regidx
);
1093 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1096 static ssize_t
write_file_regidx(struct file
*file
, const char __user
*user_buf
,
1097 size_t count
, loff_t
*ppos
)
1099 struct ath_softc
*sc
= file
->private_data
;
1100 unsigned long regidx
;
1104 len
= min(count
, sizeof(buf
) - 1);
1105 if (copy_from_user(buf
, user_buf
, len
))
1109 if (strict_strtoul(buf
, 0, ®idx
))
1112 sc
->debug
.regidx
= regidx
;
1116 static const struct file_operations fops_regidx
= {
1117 .read
= read_file_regidx
,
1118 .write
= write_file_regidx
,
1119 .open
= ath9k_debugfs_open
,
1120 .owner
= THIS_MODULE
,
1121 .llseek
= default_llseek
,
1124 static ssize_t
read_file_regval(struct file
*file
, char __user
*user_buf
,
1125 size_t count
, loff_t
*ppos
)
1127 struct ath_softc
*sc
= file
->private_data
;
1128 struct ath_hw
*ah
= sc
->sc_ah
;
1133 ath9k_ps_wakeup(sc
);
1134 regval
= REG_READ_D(ah
, sc
->debug
.regidx
);
1135 ath9k_ps_restore(sc
);
1136 len
= sprintf(buf
, "0x%08x\n", regval
);
1137 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1140 static ssize_t
write_file_regval(struct file
*file
, const char __user
*user_buf
,
1141 size_t count
, loff_t
*ppos
)
1143 struct ath_softc
*sc
= file
->private_data
;
1144 struct ath_hw
*ah
= sc
->sc_ah
;
1145 unsigned long regval
;
1149 len
= min(count
, sizeof(buf
) - 1);
1150 if (copy_from_user(buf
, user_buf
, len
))
1154 if (strict_strtoul(buf
, 0, ®val
))
1157 ath9k_ps_wakeup(sc
);
1158 REG_WRITE_D(ah
, sc
->debug
.regidx
, regval
);
1159 ath9k_ps_restore(sc
);
1163 static const struct file_operations fops_regval
= {
1164 .read
= read_file_regval
,
1165 .write
= write_file_regval
,
1166 .open
= ath9k_debugfs_open
,
1167 .owner
= THIS_MODULE
,
1168 .llseek
= default_llseek
,
1171 #define REGDUMP_LINE_SIZE 20
1173 static int open_file_regdump(struct inode
*inode
, struct file
*file
)
1175 struct ath_softc
*sc
= inode
->i_private
;
1176 unsigned int len
= 0;
1179 unsigned long num_regs
, regdump_len
, max_reg_offset
;
1181 max_reg_offset
= AR_SREV_9300_20_OR_LATER(sc
->sc_ah
) ? 0x16bd4 : 0xb500;
1182 num_regs
= max_reg_offset
/ 4 + 1;
1183 regdump_len
= num_regs
* REGDUMP_LINE_SIZE
+ 1;
1184 buf
= vmalloc(regdump_len
);
1188 ath9k_ps_wakeup(sc
);
1189 for (i
= 0; i
< num_regs
; i
++)
1190 len
+= scnprintf(buf
+ len
, regdump_len
- len
,
1191 "0x%06x 0x%08x\n", i
<< 2, REG_READ(sc
->sc_ah
, i
<< 2));
1192 ath9k_ps_restore(sc
);
1194 file
->private_data
= buf
;
1199 static const struct file_operations fops_regdump
= {
1200 .open
= open_file_regdump
,
1201 .read
= ath9k_debugfs_read_buf
,
1202 .release
= ath9k_debugfs_release_buf
,
1203 .owner
= THIS_MODULE
,
1204 .llseek
= default_llseek
,/* read accesses f_pos */
1207 static ssize_t
read_file_dump_nfcal(struct file
*file
, char __user
*user_buf
,
1208 size_t count
, loff_t
*ppos
)
1210 struct ath_softc
*sc
= file
->private_data
;
1211 struct ath_hw
*ah
= sc
->sc_ah
;
1212 struct ath9k_nfcal_hist
*h
= sc
->caldata
.nfCalHist
;
1213 struct ath_common
*common
= ath9k_hw_common(ah
);
1214 struct ieee80211_conf
*conf
= &common
->hw
->conf
;
1215 u32 len
= 0, size
= 1500;
1219 u8 chainmask
= (ah
->rxchainmask
<< 3) | ah
->rxchainmask
;
1222 buf
= kzalloc(size
, GFP_KERNEL
);
1226 len
+= snprintf(buf
+ len
, size
- len
,
1227 "Channel Noise Floor : %d\n", ah
->noise
);
1228 len
+= snprintf(buf
+ len
, size
- len
,
1229 "Chain | privNF | # Readings | NF Readings\n");
1230 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
1231 if (!(chainmask
& (1 << i
)) ||
1232 ((i
>= AR5416_MAX_CHAINS
) && !conf_is_ht40(conf
)))
1235 nread
= AR_PHY_CCA_FILTERWINDOW_LENGTH
- h
[i
].invalidNFcount
;
1236 len
+= snprintf(buf
+ len
, size
- len
, " %d\t %d\t %d\t\t",
1237 i
, h
[i
].privNF
, nread
);
1238 for (j
= 0; j
< nread
; j
++)
1239 len
+= snprintf(buf
+ len
, size
- len
,
1240 " %d", h
[i
].nfCalBuffer
[j
]);
1241 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1247 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1253 static const struct file_operations fops_dump_nfcal
= {
1254 .read
= read_file_dump_nfcal
,
1255 .open
= ath9k_debugfs_open
,
1256 .owner
= THIS_MODULE
,
1257 .llseek
= default_llseek
,
1260 static ssize_t
read_file_base_eeprom(struct file
*file
, char __user
*user_buf
,
1261 size_t count
, loff_t
*ppos
)
1263 struct ath_softc
*sc
= file
->private_data
;
1264 struct ath_hw
*ah
= sc
->sc_ah
;
1265 u32 len
= 0, size
= 1500;
1269 buf
= kzalloc(size
, GFP_KERNEL
);
1273 len
= ah
->eep_ops
->dump_eeprom(ah
, true, buf
, len
, size
);
1275 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1281 static const struct file_operations fops_base_eeprom
= {
1282 .read
= read_file_base_eeprom
,
1283 .open
= ath9k_debugfs_open
,
1284 .owner
= THIS_MODULE
,
1285 .llseek
= default_llseek
,
1288 static ssize_t
read_file_modal_eeprom(struct file
*file
, char __user
*user_buf
,
1289 size_t count
, loff_t
*ppos
)
1291 struct ath_softc
*sc
= file
->private_data
;
1292 struct ath_hw
*ah
= sc
->sc_ah
;
1293 u32 len
= 0, size
= 6000;
1297 buf
= kzalloc(size
, GFP_KERNEL
);
1301 len
= ah
->eep_ops
->dump_eeprom(ah
, false, buf
, len
, size
);
1303 retval
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
1309 static const struct file_operations fops_modal_eeprom
= {
1310 .read
= read_file_modal_eeprom
,
1311 .open
= ath9k_debugfs_open
,
1312 .owner
= THIS_MODULE
,
1313 .llseek
= default_llseek
,
1316 void ath9k_debug_samp_bb_mac(struct ath_softc
*sc
)
1318 #define ATH_SAMP_DBG(c) (sc->debug.bb_mac_samp[sc->debug.sampidx].c)
1319 struct ath_hw
*ah
= sc
->sc_ah
;
1320 struct ath_common
*common
= ath9k_hw_common(ah
);
1321 unsigned long flags
;
1324 ath9k_ps_wakeup(sc
);
1326 spin_lock_irqsave(&common
->cc_lock
, flags
);
1327 ath_hw_cycle_counters_update(common
);
1328 spin_unlock_irqrestore(&common
->cc_lock
, flags
);
1330 spin_lock_bh(&sc
->debug
.samp_lock
);
1332 ATH_SAMP_DBG(cc
.cycles
) = common
->cc_ani
.cycles
;
1333 ATH_SAMP_DBG(cc
.rx_busy
) = common
->cc_ani
.rx_busy
;
1334 ATH_SAMP_DBG(cc
.rx_frame
) = common
->cc_ani
.rx_frame
;
1335 ATH_SAMP_DBG(cc
.tx_frame
) = common
->cc_ani
.tx_frame
;
1336 ATH_SAMP_DBG(noise
) = ah
->noise
;
1338 REG_WRITE_D(ah
, AR_MACMISC
,
1339 ((AR_MACMISC_DMA_OBS_LINE_8
<< AR_MACMISC_DMA_OBS_S
) |
1340 (AR_MACMISC_MISC_OBS_BUS_1
<<
1341 AR_MACMISC_MISC_OBS_BUS_MSB_S
)));
1343 for (i
= 0; i
< ATH9K_NUM_DMA_DEBUG_REGS
; i
++)
1344 ATH_SAMP_DBG(dma_dbg_reg_vals
[i
]) = REG_READ_D(ah
,
1345 AR_DMADBG_0
+ (i
* sizeof(u32
)));
1347 ATH_SAMP_DBG(pcu_obs
) = REG_READ_D(ah
, AR_OBS_BUS_1
);
1348 ATH_SAMP_DBG(pcu_cr
) = REG_READ_D(ah
, AR_CR
);
1350 memcpy(ATH_SAMP_DBG(nfCalHist
), sc
->caldata
.nfCalHist
,
1351 sizeof(ATH_SAMP_DBG(nfCalHist
)));
1353 sc
->debug
.sampidx
= (sc
->debug
.sampidx
+ 1) % ATH_DBG_MAX_SAMPLES
;
1354 spin_unlock_bh(&sc
->debug
.samp_lock
);
1355 ath9k_ps_restore(sc
);
1360 static int open_file_bb_mac_samps(struct inode
*inode
, struct file
*file
)
1362 #define ATH_SAMP_DBG(c) bb_mac_samp[sampidx].c
1363 struct ath_softc
*sc
= inode
->i_private
;
1364 struct ath_hw
*ah
= sc
->sc_ah
;
1365 struct ath_common
*common
= ath9k_hw_common(ah
);
1366 struct ieee80211_conf
*conf
= &common
->hw
->conf
;
1367 struct ath_dbg_bb_mac_samp
*bb_mac_samp
;
1368 struct ath9k_nfcal_hist
*h
;
1369 int i
, j
, qcuOffset
= 0, dcuOffset
= 0;
1370 u32
*qcuBase
, *dcuBase
, size
= 30000, len
= 0;
1373 u8 chainmask
= (ah
->rxchainmask
<< 3) | ah
->rxchainmask
;
1376 buf
= vmalloc(size
);
1379 bb_mac_samp
= vmalloc(sizeof(*bb_mac_samp
) * ATH_DBG_MAX_SAMPLES
);
1385 spin_lock_bh(&sc
->debug
.samp_lock
);
1386 memcpy(bb_mac_samp
, sc
->debug
.bb_mac_samp
,
1387 sizeof(*bb_mac_samp
) * ATH_DBG_MAX_SAMPLES
);
1388 spin_unlock_bh(&sc
->debug
.samp_lock
);
1390 len
+= snprintf(buf
+ len
, size
- len
,
1391 "Raw DMA Debug Dump:\n");
1392 len
+= snprintf(buf
+ len
, size
- len
, "Sample |\t");
1393 for (i
= 0; i
< ATH9K_NUM_DMA_DEBUG_REGS
; i
++)
1394 len
+= snprintf(buf
+ len
, size
- len
, " DMA Reg%d |\t", i
);
1395 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1397 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1398 len
+= snprintf(buf
+ len
, size
- len
, "%d\t", sampidx
);
1400 for (i
= 0; i
< ATH9K_NUM_DMA_DEBUG_REGS
; i
++)
1401 len
+= snprintf(buf
+ len
, size
- len
, " %08x\t",
1402 ATH_SAMP_DBG(dma_dbg_reg_vals
[i
]));
1403 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1405 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1407 len
+= snprintf(buf
+ len
, size
- len
,
1408 "Sample Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n");
1409 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1410 qcuBase
= &ATH_SAMP_DBG(dma_dbg_reg_vals
[0]);
1411 dcuBase
= &ATH_SAMP_DBG(dma_dbg_reg_vals
[4]);
1413 for (i
= 0; i
< ATH9K_NUM_QUEUES
; i
++,
1414 qcuOffset
+= 4, dcuOffset
+= 5) {
1424 if (!sc
->debug
.stats
.txstats
[i
].queued
)
1427 len
+= snprintf(buf
+ len
, size
- len
,
1428 "%4d %7d %2x %1x %2x %2x\n",
1430 (*qcuBase
& (0x7 << qcuOffset
)) >> qcuOffset
,
1431 (*qcuBase
& (0x8 << qcuOffset
)) >>
1433 ATH_SAMP_DBG(dma_dbg_reg_vals
[2]) &
1434 (0x7 << (i
* 3)) >> (i
* 3),
1435 (*dcuBase
& (0x1f << dcuOffset
)) >> dcuOffset
);
1437 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1439 len
+= snprintf(buf
+ len
, size
- len
,
1440 "samp qcu_sh qcu_fh qcu_comp dcu_comp dcu_arb dcu_fp "
1441 "ch_idle_dur ch_idle_dur_val txfifo_val0 txfifo_val1 "
1442 "txfifo_dcu0 txfifo_dcu1 pcu_obs AR_CR\n");
1444 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1445 qcuBase
= &ATH_SAMP_DBG(dma_dbg_reg_vals
[0]);
1446 dcuBase
= &ATH_SAMP_DBG(dma_dbg_reg_vals
[4]);
1448 len
+= snprintf(buf
+ len
, size
- len
, "%4d %5x %5x ", sampidx
,
1449 (ATH_SAMP_DBG(dma_dbg_reg_vals
[3]) & 0x003c0000) >> 18,
1450 (ATH_SAMP_DBG(dma_dbg_reg_vals
[3]) & 0x03c00000) >> 22);
1451 len
+= snprintf(buf
+ len
, size
- len
, "%7x %8x ",
1452 (ATH_SAMP_DBG(dma_dbg_reg_vals
[3]) & 0x1c000000) >> 26,
1453 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x3));
1454 len
+= snprintf(buf
+ len
, size
- len
, "%7x %7x ",
1455 (ATH_SAMP_DBG(dma_dbg_reg_vals
[5]) & 0x06000000) >> 25,
1456 (ATH_SAMP_DBG(dma_dbg_reg_vals
[5]) & 0x38000000) >> 27);
1457 len
+= snprintf(buf
+ len
, size
- len
, "%7d %12d ",
1458 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x000003fc) >> 2,
1459 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x00000400) >> 10);
1460 len
+= snprintf(buf
+ len
, size
- len
, "%12d %12d ",
1461 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x00000800) >> 11,
1462 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x00001000) >> 12);
1463 len
+= snprintf(buf
+ len
, size
- len
, "%12d %12d ",
1464 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x0001e000) >> 13,
1465 (ATH_SAMP_DBG(dma_dbg_reg_vals
[6]) & 0x001e0000) >> 17);
1466 len
+= snprintf(buf
+ len
, size
- len
, "0x%07x 0x%07x\n",
1467 ATH_SAMP_DBG(pcu_obs
), ATH_SAMP_DBG(pcu_cr
));
1470 len
+= snprintf(buf
+ len
, size
- len
,
1471 "Sample ChNoise Chain privNF #Reading Readings\n");
1472 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1473 h
= ATH_SAMP_DBG(nfCalHist
);
1474 if (!ATH_SAMP_DBG(noise
))
1477 for (i
= 0; i
< NUM_NF_READINGS
; i
++) {
1478 if (!(chainmask
& (1 << i
)) ||
1479 ((i
>= AR5416_MAX_CHAINS
) && !conf_is_ht40(conf
)))
1482 nread
= AR_PHY_CCA_FILTERWINDOW_LENGTH
-
1483 h
[i
].invalidNFcount
;
1484 len
+= snprintf(buf
+ len
, size
- len
,
1485 "%4d %5d %4d\t %d\t %d\t",
1486 sampidx
, ATH_SAMP_DBG(noise
),
1487 i
, h
[i
].privNF
, nread
);
1488 for (j
= 0; j
< nread
; j
++)
1489 len
+= snprintf(buf
+ len
, size
- len
,
1490 " %d", h
[i
].nfCalBuffer
[j
]);
1491 len
+= snprintf(buf
+ len
, size
- len
, "\n");
1494 len
+= snprintf(buf
+ len
, size
- len
, "\nCycle counters:\n"
1495 "Sample Total Rxbusy Rxframes Txframes\n");
1496 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1497 if (!ATH_SAMP_DBG(cc
.cycles
))
1499 len
+= snprintf(buf
+ len
, size
- len
,
1500 "%4d %08x %08x %08x %08x\n",
1501 sampidx
, ATH_SAMP_DBG(cc
.cycles
),
1502 ATH_SAMP_DBG(cc
.rx_busy
),
1503 ATH_SAMP_DBG(cc
.rx_frame
),
1504 ATH_SAMP_DBG(cc
.tx_frame
));
1507 len
+= snprintf(buf
+ len
, size
- len
, "Tx status Dump :\n");
1508 len
+= snprintf(buf
+ len
, size
- len
,
1509 "Sample rssi:- ctl0 ctl1 ctl2 ext0 ext1 ext2 comb "
1510 "isok rts_fail data_fail rate tid qid tx_before(ms)\n");
1511 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1512 for (i
= 0; i
< ATH_DBG_MAX_SAMPLES
; i
++) {
1513 if (!ATH_SAMP_DBG(ts
[i
].jiffies
))
1515 len
+= snprintf(buf
+ len
, size
- len
, "%4d \t"
1516 "%8d %4d %4d %4d %4d %4d %4d %4d %4d "
1517 "%4d %4d %2d %2d %d\n",
1519 ATH_SAMP_DBG(ts
[i
].rssi_ctl0
),
1520 ATH_SAMP_DBG(ts
[i
].rssi_ctl1
),
1521 ATH_SAMP_DBG(ts
[i
].rssi_ctl2
),
1522 ATH_SAMP_DBG(ts
[i
].rssi_ext0
),
1523 ATH_SAMP_DBG(ts
[i
].rssi_ext1
),
1524 ATH_SAMP_DBG(ts
[i
].rssi_ext2
),
1525 ATH_SAMP_DBG(ts
[i
].rssi
),
1526 ATH_SAMP_DBG(ts
[i
].isok
),
1527 ATH_SAMP_DBG(ts
[i
].rts_fail_cnt
),
1528 ATH_SAMP_DBG(ts
[i
].data_fail_cnt
),
1529 ATH_SAMP_DBG(ts
[i
].rateindex
),
1530 ATH_SAMP_DBG(ts
[i
].tid
),
1531 ATH_SAMP_DBG(ts
[i
].qid
),
1532 jiffies_to_msecs(jiffies
-
1533 ATH_SAMP_DBG(ts
[i
].jiffies
)));
1537 len
+= snprintf(buf
+ len
, size
- len
, "Rx status Dump :\n");
1538 len
+= snprintf(buf
+ len
, size
- len
, "Sample rssi:- ctl0 ctl1 ctl2 "
1539 "ext0 ext1 ext2 comb beacon ant rate rx_before(ms)\n");
1540 for (sampidx
= 0; sampidx
< ATH_DBG_MAX_SAMPLES
; sampidx
++) {
1541 for (i
= 0; i
< ATH_DBG_MAX_SAMPLES
; i
++) {
1542 if (!ATH_SAMP_DBG(rs
[i
].jiffies
))
1544 len
+= snprintf(buf
+ len
, size
- len
, "%4d \t"
1545 "%8d %4d %4d %4d %4d %4d %4d %s %4d %02x %d\n",
1547 ATH_SAMP_DBG(rs
[i
].rssi_ctl0
),
1548 ATH_SAMP_DBG(rs
[i
].rssi_ctl1
),
1549 ATH_SAMP_DBG(rs
[i
].rssi_ctl2
),
1550 ATH_SAMP_DBG(rs
[i
].rssi_ext0
),
1551 ATH_SAMP_DBG(rs
[i
].rssi_ext1
),
1552 ATH_SAMP_DBG(rs
[i
].rssi_ext2
),
1553 ATH_SAMP_DBG(rs
[i
].rssi
),
1554 ATH_SAMP_DBG(rs
[i
].is_mybeacon
) ?
1556 ATH_SAMP_DBG(rs
[i
].antenna
),
1557 ATH_SAMP_DBG(rs
[i
].rate
),
1558 jiffies_to_msecs(jiffies
-
1559 ATH_SAMP_DBG(rs
[i
].jiffies
)));
1564 file
->private_data
= buf
;
1570 static const struct file_operations fops_samps
= {
1571 .open
= open_file_bb_mac_samps
,
1572 .read
= ath9k_debugfs_read_buf
,
1573 .release
= ath9k_debugfs_release_buf
,
1574 .owner
= THIS_MODULE
,
1575 .llseek
= default_llseek
,
1579 int ath9k_init_debug(struct ath_hw
*ah
)
1581 struct ath_common
*common
= ath9k_hw_common(ah
);
1582 struct ath_softc
*sc
= (struct ath_softc
*) common
->priv
;
1584 sc
->debug
.debugfs_phy
= debugfs_create_dir("ath9k",
1585 sc
->hw
->wiphy
->debugfsdir
);
1586 if (!sc
->debug
.debugfs_phy
)
1589 #ifdef CONFIG_ATH_DEBUG
1590 debugfs_create_file("debug", S_IRUSR
| S_IWUSR
, sc
->debug
.debugfs_phy
,
1593 debugfs_create_file("dma", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1595 debugfs_create_file("interrupt", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1597 debugfs_create_file("wiphy", S_IRUSR
| S_IWUSR
, sc
->debug
.debugfs_phy
,
1599 debugfs_create_file("xmit", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1601 debugfs_create_file("stations", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1603 debugfs_create_file("misc", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1605 debugfs_create_file("recv", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1607 debugfs_create_file("rx_chainmask", S_IRUSR
| S_IWUSR
,
1608 sc
->debug
.debugfs_phy
, sc
, &fops_rx_chainmask
);
1609 debugfs_create_file("tx_chainmask", S_IRUSR
| S_IWUSR
,
1610 sc
->debug
.debugfs_phy
, sc
, &fops_tx_chainmask
);
1611 debugfs_create_file("disable_ani", S_IRUSR
| S_IWUSR
,
1612 sc
->debug
.debugfs_phy
, sc
, &fops_disable_ani
);
1613 debugfs_create_file("regidx", S_IRUSR
| S_IWUSR
, sc
->debug
.debugfs_phy
,
1615 debugfs_create_file("regval", S_IRUSR
| S_IWUSR
, sc
->debug
.debugfs_phy
,
1617 debugfs_create_bool("ignore_extcca", S_IRUSR
| S_IWUSR
,
1618 sc
->debug
.debugfs_phy
,
1619 &ah
->config
.cwm_ignore_extcca
);
1620 debugfs_create_file("regdump", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1622 debugfs_create_file("dump_nfcal", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1624 debugfs_create_file("base_eeprom", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1626 debugfs_create_file("modal_eeprom", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1627 &fops_modal_eeprom
);
1628 debugfs_create_file("samples", S_IRUSR
, sc
->debug
.debugfs_phy
, sc
,
1631 debugfs_create_u32("gpio_mask", S_IRUSR
| S_IWUSR
,
1632 sc
->debug
.debugfs_phy
, &sc
->sc_ah
->gpio_mask
);
1634 debugfs_create_u32("gpio_val", S_IRUSR
| S_IWUSR
,
1635 sc
->debug
.debugfs_phy
, &sc
->sc_ah
->gpio_val
);
1637 sc
->debug
.regidx
= 0;
1638 memset(&sc
->debug
.bb_mac_samp
, 0, sizeof(sc
->debug
.bb_mac_samp
));
1639 sc
->debug
.sampidx
= 0;
1640 sc
->debug
.tsidx
= 0;
1641 sc
->debug
.rsidx
= 0;