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         unsigned long long 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 }