3 Broadcom BCM43xx wireless driver
5 debugfs driver debugging code
7 Copyright (c) 2005 Michael Buesch <mbuesch@freenet.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.
29 #include <linux/debugfs.h>
30 #include <linux/slab.h>
31 #include <linux/netdevice.h>
32 #include <linux/pci.h>
36 #include "bcm43xx_main.h"
37 #include "bcm43xx_debugfs.h"
38 #include "bcm43xx_dma.h"
39 #include "bcm43xx_pio.h"
40 #include "bcm43xx_xmit.h"
42 #define REALLY_BIG_BUFFER_SIZE (1024*256)
44 static struct bcm43xx_debugfs fs
;
45 static char really_big_buffer
[REALLY_BIG_BUFFER_SIZE
];
46 static DECLARE_MUTEX(big_buffer_sem
);
49 static ssize_t
write_file_dummy(struct file
*file
, const char __user
*buf
,
50 size_t count
, loff_t
*ppos
)
55 static int open_file_generic(struct inode
*inode
, struct file
*file
)
57 file
->private_data
= inode
->u
.generic_ip
;
61 #define fappend(fmt, x...) pos += snprintf(buf + pos, len - pos, fmt , ##x)
63 static ssize_t
devinfo_read_file(struct file
*file
, char __user
*userbuf
,
64 size_t count
, loff_t
*ppos
)
66 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
68 struct bcm43xx_private
*bcm
= file
->private_data
;
69 char *buf
= really_big_buffer
;
72 struct net_device
*net_dev
;
73 struct pci_dev
*pci_dev
;
78 down(&big_buffer_sem
);
80 mutex_lock(&bcm
->mutex
);
81 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
82 if (bcm43xx_status(bcm
) != BCM43xx_STAT_INITIALIZED
) {
83 fappend("Board not initialized.\n");
86 net_dev
= bcm
->net_dev
;
87 pci_dev
= bcm
->pci_dev
;
89 /* This is where the information is written to the "devinfo" file */
90 fappend("*** %s devinfo ***\n", net_dev
->name
);
91 fappend("vendor: 0x%04x device: 0x%04x\n",
92 pci_dev
->vendor
, pci_dev
->device
);
93 fappend("subsystem_vendor: 0x%04x subsystem_device: 0x%04x\n",
94 pci_dev
->subsystem_vendor
, pci_dev
->subsystem_device
);
95 fappend("IRQ: %d\n", bcm
->irq
);
96 fappend("mmio_addr: 0x%p\n", bcm
->mmio_addr
);
97 fappend("chip_id: 0x%04x chip_rev: 0x%02x\n", bcm
->chip_id
, bcm
->chip_rev
);
98 if ((bcm
->core_80211
[0].rev
>= 3) && (bcm43xx_read32(bcm
, 0x0158) & (1 << 16)))
99 fappend("Radio disabled by hardware!\n");
100 if ((bcm
->core_80211
[0].rev
< 3) && !(bcm43xx_read16(bcm
, 0x049A) & (1 << 4)))
101 fappend("Radio disabled by hardware!\n");
102 fappend("board_vendor: 0x%04x board_type: 0x%04x\n", bcm
->board_vendor
,
105 fappend("\nCores:\n");
106 #define fappend_core(name, info) fappend("core \"" name "\" %s, %s, id: 0x%04x, " \
107 "rev: 0x%02x, index: 0x%02x\n", \
109 ? "available" : "nonavailable", \
111 ? "enabled" : "disabled", \
112 (info).id, (info).rev, (info).index)
113 fappend_core("CHIPCOMMON", bcm
->core_chipcommon
);
114 fappend_core("PCI", bcm
->core_pci
);
115 fappend_core("first 80211", bcm
->core_80211
[0]);
116 fappend_core("second 80211", bcm
->core_80211
[1]);
118 tmp16
= bcm43xx_read16(bcm
, BCM43xx_MMIO_GPIO_CONTROL
);
120 for (i
= 0; i
< BCM43xx_NR_LEDS
; i
++)
121 fappend("%d ", !!(tmp16
& (1 << i
)));
125 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
126 mutex_unlock(&bcm
->mutex
);
127 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
132 static ssize_t
drvinfo_read_file(struct file
*file
, char __user
*userbuf
,
133 size_t count
, loff_t
*ppos
)
135 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
137 char *buf
= really_big_buffer
;
141 down(&big_buffer_sem
);
143 /* This is where the information is written to the "driver" file */
144 fappend(KBUILD_MODNAME
" driver\n");
145 fappend("Compiled at: %s %s\n", __DATE__
, __TIME__
);
147 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
152 static ssize_t
spromdump_read_file(struct file
*file
, char __user
*userbuf
,
153 size_t count
, loff_t
*ppos
)
155 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
157 struct bcm43xx_private
*bcm
= file
->private_data
;
158 char *buf
= really_big_buffer
;
163 down(&big_buffer_sem
);
164 mutex_lock(&bcm
->mutex
);
165 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
166 if (bcm43xx_status(bcm
) != BCM43xx_STAT_INITIALIZED
) {
167 fappend("Board not initialized.\n");
171 /* This is where the information is written to the "sprom_dump" file */
172 fappend("boardflags: 0x%04x\n", bcm
->sprom
.boardflags
);
175 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
176 mutex_unlock(&bcm
->mutex
);
177 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
182 static ssize_t
tsf_read_file(struct file
*file
, char __user
*userbuf
,
183 size_t count
, loff_t
*ppos
)
185 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
187 struct bcm43xx_private
*bcm
= file
->private_data
;
188 char *buf
= really_big_buffer
;
194 down(&big_buffer_sem
);
195 mutex_lock(&bcm
->mutex
);
196 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
197 if (bcm43xx_status(bcm
) != BCM43xx_STAT_INITIALIZED
) {
198 fappend("Board not initialized.\n");
201 bcm43xx_tsf_read(bcm
, &tsf
);
202 fappend("0x%08x%08x\n",
203 (unsigned int)((tsf
& 0xFFFFFFFF00000000ULL
) >> 32),
204 (unsigned int)(tsf
& 0xFFFFFFFFULL
));
207 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
208 mutex_unlock(&bcm
->mutex
);
209 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
214 static ssize_t
tsf_write_file(struct file
*file
, const char __user
*user_buf
,
215 size_t count
, loff_t
*ppos
)
217 struct bcm43xx_private
*bcm
= file
->private_data
;
218 char *buf
= really_big_buffer
;
224 buf_size
= min(count
, sizeof (really_big_buffer
) - 1);
225 down(&big_buffer_sem
);
226 if (copy_from_user(buf
, user_buf
, buf_size
)) {
230 mutex_lock(&bcm
->mutex
);
231 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
232 if (bcm43xx_status(bcm
) != BCM43xx_STAT_INITIALIZED
) {
233 printk(KERN_INFO PFX
"debugfs: Board not initialized.\n");
237 if (sscanf(buf
, "%lli", &tsf
) != 1) {
238 printk(KERN_INFO PFX
"debugfs: invalid values for \"tsf\"\n");
242 bcm43xx_tsf_write(bcm
, tsf
);
247 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
248 mutex_unlock(&bcm
->mutex
);
254 static ssize_t
txstat_read_file(struct file
*file
, char __user
*userbuf
,
255 size_t count
, loff_t
*ppos
)
257 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
259 struct bcm43xx_private
*bcm
= file
->private_data
;
260 char *buf
= really_big_buffer
;
264 struct bcm43xx_dfsentry
*e
;
265 struct bcm43xx_xmitstatus
*status
;
268 down(&big_buffer_sem
);
269 mutex_lock(&bcm
->mutex
);
270 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
272 fappend("Last %d logged xmitstatus blobs (Latest first):\n\n",
273 BCM43xx_NR_LOGGED_XMITSTATUS
);
275 if (e
->xmitstatus_printing
== 0) {
276 /* At the beginning, make a copy of all data to avoid
277 * concurrency, as this function is called multiple
278 * times for big logs. Without copying, the data might
279 * change between reads. This would result in total trash.
281 e
->xmitstatus_printing
= 1;
282 e
->saved_xmitstatus_ptr
= e
->xmitstatus_ptr
;
283 e
->saved_xmitstatus_cnt
= e
->xmitstatus_cnt
;
284 memcpy(e
->xmitstatus_print_buffer
, e
->xmitstatus_buffer
,
285 BCM43xx_NR_LOGGED_XMITSTATUS
* sizeof(*(e
->xmitstatus_buffer
)));
287 i
= e
->saved_xmitstatus_ptr
- 1;
289 i
= BCM43xx_NR_LOGGED_XMITSTATUS
- 1;
290 cnt
= e
->saved_xmitstatus_cnt
;
292 status
= e
->xmitstatus_print_buffer
+ i
;
293 fappend("0x%02x: cookie: 0x%04x, flags: 0x%02x, "
294 "cnt1: 0x%02x, cnt2: 0x%02x, seq: 0x%04x, "
296 status
->cookie
, status
->flags
,
297 status
->cnt1
, status
->cnt2
, status
->seq
,
303 i
= BCM43xx_NR_LOGGED_XMITSTATUS
- 1;
306 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
307 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
308 spin_lock_irqsave(&bcm
->irq_lock
, flags
);
310 /* Done. Drop the copied data. */
311 e
->xmitstatus_printing
= 0;
313 spin_unlock_irqrestore(&bcm
->irq_lock
, flags
);
314 mutex_unlock(&bcm
->mutex
);
322 static struct file_operations devinfo_fops
= {
323 .read
= devinfo_read_file
,
324 .write
= write_file_dummy
,
325 .open
= open_file_generic
,
328 static struct file_operations spromdump_fops
= {
329 .read
= spromdump_read_file
,
330 .write
= write_file_dummy
,
331 .open
= open_file_generic
,
334 static struct file_operations drvinfo_fops
= {
335 .read
= drvinfo_read_file
,
336 .write
= write_file_dummy
,
337 .open
= open_file_generic
,
340 static struct file_operations tsf_fops
= {
341 .read
= tsf_read_file
,
342 .write
= tsf_write_file
,
343 .open
= open_file_generic
,
346 static struct file_operations txstat_fops
= {
347 .read
= txstat_read_file
,
348 .write
= write_file_dummy
,
349 .open
= open_file_generic
,
353 void bcm43xx_debugfs_add_device(struct bcm43xx_private
*bcm
)
355 struct bcm43xx_dfsentry
*e
;
356 char devdir
[IFNAMSIZ
];
359 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
361 printk(KERN_ERR PFX
"out of memory\n");
365 e
->xmitstatus_buffer
= kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
366 * sizeof(*(e
->xmitstatus_buffer
)),
368 if (!e
->xmitstatus_buffer
) {
369 printk(KERN_ERR PFX
"out of memory\n");
373 e
->xmitstatus_print_buffer
= kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
374 * sizeof(*(e
->xmitstatus_buffer
)),
376 if (!e
->xmitstatus_print_buffer
) {
377 printk(KERN_ERR PFX
"out of memory\n");
385 strncpy(devdir
, bcm
->net_dev
->name
, ARRAY_SIZE(devdir
));
386 e
->subdir
= debugfs_create_dir(devdir
, fs
.root
);
387 e
->dentry_devinfo
= debugfs_create_file("devinfo", 0444, e
->subdir
,
389 if (!e
->dentry_devinfo
)
390 printk(KERN_ERR PFX
"debugfs: creating \"devinfo\" for \"%s\" failed!\n", devdir
);
391 e
->dentry_spromdump
= debugfs_create_file("sprom_dump", 0444, e
->subdir
,
392 bcm
, &spromdump_fops
);
393 if (!e
->dentry_spromdump
)
394 printk(KERN_ERR PFX
"debugfs: creating \"sprom_dump\" for \"%s\" failed!\n", devdir
);
395 e
->dentry_tsf
= debugfs_create_file("tsf", 0666, e
->subdir
,
398 printk(KERN_ERR PFX
"debugfs: creating \"tsf\" for \"%s\" failed!\n", devdir
);
399 e
->dentry_txstat
= debugfs_create_file("tx_status", 0444, e
->subdir
,
401 if (!e
->dentry_txstat
)
402 printk(KERN_ERR PFX
"debugfs: creating \"tx_status\" for \"%s\" failed!\n", devdir
);
405 void bcm43xx_debugfs_remove_device(struct bcm43xx_private
*bcm
)
407 struct bcm43xx_dfsentry
*e
;
414 debugfs_remove(e
->dentry_spromdump
);
415 debugfs_remove(e
->dentry_devinfo
);
416 debugfs_remove(e
->dentry_tsf
);
417 debugfs_remove(e
->dentry_txstat
);
418 debugfs_remove(e
->subdir
);
419 kfree(e
->xmitstatus_buffer
);
420 kfree(e
->xmitstatus_print_buffer
);
424 void bcm43xx_debugfs_log_txstat(struct bcm43xx_private
*bcm
,
425 struct bcm43xx_xmitstatus
*status
)
427 struct bcm43xx_dfsentry
*e
;
428 struct bcm43xx_xmitstatus
*savedstatus
;
430 /* This is protected by bcm->_lock */
433 savedstatus
= e
->xmitstatus_buffer
+ e
->xmitstatus_ptr
;
434 memcpy(savedstatus
, status
, sizeof(*status
));
436 if (e
->xmitstatus_ptr
>= BCM43xx_NR_LOGGED_XMITSTATUS
)
437 e
->xmitstatus_ptr
= 0;
438 if (e
->xmitstatus_cnt
< BCM43xx_NR_LOGGED_XMITSTATUS
)
442 void bcm43xx_debugfs_init(void)
444 memset(&fs
, 0, sizeof(fs
));
445 fs
.root
= debugfs_create_dir(KBUILD_MODNAME
, NULL
);
447 printk(KERN_ERR PFX
"debugfs: creating \"" KBUILD_MODNAME
"\" subdir failed!\n");
448 fs
.dentry_driverinfo
= debugfs_create_file("driver", 0444, fs
.root
, NULL
, &drvinfo_fops
);
449 if (!fs
.dentry_driverinfo
)
450 printk(KERN_ERR PFX
"debugfs: creating \"" KBUILD_MODNAME
"/driver\" failed!\n");
453 void bcm43xx_debugfs_exit(void)
455 debugfs_remove(fs
.dentry_driverinfo
);
456 debugfs_remove(fs
.root
);
459 void bcm43xx_printk_dump(const char *data
,
461 const char *description
)
466 printk(KERN_INFO PFX
"Data dump (%s, %zd bytes):",
468 for (i
= 0; i
< size
; i
++) {
471 printk("\n" KERN_INFO PFX
"0x%08zx: 0x%02x, ", i
, c
& 0xff);
473 printk("0x%02x, ", c
& 0xff);
478 void bcm43xx_printk_bitdump(const unsigned char *data
,
479 size_t bytes
, int msb_to_lsb
,
480 const char *description
)
484 const unsigned char *d
;
486 printk(KERN_INFO PFX
"*** Bitdump (%s, %zd bytes, %s) ***",
487 description
, bytes
, msb_to_lsb
? "MSB to LSB" : "LSB to MSB");
488 for (i
= 0; i
< bytes
; i
++) {
491 printk("\n" KERN_INFO PFX
"0x%08zx: ", i
);
493 for (j
= 7; j
>= 0; j
--) {
500 for (j
= 0; j
< 8; j
++) {