]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/net/wireless/b43/debugfs.c
3 Broadcom B43 wireless driver
5 debugfs driver debugging code
7 Copyright (c) 2005-2007 Michael Buesch <mb@bu3sch.de>
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.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
22 Boston, MA 02110-1301, USA.
27 #include <linux/debugfs.h>
28 #include <linux/slab.h>
29 #include <linux/netdevice.h>
30 #include <linux/pci.h>
31 #include <linux/mutex.h>
40 /* The root directory. */
41 static struct dentry
*rootdir
;
43 struct b43_debugfs_fops
{
44 ssize_t (*read
)(struct b43_wldev
*dev
, char *buf
, size_t bufsize
);
45 int (*write
)(struct b43_wldev
*dev
, const char *buf
, size_t count
);
46 struct file_operations fops
;
47 /* Offset of struct b43_dfs_file in struct b43_dfsentry */
48 size_t file_struct_offset
;
49 /* Take wl->irq_lock before calling read/write? */
54 struct b43_dfs_file
* fops_to_dfs_file(struct b43_wldev
*dev
,
55 const struct b43_debugfs_fops
*dfops
)
60 p
+= dfops
->file_struct_offset
;
66 #define fappend(fmt, x...) \
68 if (bufsize - count) \
69 count += snprintf(buf + count, \
73 printk(KERN_ERR "b43: fappend overflow\n"); \
77 /* The biggest address values for SHM access from the debugfs files. */
78 #define B43_MAX_SHM_ROUTING 4
79 #define B43_MAX_SHM_ADDR 0xFFFF
81 static ssize_t
shm16read__read_file(struct b43_wldev
*dev
,
82 char *buf
, size_t bufsize
)
85 unsigned int routing
, addr
;
88 routing
= dev
->dfsentry
->shm16read_routing_next
;
89 addr
= dev
->dfsentry
->shm16read_addr_next
;
90 if ((routing
> B43_MAX_SHM_ROUTING
) ||
91 (addr
> B43_MAX_SHM_ADDR
))
94 val
= b43_shm_read16(dev
, routing
, addr
);
95 fappend("0x%04X\n", val
);
100 static int shm16read__write_file(struct b43_wldev
*dev
,
101 const char *buf
, size_t count
)
103 unsigned int routing
, addr
;
106 res
= sscanf(buf
, "0x%X 0x%X", &routing
, &addr
);
109 if (routing
> B43_MAX_SHM_ROUTING
)
110 return -EADDRNOTAVAIL
;
111 if (addr
> B43_MAX_SHM_ADDR
)
112 return -EADDRNOTAVAIL
;
113 if (routing
== B43_SHM_SHARED
) {
115 return -EADDRNOTAVAIL
;
118 dev
->dfsentry
->shm16read_routing_next
= routing
;
119 dev
->dfsentry
->shm16read_addr_next
= addr
;
124 static int shm16write__write_file(struct b43_wldev
*dev
,
125 const char *buf
, size_t count
)
127 unsigned int routing
, addr
, mask
, set
;
132 res
= sscanf(buf
, "0x%X 0x%X 0x%X 0x%X",
133 &routing
, &addr
, &mask
, &set
);
136 if (routing
> B43_MAX_SHM_ROUTING
)
137 return -EADDRNOTAVAIL
;
138 if (addr
> B43_MAX_SHM_ADDR
)
139 return -EADDRNOTAVAIL
;
140 if (routing
== B43_SHM_SHARED
) {
142 return -EADDRNOTAVAIL
;
144 if ((mask
> 0xFFFF) || (set
> 0xFFFF))
147 spin_lock_irqsave(&dev
->wl
->shm_lock
, flags
);
151 val
= __b43_shm_read16(dev
, routing
, addr
);
154 __b43_shm_write16(dev
, routing
, addr
, val
);
155 spin_unlock_irqrestore(&dev
->wl
->shm_lock
, flags
);
160 static ssize_t
shm32read__read_file(struct b43_wldev
*dev
,
161 char *buf
, size_t bufsize
)
164 unsigned int routing
, addr
;
167 routing
= dev
->dfsentry
->shm32read_routing_next
;
168 addr
= dev
->dfsentry
->shm32read_addr_next
;
169 if ((routing
> B43_MAX_SHM_ROUTING
) ||
170 (addr
> B43_MAX_SHM_ADDR
))
171 return -EDESTADDRREQ
;
173 val
= b43_shm_read32(dev
, routing
, addr
);
174 fappend("0x%08X\n", val
);
179 static int shm32read__write_file(struct b43_wldev
*dev
,
180 const char *buf
, size_t count
)
182 unsigned int routing
, addr
;
185 res
= sscanf(buf
, "0x%X 0x%X", &routing
, &addr
);
188 if (routing
> B43_MAX_SHM_ROUTING
)
189 return -EADDRNOTAVAIL
;
190 if (addr
> B43_MAX_SHM_ADDR
)
191 return -EADDRNOTAVAIL
;
192 if (routing
== B43_SHM_SHARED
) {
194 return -EADDRNOTAVAIL
;
197 dev
->dfsentry
->shm32read_routing_next
= routing
;
198 dev
->dfsentry
->shm32read_addr_next
= addr
;
203 static int shm32write__write_file(struct b43_wldev
*dev
,
204 const char *buf
, size_t count
)
206 unsigned int routing
, addr
, mask
, set
;
211 res
= sscanf(buf
, "0x%X 0x%X 0x%X 0x%X",
212 &routing
, &addr
, &mask
, &set
);
215 if (routing
> B43_MAX_SHM_ROUTING
)
216 return -EADDRNOTAVAIL
;
217 if (addr
> B43_MAX_SHM_ADDR
)
218 return -EADDRNOTAVAIL
;
219 if (routing
== B43_SHM_SHARED
) {
221 return -EADDRNOTAVAIL
;
223 if ((mask
> 0xFFFFFFFF) || (set
> 0xFFFFFFFF))
226 spin_lock_irqsave(&dev
->wl
->shm_lock
, flags
);
230 val
= __b43_shm_read32(dev
, routing
, addr
);
233 __b43_shm_write32(dev
, routing
, addr
, val
);
234 spin_unlock_irqrestore(&dev
->wl
->shm_lock
, flags
);
239 /* The biggest MMIO address that we allow access to from the debugfs files. */
240 #define B43_MAX_MMIO_ACCESS (0xF00 - 1)
242 static ssize_t
mmio16read__read_file(struct b43_wldev
*dev
,
243 char *buf
, size_t bufsize
)
249 addr
= dev
->dfsentry
->mmio16read_next
;
250 if (addr
> B43_MAX_MMIO_ACCESS
)
251 return -EDESTADDRREQ
;
253 val
= b43_read16(dev
, addr
);
254 fappend("0x%04X\n", val
);
259 static int mmio16read__write_file(struct b43_wldev
*dev
,
260 const char *buf
, size_t count
)
265 res
= sscanf(buf
, "0x%X", &addr
);
268 if (addr
> B43_MAX_MMIO_ACCESS
)
269 return -EADDRNOTAVAIL
;
273 dev
->dfsentry
->mmio16read_next
= addr
;
278 static int mmio16write__write_file(struct b43_wldev
*dev
,
279 const char *buf
, size_t count
)
281 unsigned int addr
, mask
, set
;
285 res
= sscanf(buf
, "0x%X 0x%X 0x%X", &addr
, &mask
, &set
);
288 if (addr
> B43_MAX_MMIO_ACCESS
)
289 return -EADDRNOTAVAIL
;
290 if ((mask
> 0xFFFF) || (set
> 0xFFFF))
298 val
= b43_read16(dev
, addr
);
301 b43_write16(dev
, addr
, val
);
306 static ssize_t
mmio32read__read_file(struct b43_wldev
*dev
,
307 char *buf
, size_t bufsize
)
313 addr
= dev
->dfsentry
->mmio32read_next
;
314 if (addr
> B43_MAX_MMIO_ACCESS
)
315 return -EDESTADDRREQ
;
317 val
= b43_read32(dev
, addr
);
318 fappend("0x%08X\n", val
);
323 static int mmio32read__write_file(struct b43_wldev
*dev
,
324 const char *buf
, size_t count
)
329 res
= sscanf(buf
, "0x%X", &addr
);
332 if (addr
> B43_MAX_MMIO_ACCESS
)
333 return -EADDRNOTAVAIL
;
337 dev
->dfsentry
->mmio32read_next
= addr
;
342 static int mmio32write__write_file(struct b43_wldev
*dev
,
343 const char *buf
, size_t count
)
345 unsigned int addr
, mask
, set
;
349 res
= sscanf(buf
, "0x%X 0x%X 0x%X", &addr
, &mask
, &set
);
352 if (addr
> B43_MAX_MMIO_ACCESS
)
353 return -EADDRNOTAVAIL
;
354 if ((mask
> 0xFFFFFFFF) || (set
> 0xFFFFFFFF))
362 val
= b43_read32(dev
, addr
);
365 b43_write32(dev
, addr
, val
);
370 /* wl->irq_lock is locked */
371 static ssize_t
tsf_read_file(struct b43_wldev
*dev
,
372 char *buf
, size_t bufsize
)
377 b43_tsf_read(dev
, &tsf
);
378 fappend("0x%08x%08x\n",
379 (unsigned int)((tsf
& 0xFFFFFFFF00000000ULL
) >> 32),
380 (unsigned int)(tsf
& 0xFFFFFFFFULL
));
385 /* wl->irq_lock is locked */
386 static int tsf_write_file(struct b43_wldev
*dev
,
387 const char *buf
, size_t count
)
391 if (sscanf(buf
, "%llu", (unsigned long long *)(&tsf
)) != 1)
393 b43_tsf_write(dev
, tsf
);
398 static ssize_t
txstat_read_file(struct b43_wldev
*dev
,
399 char *buf
, size_t bufsize
)
401 struct b43_txstatus_log
*log
= &dev
->dfsentry
->txstatlog
;
405 struct b43_txstatus
*stat
;
407 spin_lock_irqsave(&log
->lock
, flags
);
409 fappend("Nothing transmitted, yet\n");
412 fappend("b43 TX status reports:\n\n"
413 "index | cookie | seq | phy_stat | frame_count | "
414 "rts_count | supp_reason | pm_indicated | "
415 "intermediate | for_ampdu | acked\n" "---\n");
419 if (i
== B43_NR_LOGGED_TXSTATUS
)
421 stat
= &(log
->log
[i
]);
424 "0x%04X | 0x%04X | 0x%02X | "
429 stat
->cookie
, stat
->seq
, stat
->phy_stat
,
430 stat
->frame_count
, stat
->rts_count
,
431 stat
->supp_reason
, stat
->pm_indicated
,
432 stat
->intermediate
, stat
->for_ampdu
,
441 spin_unlock_irqrestore(&log
->lock
, flags
);
446 static ssize_t
txpower_g_read_file(struct b43_wldev
*dev
,
447 char *buf
, size_t bufsize
)
451 if (dev
->phy
.type
!= B43_PHYTYPE_G
) {
452 fappend("Device is not a G-PHY\n");
455 fappend("Control: %s\n", dev
->phy
.manual_txpower_control
?
456 "MANUAL" : "AUTOMATIC");
457 fappend("Baseband attenuation: %u\n", dev
->phy
.bbatt
.att
);
458 fappend("Radio attenuation: %u\n", dev
->phy
.rfatt
.att
);
459 fappend("TX Mixer Gain: %s\n",
460 (dev
->phy
.tx_control
& B43_TXCTL_TXMIX
) ? "ON" : "OFF");
461 fappend("PA Gain 2dB: %s\n",
462 (dev
->phy
.tx_control
& B43_TXCTL_PA2DB
) ? "ON" : "OFF");
463 fappend("PA Gain 3dB: %s\n",
464 (dev
->phy
.tx_control
& B43_TXCTL_PA3DB
) ? "ON" : "OFF");
466 fappend("You can write to this file:\n");
467 fappend("Writing \"auto\" enables automatic txpower control.\n");
469 ("Writing the attenuation values as \"bbatt rfatt txmix pa2db pa3db\" "
470 "enables manual txpower control.\n");
471 fappend("Example: 5 4 0 0 1\n");
472 fappend("Enables manual control with Baseband attenuation 5, "
473 "Radio attenuation 4, No TX Mixer Gain, "
474 "No PA Gain 2dB, With PA Gain 3dB.\n");
479 static int txpower_g_write_file(struct b43_wldev
*dev
,
480 const char *buf
, size_t count
)
482 if (dev
->phy
.type
!= B43_PHYTYPE_G
)
484 if ((count
>= 4) && (memcmp(buf
, "auto", 4) == 0)) {
485 /* Automatic control */
486 dev
->phy
.manual_txpower_control
= 0;
487 b43_phy_xmitpower(dev
);
489 int bbatt
= 0, rfatt
= 0, txmix
= 0, pa2db
= 0, pa3db
= 0;
491 if (sscanf(buf
, "%d %d %d %d %d", &bbatt
, &rfatt
,
492 &txmix
, &pa2db
, &pa3db
) != 5)
494 b43_put_attenuation_into_ranges(dev
, &bbatt
, &rfatt
);
495 dev
->phy
.manual_txpower_control
= 1;
496 dev
->phy
.bbatt
.att
= bbatt
;
497 dev
->phy
.rfatt
.att
= rfatt
;
498 dev
->phy
.tx_control
= 0;
500 dev
->phy
.tx_control
|= B43_TXCTL_TXMIX
;
502 dev
->phy
.tx_control
|= B43_TXCTL_PA2DB
;
504 dev
->phy
.tx_control
|= B43_TXCTL_PA3DB
;
507 b43_set_txpower_g(dev
, &dev
->phy
.bbatt
,
508 &dev
->phy
.rfatt
, dev
->phy
.tx_control
);
509 b43_radio_unlock(dev
);
516 /* wl->irq_lock is locked */
517 static int restart_write_file(struct b43_wldev
*dev
,
518 const char *buf
, size_t count
)
522 if (count
> 0 && buf
[0] == '1') {
523 b43_controller_restart(dev
, "manually restarted");
530 static unsigned long calc_expire_secs(unsigned long now
,
532 unsigned long expire
)
534 expire
= time
+ expire
;
536 if (time_after(now
, expire
))
537 return 0; /* expired */
539 /* jiffies wrapped */
540 expire
-= MAX_JIFFY_OFFSET
;
541 now
-= MAX_JIFFY_OFFSET
;
543 B43_WARN_ON(expire
< now
);
545 return (expire
- now
) / HZ
;
548 static ssize_t
loctls_read_file(struct b43_wldev
*dev
,
549 char *buf
, size_t bufsize
)
552 struct b43_txpower_lo_control
*lo
;
554 struct b43_lo_calib
*cal
;
555 unsigned long now
= jiffies
;
556 struct b43_phy
*phy
= &dev
->phy
;
558 if (phy
->type
!= B43_PHYTYPE_G
) {
559 fappend("Device is not a G-PHY\n");
563 lo
= phy
->lo_control
;
564 fappend("-- Local Oscillator calibration data --\n\n");
565 fappend("HW-power-control enabled: %d\n",
566 dev
->phy
.hardware_power_control
);
567 fappend("TX Bias: 0x%02X, TX Magn: 0x%02X (expire in %lu sec)\n",
568 lo
->tx_bias
, lo
->tx_magn
,
569 calc_expire_secs(now
, lo
->txctl_measured_time
,
570 B43_LO_TXCTL_EXPIRE
));
571 fappend("Power Vector: 0x%08X%08X (expires in %lu sec)\n",
572 (unsigned int)((lo
->power_vector
& 0xFFFFFFFF00000000ULL
) >> 32),
573 (unsigned int)(lo
->power_vector
& 0x00000000FFFFFFFFULL
),
574 calc_expire_secs(now
, lo
->pwr_vec_read_time
,
575 B43_LO_PWRVEC_EXPIRE
));
577 fappend("\nCalibrated settings:\n");
578 list_for_each_entry(cal
, &lo
->calib_list
, list
) {
581 active
= (b43_compare_bbatt(&cal
->bbatt
, &phy
->bbatt
) &&
582 b43_compare_rfatt(&cal
->rfatt
, &phy
->rfatt
));
583 fappend("BB(%d), RF(%d,%d) -> I=%d, Q=%d "
584 "(expires in %lu sec)%s\n",
586 cal
->rfatt
.att
, cal
->rfatt
.with_padmix
,
587 cal
->ctl
.i
, cal
->ctl
.q
,
588 calc_expire_secs(now
, cal
->calib_time
,
589 B43_LO_CALIB_EXPIRE
),
590 active
? " ACTIVE" : "");
593 fappend("\nUsed RF attenuation values: Value(WithPadmix flag)\n");
594 for (i
= 0; i
< lo
->rfatt_list
.len
; i
++) {
596 lo
->rfatt_list
.list
[i
].att
,
597 lo
->rfatt_list
.list
[i
].with_padmix
);
600 fappend("\nUsed Baseband attenuation values:\n");
601 for (i
= 0; i
< lo
->bbatt_list
.len
; i
++) {
603 lo
->bbatt_list
.list
[i
].att
);
608 return err
? err
: count
;
613 static int b43_debugfs_open(struct inode
*inode
, struct file
*file
)
615 file
->private_data
= inode
->i_private
;
619 static ssize_t
b43_debugfs_read(struct file
*file
, char __user
*userbuf
,
620 size_t count
, loff_t
*ppos
)
622 struct b43_wldev
*dev
;
623 struct b43_debugfs_fops
*dfops
;
624 struct b43_dfs_file
*dfile
;
625 ssize_t
uninitialized_var(ret
);
627 const size_t bufsize
= 1024 * 16; /* 16 kiB buffer */
628 const size_t buforder
= get_order(bufsize
);
633 dev
= file
->private_data
;
637 mutex_lock(&dev
->wl
->mutex
);
638 if (b43_status(dev
) < B43_STAT_INITIALIZED
) {
643 dfops
= container_of(file
->f_op
, struct b43_debugfs_fops
, fops
);
648 dfile
= fops_to_dfs_file(dev
, dfops
);
650 if (!dfile
->buffer
) {
651 buf
= (char *)__get_free_pages(GFP_KERNEL
, buforder
);
656 memset(buf
, 0, bufsize
);
657 if (dfops
->take_irqlock
) {
658 spin_lock_irq(&dev
->wl
->irq_lock
);
659 ret
= dfops
->read(dev
, buf
, bufsize
);
660 spin_unlock_irq(&dev
->wl
->irq_lock
);
662 ret
= dfops
->read(dev
, buf
, bufsize
);
664 free_pages((unsigned long)buf
, buforder
);
668 dfile
->data_len
= ret
;
672 ret
= simple_read_from_buffer(userbuf
, count
, ppos
,
675 if (*ppos
>= dfile
->data_len
) {
676 free_pages((unsigned long)dfile
->buffer
, buforder
);
677 dfile
->buffer
= NULL
;
681 mutex_unlock(&dev
->wl
->mutex
);
683 return err
? err
: ret
;
686 static ssize_t
b43_debugfs_write(struct file
*file
,
687 const char __user
*userbuf
,
688 size_t count
, loff_t
*ppos
)
690 struct b43_wldev
*dev
;
691 struct b43_debugfs_fops
*dfops
;
697 if (count
> PAGE_SIZE
)
699 dev
= file
->private_data
;
703 mutex_lock(&dev
->wl
->mutex
);
704 if (b43_status(dev
) < B43_STAT_INITIALIZED
) {
709 dfops
= container_of(file
->f_op
, struct b43_debugfs_fops
, fops
);
715 buf
= (char *)get_zeroed_page(GFP_KERNEL
);
720 if (copy_from_user(buf
, userbuf
, count
)) {
724 if (dfops
->take_irqlock
) {
725 spin_lock_irq(&dev
->wl
->irq_lock
);
726 err
= dfops
->write(dev
, buf
, count
);
727 spin_unlock_irq(&dev
->wl
->irq_lock
);
729 err
= dfops
->write(dev
, buf
, count
);
734 free_page((unsigned long)buf
);
736 mutex_unlock(&dev
->wl
->mutex
);
738 return err
? err
: count
;
742 #define B43_DEBUGFS_FOPS(name, _read, _write, _take_irqlock) \
743 static struct b43_debugfs_fops fops_##name = { \
747 .open = b43_debugfs_open, \
748 .read = b43_debugfs_read, \
749 .write = b43_debugfs_write, \
751 .file_struct_offset = offsetof(struct b43_dfsentry, \
753 .take_irqlock = _take_irqlock, \
756 B43_DEBUGFS_FOPS(shm16read
, shm16read__read_file
, shm16read__write_file
, 1);
757 B43_DEBUGFS_FOPS(shm16write
, NULL
, shm16write__write_file
, 1);
758 B43_DEBUGFS_FOPS(shm32read
, shm32read__read_file
, shm32read__write_file
, 1);
759 B43_DEBUGFS_FOPS(shm32write
, NULL
, shm32write__write_file
, 1);
760 B43_DEBUGFS_FOPS(mmio16read
, mmio16read__read_file
, mmio16read__write_file
, 1);
761 B43_DEBUGFS_FOPS(mmio16write
, NULL
, mmio16write__write_file
, 1);
762 B43_DEBUGFS_FOPS(mmio32read
, mmio32read__read_file
, mmio32read__write_file
, 1);
763 B43_DEBUGFS_FOPS(mmio32write
, NULL
, mmio32write__write_file
, 1);
764 B43_DEBUGFS_FOPS(tsf
, tsf_read_file
, tsf_write_file
, 1);
765 B43_DEBUGFS_FOPS(txstat
, txstat_read_file
, NULL
, 0);
766 B43_DEBUGFS_FOPS(txpower_g
, txpower_g_read_file
, txpower_g_write_file
, 0);
767 B43_DEBUGFS_FOPS(restart
, NULL
, restart_write_file
, 1);
768 B43_DEBUGFS_FOPS(loctls
, loctls_read_file
, NULL
, 0);
771 int b43_debug(struct b43_wldev
*dev
, enum b43_dyndbg feature
)
773 return !!(dev
->dfsentry
&& dev
->dfsentry
->dyn_debug
[feature
]);
776 static void b43_remove_dynamic_debug(struct b43_wldev
*dev
)
778 struct b43_dfsentry
*e
= dev
->dfsentry
;
781 for (i
= 0; i
< __B43_NR_DYNDBG
; i
++)
782 debugfs_remove(e
->dyn_debug_dentries
[i
]);
785 static void b43_add_dynamic_debug(struct b43_wldev
*dev
)
787 struct b43_dfsentry
*e
= dev
->dfsentry
;
790 #define add_dyn_dbg(name, id, initstate) do { \
791 e->dyn_debug[id] = (initstate); \
792 d = debugfs_create_bool(name, 0600, e->subdir, \
793 &(e->dyn_debug[id])); \
795 e->dyn_debug_dentries[id] = d; \
798 add_dyn_dbg("debug_xmitpower", B43_DBG_XMITPOWER
, 0);
799 add_dyn_dbg("debug_dmaoverflow", B43_DBG_DMAOVERFLOW
, 0);
800 add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE
, 0);
801 add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST
, 0);
802 add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP
, 0);
803 add_dyn_dbg("debug_lo", B43_DBG_LO
, 0);
808 void b43_debugfs_add_device(struct b43_wldev
*dev
)
810 struct b43_dfsentry
*e
;
811 struct b43_txstatus_log
*log
;
815 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
817 b43err(dev
->wl
, "debugfs: add device OOM\n");
822 log
->log
= kcalloc(B43_NR_LOGGED_TXSTATUS
,
823 sizeof(struct b43_txstatus
), GFP_KERNEL
);
825 b43err(dev
->wl
, "debugfs: add device txstatus OOM\n");
830 spin_lock_init(&log
->lock
);
834 snprintf(devdir
, sizeof(devdir
), "%s", wiphy_name(dev
->wl
->hw
->wiphy
));
835 e
->subdir
= debugfs_create_dir(devdir
, rootdir
);
836 if (!e
->subdir
|| IS_ERR(e
->subdir
)) {
837 if (e
->subdir
== ERR_PTR(-ENODEV
)) {
838 b43dbg(dev
->wl
, "DebugFS (CONFIG_DEBUG_FS) not "
839 "enabled in kernel config\n");
841 b43err(dev
->wl
, "debugfs: cannot create %s directory\n",
844 dev
->dfsentry
= NULL
;
850 e
->mmio16read_next
= 0xFFFF; /* invalid address */
851 e
->mmio32read_next
= 0xFFFF; /* invalid address */
852 e
->shm16read_routing_next
= 0xFFFFFFFF; /* invalid routing */
853 e
->shm16read_addr_next
= 0xFFFFFFFF; /* invalid address */
854 e
->shm32read_routing_next
= 0xFFFFFFFF; /* invalid routing */
855 e
->shm32read_addr_next
= 0xFFFFFFFF; /* invalid address */
857 #define ADD_FILE(name, mode) \
860 d = debugfs_create_file(__stringify(name), \
861 mode, e->subdir, dev, \
862 &fops_##name.fops); \
863 e->file_##name.dentry = NULL; \
865 e->file_##name.dentry = d; \
869 ADD_FILE(shm16read
, 0600);
870 ADD_FILE(shm16write
, 0200);
871 ADD_FILE(shm32read
, 0600);
872 ADD_FILE(shm32write
, 0200);
873 ADD_FILE(mmio16read
, 0600);
874 ADD_FILE(mmio16write
, 0200);
875 ADD_FILE(mmio32read
, 0600);
876 ADD_FILE(mmio32write
, 0200);
878 ADD_FILE(txstat
, 0400);
879 ADD_FILE(txpower_g
, 0600);
880 ADD_FILE(restart
, 0200);
881 ADD_FILE(loctls
, 0400);
885 b43_add_dynamic_debug(dev
);
888 void b43_debugfs_remove_device(struct b43_wldev
*dev
)
890 struct b43_dfsentry
*e
;
897 b43_remove_dynamic_debug(dev
);
899 debugfs_remove(e
->file_shm16read
.dentry
);
900 debugfs_remove(e
->file_shm16write
.dentry
);
901 debugfs_remove(e
->file_shm32read
.dentry
);
902 debugfs_remove(e
->file_shm32write
.dentry
);
903 debugfs_remove(e
->file_mmio16read
.dentry
);
904 debugfs_remove(e
->file_mmio16write
.dentry
);
905 debugfs_remove(e
->file_mmio32read
.dentry
);
906 debugfs_remove(e
->file_mmio32write
.dentry
);
907 debugfs_remove(e
->file_tsf
.dentry
);
908 debugfs_remove(e
->file_txstat
.dentry
);
909 debugfs_remove(e
->file_txpower_g
.dentry
);
910 debugfs_remove(e
->file_restart
.dentry
);
911 debugfs_remove(e
->file_loctls
.dentry
);
913 debugfs_remove(e
->subdir
);
914 kfree(e
->txstatlog
.log
);
918 /* Called with IRQs disabled. */
919 void b43_debugfs_log_txstat(struct b43_wldev
*dev
,
920 const struct b43_txstatus
*status
)
922 struct b43_dfsentry
*e
= dev
->dfsentry
;
923 struct b43_txstatus_log
*log
;
924 struct b43_txstatus
*cur
;
930 spin_lock(&log
->lock
); /* IRQs are already disabled. */
932 if (i
== B43_NR_LOGGED_TXSTATUS
)
935 cur
= &(log
->log
[i
]);
936 memcpy(cur
, status
, sizeof(*cur
));
937 spin_unlock(&log
->lock
);
940 void b43_debugfs_init(void)
942 rootdir
= debugfs_create_dir(KBUILD_MODNAME
, NULL
);
947 void b43_debugfs_exit(void)
949 debugfs_remove(rootdir
);