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 bcm43xx_lock_mmio(bcm
, flags
);
81 if (!bcm
->initialized
) {
82 fappend("Board not initialized.\n");
85 net_dev
= bcm
->net_dev
;
86 pci_dev
= bcm
->pci_dev
;
88 /* This is where the information is written to the "devinfo" file */
89 fappend("*** %s devinfo ***\n", net_dev
->name
);
90 fappend("vendor: 0x%04x device: 0x%04x\n",
91 pci_dev
->vendor
, pci_dev
->device
);
92 fappend("subsystem_vendor: 0x%04x subsystem_device: 0x%04x\n",
93 pci_dev
->subsystem_vendor
, pci_dev
->subsystem_device
);
94 fappend("IRQ: %d\n", bcm
->irq
);
95 fappend("mmio_addr: 0x%p mmio_len: %u\n", bcm
->mmio_addr
, bcm
->mmio_len
);
96 fappend("chip_id: 0x%04x chip_rev: 0x%02x\n", bcm
->chip_id
, bcm
->chip_rev
);
97 if ((bcm
->core_80211
[0].rev
>= 3) && (bcm43xx_read32(bcm
, 0x0158) & (1 << 16)))
98 fappend("Radio disabled by hardware!\n");
99 if ((bcm
->core_80211
[0].rev
< 3) && !(bcm43xx_read16(bcm
, 0x049A) & (1 << 4)))
100 fappend("Radio disabled by hardware!\n");
101 fappend("board_vendor: 0x%04x board_type: 0x%04x\n", bcm
->board_vendor
,
104 fappend("\nCores:\n");
105 #define fappend_core(name, info) fappend("core \"" name "\" %s, %s, id: 0x%04x, " \
106 "rev: 0x%02x, index: 0x%02x\n", \
108 ? "available" : "nonavailable", \
110 ? "enabled" : "disabled", \
111 (info).id, (info).rev, (info).index)
112 fappend_core("CHIPCOMMON", bcm
->core_chipcommon
);
113 fappend_core("PCI", bcm
->core_pci
);
114 fappend_core("first 80211", bcm
->core_80211
[0]);
115 fappend_core("second 80211", bcm
->core_80211
[1]);
117 tmp16
= bcm43xx_read16(bcm
, BCM43xx_MMIO_GPIO_CONTROL
);
119 for (i
= 0; i
< BCM43xx_NR_LEDS
; i
++)
120 fappend("%d ", !!(tmp16
& (1 << i
)));
124 bcm43xx_unlock_mmio(bcm
, flags
);
125 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
130 static ssize_t
drvinfo_read_file(struct file
*file
, char __user
*userbuf
,
131 size_t count
, loff_t
*ppos
)
133 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
135 char *buf
= really_big_buffer
;
139 down(&big_buffer_sem
);
141 /* This is where the information is written to the "driver" file */
142 fappend(KBUILD_MODNAME
" driver\n");
143 fappend("Compiled at: %s %s\n", __DATE__
, __TIME__
);
145 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
150 static ssize_t
spromdump_read_file(struct file
*file
, char __user
*userbuf
,
151 size_t count
, loff_t
*ppos
)
153 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
155 struct bcm43xx_private
*bcm
= file
->private_data
;
156 char *buf
= really_big_buffer
;
161 down(&big_buffer_sem
);
162 bcm43xx_lock_mmio(bcm
, flags
);
163 if (!bcm
->initialized
) {
164 fappend("Board not initialized.\n");
168 /* This is where the information is written to the "sprom_dump" file */
169 fappend("boardflags: 0x%04x\n", bcm
->sprom
.boardflags
);
172 bcm43xx_unlock_mmio(bcm
, flags
);
173 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
178 static ssize_t
tsf_read_file(struct file
*file
, char __user
*userbuf
,
179 size_t count
, loff_t
*ppos
)
181 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
183 struct bcm43xx_private
*bcm
= file
->private_data
;
184 char *buf
= really_big_buffer
;
190 down(&big_buffer_sem
);
191 bcm43xx_lock_mmio(bcm
, flags
);
192 if (!bcm
->initialized
) {
193 fappend("Board not initialized.\n");
196 bcm43xx_tsf_read(bcm
, &tsf
);
197 fappend("0x%08x%08x\n",
198 (unsigned int)((tsf
& 0xFFFFFFFF00000000ULL
) >> 32),
199 (unsigned int)(tsf
& 0xFFFFFFFFULL
));
202 bcm43xx_unlock_mmio(bcm
, flags
);
203 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
208 static ssize_t
tsf_write_file(struct file
*file
, const char __user
*user_buf
,
209 size_t count
, loff_t
*ppos
)
211 struct bcm43xx_private
*bcm
= file
->private_data
;
212 char *buf
= really_big_buffer
;
218 buf_size
= min(count
, sizeof (really_big_buffer
) - 1);
219 down(&big_buffer_sem
);
220 if (copy_from_user(buf
, user_buf
, buf_size
)) {
224 bcm43xx_lock_mmio(bcm
, flags
);
225 if (!bcm
->initialized
) {
226 printk(KERN_INFO PFX
"debugfs: Board not initialized.\n");
230 if (sscanf(buf
, "%lli", &tsf
) != 1) {
231 printk(KERN_INFO PFX
"debugfs: invalid values for \"tsf\"\n");
235 bcm43xx_tsf_write(bcm
, tsf
);
239 bcm43xx_unlock_mmio(bcm
, flags
);
245 static ssize_t
txstat_read_file(struct file
*file
, char __user
*userbuf
,
246 size_t count
, loff_t
*ppos
)
248 const size_t len
= REALLY_BIG_BUFFER_SIZE
;
250 struct bcm43xx_private
*bcm
= file
->private_data
;
251 char *buf
= really_big_buffer
;
255 struct bcm43xx_dfsentry
*e
;
256 struct bcm43xx_xmitstatus
*status
;
259 down(&big_buffer_sem
);
260 bcm43xx_lock(bcm
, flags
);
262 fappend("Last %d logged xmitstatus blobs (Latest first):\n\n",
263 BCM43xx_NR_LOGGED_XMITSTATUS
);
265 if (e
->xmitstatus_printing
== 0) {
266 /* At the beginning, make a copy of all data to avoid
267 * concurrency, as this function is called multiple
268 * times for big logs. Without copying, the data might
269 * change between reads. This would result in total trash.
271 e
->xmitstatus_printing
= 1;
272 e
->saved_xmitstatus_ptr
= e
->xmitstatus_ptr
;
273 e
->saved_xmitstatus_cnt
= e
->xmitstatus_cnt
;
274 memcpy(e
->xmitstatus_print_buffer
, e
->xmitstatus_buffer
,
275 BCM43xx_NR_LOGGED_XMITSTATUS
* sizeof(*(e
->xmitstatus_buffer
)));
277 i
= e
->saved_xmitstatus_ptr
- 1;
279 i
= BCM43xx_NR_LOGGED_XMITSTATUS
- 1;
280 cnt
= e
->saved_xmitstatus_cnt
;
282 status
= e
->xmitstatus_print_buffer
+ i
;
283 fappend("0x%02x: cookie: 0x%04x, flags: 0x%02x, "
284 "cnt1: 0x%02x, cnt2: 0x%02x, seq: 0x%04x, "
286 status
->cookie
, status
->flags
,
287 status
->cnt1
, status
->cnt2
, status
->seq
,
293 i
= BCM43xx_NR_LOGGED_XMITSTATUS
- 1;
296 bcm43xx_unlock(bcm
, flags
);
297 res
= simple_read_from_buffer(userbuf
, count
, ppos
, buf
, pos
);
298 bcm43xx_lock(bcm
, flags
);
300 /* Done. Drop the copied data. */
301 e
->xmitstatus_printing
= 0;
303 bcm43xx_unlock(bcm
, flags
);
311 static struct file_operations devinfo_fops
= {
312 .read
= devinfo_read_file
,
313 .write
= write_file_dummy
,
314 .open
= open_file_generic
,
317 static struct file_operations spromdump_fops
= {
318 .read
= spromdump_read_file
,
319 .write
= write_file_dummy
,
320 .open
= open_file_generic
,
323 static struct file_operations drvinfo_fops
= {
324 .read
= drvinfo_read_file
,
325 .write
= write_file_dummy
,
326 .open
= open_file_generic
,
329 static struct file_operations tsf_fops
= {
330 .read
= tsf_read_file
,
331 .write
= tsf_write_file
,
332 .open
= open_file_generic
,
335 static struct file_operations txstat_fops
= {
336 .read
= txstat_read_file
,
337 .write
= write_file_dummy
,
338 .open
= open_file_generic
,
342 void bcm43xx_debugfs_add_device(struct bcm43xx_private
*bcm
)
344 struct bcm43xx_dfsentry
*e
;
345 char devdir
[IFNAMSIZ
];
348 e
= kzalloc(sizeof(*e
), GFP_KERNEL
);
350 printk(KERN_ERR PFX
"out of memory\n");
354 e
->xmitstatus_buffer
= kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
355 * sizeof(*(e
->xmitstatus_buffer
)),
357 if (!e
->xmitstatus_buffer
) {
358 printk(KERN_ERR PFX
"out of memory\n");
362 e
->xmitstatus_print_buffer
= kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
363 * sizeof(*(e
->xmitstatus_buffer
)),
365 if (!e
->xmitstatus_print_buffer
) {
366 printk(KERN_ERR PFX
"out of memory\n");
374 strncpy(devdir
, bcm
->net_dev
->name
, ARRAY_SIZE(devdir
));
375 e
->subdir
= debugfs_create_dir(devdir
, fs
.root
);
376 e
->dentry_devinfo
= debugfs_create_file("devinfo", 0444, e
->subdir
,
378 if (!e
->dentry_devinfo
)
379 printk(KERN_ERR PFX
"debugfs: creating \"devinfo\" for \"%s\" failed!\n", devdir
);
380 e
->dentry_spromdump
= debugfs_create_file("sprom_dump", 0444, e
->subdir
,
381 bcm
, &spromdump_fops
);
382 if (!e
->dentry_spromdump
)
383 printk(KERN_ERR PFX
"debugfs: creating \"sprom_dump\" for \"%s\" failed!\n", devdir
);
384 e
->dentry_tsf
= debugfs_create_file("tsf", 0666, e
->subdir
,
387 printk(KERN_ERR PFX
"debugfs: creating \"tsf\" for \"%s\" failed!\n", devdir
);
388 e
->dentry_txstat
= debugfs_create_file("tx_status", 0444, e
->subdir
,
390 if (!e
->dentry_txstat
)
391 printk(KERN_ERR PFX
"debugfs: creating \"tx_status\" for \"%s\" failed!\n", devdir
);
394 void bcm43xx_debugfs_remove_device(struct bcm43xx_private
*bcm
)
396 struct bcm43xx_dfsentry
*e
;
403 debugfs_remove(e
->dentry_spromdump
);
404 debugfs_remove(e
->dentry_devinfo
);
405 debugfs_remove(e
->dentry_tsf
);
406 debugfs_remove(e
->dentry_txstat
);
407 debugfs_remove(e
->subdir
);
408 kfree(e
->xmitstatus_buffer
);
409 kfree(e
->xmitstatus_print_buffer
);
413 void bcm43xx_debugfs_log_txstat(struct bcm43xx_private
*bcm
,
414 struct bcm43xx_xmitstatus
*status
)
416 struct bcm43xx_dfsentry
*e
;
417 struct bcm43xx_xmitstatus
*savedstatus
;
419 /* This is protected by bcm->_lock */
422 savedstatus
= e
->xmitstatus_buffer
+ e
->xmitstatus_ptr
;
423 memcpy(savedstatus
, status
, sizeof(*status
));
425 if (e
->xmitstatus_ptr
>= BCM43xx_NR_LOGGED_XMITSTATUS
)
426 e
->xmitstatus_ptr
= 0;
427 if (e
->xmitstatus_cnt
< BCM43xx_NR_LOGGED_XMITSTATUS
)
431 void bcm43xx_debugfs_init(void)
433 memset(&fs
, 0, sizeof(fs
));
434 fs
.root
= debugfs_create_dir(KBUILD_MODNAME
, NULL
);
436 printk(KERN_ERR PFX
"debugfs: creating \"" KBUILD_MODNAME
"\" subdir failed!\n");
437 fs
.dentry_driverinfo
= debugfs_create_file("driver", 0444, fs
.root
, NULL
, &drvinfo_fops
);
438 if (!fs
.dentry_driverinfo
)
439 printk(KERN_ERR PFX
"debugfs: creating \"" KBUILD_MODNAME
"/driver\" failed!\n");
442 void bcm43xx_debugfs_exit(void)
444 debugfs_remove(fs
.dentry_driverinfo
);
445 debugfs_remove(fs
.root
);
448 void bcm43xx_printk_dump(const char *data
,
450 const char *description
)
455 printk(KERN_INFO PFX
"Data dump (%s, %u bytes):",
457 for (i
= 0; i
< size
; i
++) {
460 printk("\n" KERN_INFO PFX
"0x%08x: 0x%02x, ", i
, c
& 0xff);
462 printk("0x%02x, ", c
& 0xff);
467 void bcm43xx_printk_bitdump(const unsigned char *data
,
468 size_t bytes
, int msb_to_lsb
,
469 const char *description
)
473 const unsigned char *d
;
475 printk(KERN_INFO PFX
"*** Bitdump (%s, %u bytes, %s) ***",
476 description
, bytes
, msb_to_lsb
? "MSB to LSB" : "LSB to MSB");
477 for (i
= 0; i
< bytes
; i
++) {
480 printk("\n" KERN_INFO PFX
"0x%08x: ", i
);
482 for (j
= 7; j
>= 0; j
--) {
489 for (j
= 0; j
< 8; j
++) {