Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / drivers / net / wireless / bcm43xx / bcm43xx_debugfs.c
1 /*
2
3   Broadcom BCM43xx wireless driver
4
5   debugfs driver debugging code
6
7   Copyright (c) 2005 Michael Buesch <mbuesch@freenet.de>
8
9   This program is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 2 of the License, or
12   (at your option) any later version.
13
14   This program is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with this program; see the file COPYING.  If not, write to
21   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
22   Boston, MA 02110-1301, USA.
23
24 */
25
26
27
28 #include <linux/fs.h>
29 #include <linux/debugfs.h>
30 #include <linux/slab.h>
31 #include <linux/netdevice.h>
32 #include <linux/pci.h>
33 #include <asm/io.h>
34
35 #include "bcm43xx.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"
41
42 #define REALLY_BIG_BUFFER_SIZE  (1024*256)
43
44 static struct bcm43xx_debugfs fs;
45 static char really_big_buffer[REALLY_BIG_BUFFER_SIZE];
46 static DECLARE_MUTEX(big_buffer_sem);
47
48
49 static ssize_t write_file_dummy(struct file *file, const char __user *buf,
50                                 size_t count, loff_t *ppos)
51 {
52         return count;
53 }
54
55 static int open_file_generic(struct inode *inode, struct file *file)
56 {
57         file->private_data = inode->i_private;
58         return 0;
59 }
60
61 #define fappend(fmt, x...)      pos += snprintf(buf + pos, len - pos, fmt , ##x)
62
63 static ssize_t devinfo_read_file(struct file *file, char __user *userbuf,
64                                  size_t count, loff_t *ppos)
65 {
66         const size_t len = REALLY_BIG_BUFFER_SIZE;
67
68         struct bcm43xx_private *bcm = file->private_data;
69         char *buf = really_big_buffer;
70         size_t pos = 0;
71         ssize_t res;
72         struct net_device *net_dev;
73         struct pci_dev *pci_dev;
74         unsigned long flags;
75         u16 tmp16;
76         int i;
77
78         down(&big_buffer_sem);
79
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");
84                 goto out;
85         }
86         net_dev = bcm->net_dev;
87         pci_dev = bcm->pci_dev;
88
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,
103                 bcm->board_type);
104
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",                \
108                                          (info).available                               \
109                                                 ? "available" : "nonavailable",         \
110                                          (info).enabled                                 \
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]);
117 #undef fappend_core
118         tmp16 = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL);
119         fappend("LEDs: ");
120         for (i = 0; i < BCM43xx_NR_LEDS; i++)
121                 fappend("%d ", !!(tmp16 & (1 << i)));
122         fappend("\n");
123
124 out:
125         spin_unlock_irqrestore(&bcm->irq_lock, flags);
126         mutex_unlock(&bcm->mutex);
127         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
128         up(&big_buffer_sem);
129         return res;
130 }
131
132 static ssize_t drvinfo_read_file(struct file *file, char __user *userbuf,
133                                  size_t count, loff_t *ppos)
134 {
135         const size_t len = REALLY_BIG_BUFFER_SIZE;
136
137         char *buf = really_big_buffer;
138         size_t pos = 0;
139         ssize_t res;
140
141         down(&big_buffer_sem);
142
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__);
146
147         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
148         up(&big_buffer_sem);
149         return res;
150 }
151
152 static ssize_t spromdump_read_file(struct file *file, char __user *userbuf,
153                                  size_t count, loff_t *ppos)
154 {
155         const size_t len = REALLY_BIG_BUFFER_SIZE;
156
157         struct bcm43xx_private *bcm = file->private_data;
158         char *buf = really_big_buffer;
159         size_t pos = 0;
160         ssize_t res;
161         unsigned long flags;
162
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");
168                 goto out;
169         }
170
171         /* This is where the information is written to the "sprom_dump" file */
172         fappend("boardflags: 0x%04x\n", bcm->sprom.boardflags);
173
174 out:
175         spin_unlock_irqrestore(&bcm->irq_lock, flags);
176         mutex_unlock(&bcm->mutex);
177         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
178         up(&big_buffer_sem);
179         return res;
180 }
181
182 static ssize_t tsf_read_file(struct file *file, char __user *userbuf,
183                              size_t count, loff_t *ppos)
184 {
185         const size_t len = REALLY_BIG_BUFFER_SIZE;
186
187         struct bcm43xx_private *bcm = file->private_data;
188         char *buf = really_big_buffer;
189         size_t pos = 0;
190         ssize_t res;
191         unsigned long flags;
192         u64 tsf;
193
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");
199                 goto out;
200         }
201         bcm43xx_tsf_read(bcm, &tsf);
202         fappend("0x%08x%08x\n",
203                 (unsigned int)((tsf & 0xFFFFFFFF00000000ULL) >> 32),
204                 (unsigned int)(tsf & 0xFFFFFFFFULL));
205
206 out:
207         spin_unlock_irqrestore(&bcm->irq_lock, flags);
208         mutex_unlock(&bcm->mutex);
209         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
210         up(&big_buffer_sem);
211         return res;
212 }
213
214 static ssize_t tsf_write_file(struct file *file, const char __user *user_buf,
215                               size_t count, loff_t *ppos)
216 {
217         struct bcm43xx_private *bcm = file->private_data;
218         char *buf = really_big_buffer;
219         ssize_t buf_size;
220         ssize_t res;
221         unsigned long flags;
222         u64 tsf;
223
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)) {
227                 res = -EFAULT;
228                 goto out_up;
229         }
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");
234                 res = -EFAULT;
235                 goto out_unlock;
236         }
237         if (sscanf(buf, "%lli", &tsf) != 1) {
238                 printk(KERN_INFO PFX "debugfs: invalid values for \"tsf\"\n");
239                 res = -EINVAL;
240                 goto out_unlock;
241         }
242         bcm43xx_tsf_write(bcm, tsf);
243         mmiowb();
244         res = buf_size;
245         
246 out_unlock:
247         spin_unlock_irqrestore(&bcm->irq_lock, flags);
248         mutex_unlock(&bcm->mutex);
249 out_up:
250         up(&big_buffer_sem);
251         return res;
252 }
253
254 static ssize_t txstat_read_file(struct file *file, char __user *userbuf,
255                                 size_t count, loff_t *ppos)
256 {
257         const size_t len = REALLY_BIG_BUFFER_SIZE;
258
259         struct bcm43xx_private *bcm = file->private_data;
260         char *buf = really_big_buffer;
261         size_t pos = 0;
262         ssize_t res;
263         unsigned long flags;
264         struct bcm43xx_dfsentry *e;
265         struct bcm43xx_xmitstatus *status;
266         int i, cnt, j = 0;
267
268         down(&big_buffer_sem);
269         mutex_lock(&bcm->mutex);
270         spin_lock_irqsave(&bcm->irq_lock, flags);
271
272         fappend("Last %d logged xmitstatus blobs (Latest first):\n\n",
273                 BCM43xx_NR_LOGGED_XMITSTATUS);
274         e = bcm->dfsentry;
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.
280                  */
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)));
286         }
287         i = e->saved_xmitstatus_ptr - 1;
288         if (i < 0)
289                 i = BCM43xx_NR_LOGGED_XMITSTATUS - 1;
290         cnt = e->saved_xmitstatus_cnt;
291         while (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,  "
295                         "unk: 0x%04x\n", j,
296                         status->cookie, status->flags,
297                         status->cnt1, status->cnt2, status->seq,
298                         status->unknown);
299                 j++;
300                 cnt--;
301                 i--;
302                 if (i < 0)
303                         i = BCM43xx_NR_LOGGED_XMITSTATUS - 1;
304         }
305
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);
309         if (*ppos == pos) {
310                 /* Done. Drop the copied data. */
311                 e->xmitstatus_printing = 0;
312         }
313         spin_unlock_irqrestore(&bcm->irq_lock, flags);
314         mutex_unlock(&bcm->mutex);
315         up(&big_buffer_sem);
316         return res;
317 }
318
319 static ssize_t restart_write_file(struct file *file, const char __user *user_buf,
320                                   size_t count, loff_t *ppos)
321 {
322         struct bcm43xx_private *bcm = file->private_data;
323         char *buf = really_big_buffer;
324         ssize_t buf_size;
325         ssize_t res;
326         unsigned long flags;
327
328         buf_size = min(count, sizeof (really_big_buffer) - 1);
329         down(&big_buffer_sem);
330         if (copy_from_user(buf, user_buf, buf_size)) {
331                 res = -EFAULT;
332                 goto out_up;
333         }
334         mutex_lock(&(bcm)->mutex);
335         spin_lock_irqsave(&(bcm)->irq_lock, flags);
336         if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED) {
337                 printk(KERN_INFO PFX "debugfs: Board not initialized.\n");
338                 res = -EFAULT;
339                 goto out_unlock;
340         }
341         if (count > 0 && buf[0] == '1') {
342                 bcm43xx_controller_restart(bcm, "manually restarted");
343                 res = count;
344         } else
345                 res = -EINVAL;
346
347 out_unlock:
348         spin_unlock_irqrestore(&(bcm)->irq_lock, flags);
349         mutex_unlock(&(bcm)->mutex);
350 out_up:
351         up(&big_buffer_sem);
352         return res;
353 }
354
355 #undef fappend
356
357
358 static const struct file_operations devinfo_fops = {
359         .read = devinfo_read_file,
360         .write = write_file_dummy,
361         .open = open_file_generic,
362 };
363
364 static const struct file_operations spromdump_fops = {
365         .read = spromdump_read_file,
366         .write = write_file_dummy,
367         .open = open_file_generic,
368 };
369
370 static const struct file_operations drvinfo_fops = {
371         .read = drvinfo_read_file,
372         .write = write_file_dummy,
373         .open = open_file_generic,
374 };
375
376 static const struct file_operations tsf_fops = {
377         .read = tsf_read_file,
378         .write = tsf_write_file,
379         .open = open_file_generic,
380 };
381
382 static const struct file_operations txstat_fops = {
383         .read = txstat_read_file,
384         .write = write_file_dummy,
385         .open = open_file_generic,
386 };
387
388 static const struct file_operations restart_fops = {
389         .write = restart_write_file,
390         .open = open_file_generic,
391 };
392
393
394 void bcm43xx_debugfs_add_device(struct bcm43xx_private *bcm)
395 {
396         struct bcm43xx_dfsentry *e;
397         char devdir[IFNAMSIZ];
398
399         assert(bcm);
400         e = kzalloc(sizeof(*e), GFP_KERNEL);
401         if (!e) {
402                 printk(KERN_ERR PFX "out of memory\n");
403                 return;
404         }
405         e->bcm = bcm;
406         e->xmitstatus_buffer = kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
407                                        * sizeof(*(e->xmitstatus_buffer)),
408                                        GFP_KERNEL);
409         if (!e->xmitstatus_buffer) {
410                 printk(KERN_ERR PFX "out of memory\n");
411                 kfree(e);
412                 return;
413         }
414         e->xmitstatus_print_buffer = kzalloc(BCM43xx_NR_LOGGED_XMITSTATUS
415                                              * sizeof(*(e->xmitstatus_buffer)),
416                                              GFP_KERNEL);
417         if (!e->xmitstatus_print_buffer) {
418                 printk(KERN_ERR PFX "out of memory\n");
419                 kfree(e);
420                 return;
421         }
422
423
424         bcm->dfsentry = e;
425
426         strncpy(devdir, bcm->net_dev->name, ARRAY_SIZE(devdir));
427         e->subdir = debugfs_create_dir(devdir, fs.root);
428         e->dentry_devinfo = debugfs_create_file("devinfo", 0444, e->subdir,
429                                                 bcm, &devinfo_fops);
430         if (!e->dentry_devinfo)
431                 printk(KERN_ERR PFX "debugfs: creating \"devinfo\" for \"%s\" failed!\n", devdir);
432         e->dentry_spromdump = debugfs_create_file("sprom_dump", 0444, e->subdir,
433                                                   bcm, &spromdump_fops);
434         if (!e->dentry_spromdump)
435                 printk(KERN_ERR PFX "debugfs: creating \"sprom_dump\" for \"%s\" failed!\n", devdir);
436         e->dentry_tsf = debugfs_create_file("tsf", 0666, e->subdir,
437                                             bcm, &tsf_fops);
438         if (!e->dentry_tsf)
439                 printk(KERN_ERR PFX "debugfs: creating \"tsf\" for \"%s\" failed!\n", devdir);
440         e->dentry_txstat = debugfs_create_file("tx_status", 0444, e->subdir,
441                                                 bcm, &txstat_fops);
442         if (!e->dentry_txstat)
443                 printk(KERN_ERR PFX "debugfs: creating \"tx_status\" for \"%s\" failed!\n", devdir);
444         e->dentry_restart = debugfs_create_file("restart", 0222, e->subdir,
445                                                 bcm, &restart_fops);
446         if (!e->dentry_restart)
447                 printk(KERN_ERR PFX "debugfs: creating \"restart\" for \"%s\" failed!\n", devdir);
448 }
449
450 void bcm43xx_debugfs_remove_device(struct bcm43xx_private *bcm)
451 {
452         struct bcm43xx_dfsentry *e;
453
454         if (!bcm)
455                 return;
456
457         e = bcm->dfsentry;
458         assert(e);
459         debugfs_remove(e->dentry_spromdump);
460         debugfs_remove(e->dentry_devinfo);
461         debugfs_remove(e->dentry_tsf);
462         debugfs_remove(e->dentry_txstat);
463         debugfs_remove(e->dentry_restart);
464         debugfs_remove(e->subdir);
465         kfree(e->xmitstatus_buffer);
466         kfree(e->xmitstatus_print_buffer);
467         kfree(e);
468 }
469
470 void bcm43xx_debugfs_log_txstat(struct bcm43xx_private *bcm,
471                                 struct bcm43xx_xmitstatus *status)
472 {
473         struct bcm43xx_dfsentry *e;
474         struct bcm43xx_xmitstatus *savedstatus;
475
476         /* This is protected by bcm->_lock */
477         e = bcm->dfsentry;
478         assert(e);
479         savedstatus = e->xmitstatus_buffer + e->xmitstatus_ptr;
480         memcpy(savedstatus, status, sizeof(*status));
481         e->xmitstatus_ptr++;
482         if (e->xmitstatus_ptr >= BCM43xx_NR_LOGGED_XMITSTATUS)
483                 e->xmitstatus_ptr = 0;
484         if (e->xmitstatus_cnt < BCM43xx_NR_LOGGED_XMITSTATUS)
485                 e->xmitstatus_cnt++;
486 }
487
488 void bcm43xx_debugfs_init(void)
489 {
490         memset(&fs, 0, sizeof(fs));
491         fs.root = debugfs_create_dir(KBUILD_MODNAME, NULL);
492         if (!fs.root)
493                 printk(KERN_ERR PFX "debugfs: creating \"" KBUILD_MODNAME "\" subdir failed!\n");
494         fs.dentry_driverinfo = debugfs_create_file("driver", 0444, fs.root, NULL, &drvinfo_fops);
495         if (!fs.dentry_driverinfo)
496                 printk(KERN_ERR PFX "debugfs: creating \"" KBUILD_MODNAME "/driver\" failed!\n");
497 }
498
499 void bcm43xx_debugfs_exit(void)
500 {
501         debugfs_remove(fs.dentry_driverinfo);
502         debugfs_remove(fs.root);
503 }
504
505 void bcm43xx_printk_dump(const char *data,
506                          size_t size,
507                          const char *description)
508 {
509         size_t i;
510         char c;
511
512         printk(KERN_INFO PFX "Data dump (%s, %zd bytes):",
513                description, size);
514         for (i = 0; i < size; i++) {
515                 c = data[i];
516                 if (i % 8 == 0)
517                         printk("\n" KERN_INFO PFX "0x%08zx:  0x%02x, ", i, c & 0xff);
518                 else
519                         printk("0x%02x, ", c & 0xff);
520         }
521         printk("\n");
522 }
523
524 void bcm43xx_printk_bitdump(const unsigned char *data,
525                             size_t bytes, int msb_to_lsb,
526                             const char *description)
527 {
528         size_t i;
529         int j;
530         const unsigned char *d;
531
532         printk(KERN_INFO PFX "*** Bitdump (%s, %zd bytes, %s) ***",
533                description, bytes, msb_to_lsb ? "MSB to LSB" : "LSB to MSB");
534         for (i = 0; i < bytes; i++) {
535                 d = data + i;
536                 if (i % 8 == 0)
537                         printk("\n" KERN_INFO PFX "0x%08zx:  ", i);
538                 if (msb_to_lsb) {
539                         for (j = 7; j >= 0; j--) {
540                                 if (*d & (1 << j))
541                                         printk("1");
542                                 else
543                                         printk("0");
544                         }
545                 } else {
546                         for (j = 0; j < 8; j++) {
547                                 if (*d & (1 << j))
548                                         printk("1");
549                                 else
550                                         printk("0");
551                         }
552                 }
553                 printk(" ");
554         }
555         printk("\n");
556 }