Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003 
0004   Broadcom B43 wireless driver
0005 
0006   debugfs driver debugging code
0007 
0008   Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>
0009 
0010 
0011 */
0012 
0013 #include <linux/fs.h>
0014 #include <linux/debugfs.h>
0015 #include <linux/slab.h>
0016 #include <linux/netdevice.h>
0017 #include <linux/pci.h>
0018 #include <linux/mutex.h>
0019 
0020 #include "b43.h"
0021 #include "main.h"
0022 #include "debugfs.h"
0023 #include "dma.h"
0024 #include "xmit.h"
0025 
0026 
0027 /* The root directory. */
0028 static struct dentry *rootdir;
0029 
0030 struct b43_debugfs_fops {
0031     ssize_t (*read)(struct b43_wldev *dev, char *buf, size_t bufsize);
0032     int (*write)(struct b43_wldev *dev, const char *buf, size_t count);
0033     struct file_operations fops;
0034     /* Offset of struct b43_dfs_file in struct b43_dfsentry */
0035     size_t file_struct_offset;
0036 };
0037 
0038 static inline
0039 struct b43_dfs_file *fops_to_dfs_file(struct b43_wldev *dev,
0040                       const struct b43_debugfs_fops *dfops)
0041 {
0042     void *p;
0043 
0044     p = dev->dfsentry;
0045     p += dfops->file_struct_offset;
0046 
0047     return p;
0048 }
0049 
0050 
0051 #define fappend(fmt, x...)  \
0052     do {                            \
0053         if (bufsize - count)                \
0054             count += scnprintf(buf + count,     \
0055                       bufsize - count,  \
0056                       fmt , ##x);       \
0057         else                        \
0058             printk(KERN_ERR "b43: fappend overflow\n"); \
0059     } while (0)
0060 
0061 
0062 /* The biggest address values for SHM access from the debugfs files. */
0063 #define B43_MAX_SHM_ROUTING 4
0064 #define B43_MAX_SHM_ADDR    0xFFFF
0065 
0066 static ssize_t shm16read__read_file(struct b43_wldev *dev,
0067                     char *buf, size_t bufsize)
0068 {
0069     ssize_t count = 0;
0070     unsigned int routing, addr;
0071     u16 val;
0072 
0073     routing = dev->dfsentry->shm16read_routing_next;
0074     addr = dev->dfsentry->shm16read_addr_next;
0075     if ((routing > B43_MAX_SHM_ROUTING) ||
0076         (addr > B43_MAX_SHM_ADDR))
0077         return -EDESTADDRREQ;
0078 
0079     val = b43_shm_read16(dev, routing, addr);
0080     fappend("0x%04X\n", val);
0081 
0082     return count;
0083 }
0084 
0085 static int shm16read__write_file(struct b43_wldev *dev,
0086                  const char *buf, size_t count)
0087 {
0088     unsigned int routing, addr;
0089     int res;
0090 
0091     res = sscanf(buf, "0x%X 0x%X", &routing, &addr);
0092     if (res != 2)
0093         return -EINVAL;
0094     if (routing > B43_MAX_SHM_ROUTING)
0095         return -EADDRNOTAVAIL;
0096     if (addr > B43_MAX_SHM_ADDR)
0097         return -EADDRNOTAVAIL;
0098     if (routing == B43_SHM_SHARED) {
0099         if ((addr % 2) != 0)
0100             return -EADDRNOTAVAIL;
0101     }
0102 
0103     dev->dfsentry->shm16read_routing_next = routing;
0104     dev->dfsentry->shm16read_addr_next = addr;
0105 
0106     return 0;
0107 }
0108 
0109 static int shm16write__write_file(struct b43_wldev *dev,
0110                   const char *buf, size_t count)
0111 {
0112     unsigned int routing, addr, mask, set;
0113     u16 val;
0114     int res;
0115 
0116     res = sscanf(buf, "0x%X 0x%X 0x%X 0x%X",
0117              &routing, &addr, &mask, &set);
0118     if (res != 4)
0119         return -EINVAL;
0120     if (routing > B43_MAX_SHM_ROUTING)
0121         return -EADDRNOTAVAIL;
0122     if (addr > B43_MAX_SHM_ADDR)
0123         return -EADDRNOTAVAIL;
0124     if (routing == B43_SHM_SHARED) {
0125         if ((addr % 2) != 0)
0126             return -EADDRNOTAVAIL;
0127     }
0128     if ((mask > 0xFFFF) || (set > 0xFFFF))
0129         return -E2BIG;
0130 
0131     if (mask == 0)
0132         val = 0;
0133     else
0134         val = b43_shm_read16(dev, routing, addr);
0135     val &= mask;
0136     val |= set;
0137     b43_shm_write16(dev, routing, addr, val);
0138 
0139     return 0;
0140 }
0141 
0142 static ssize_t shm32read__read_file(struct b43_wldev *dev,
0143                     char *buf, size_t bufsize)
0144 {
0145     ssize_t count = 0;
0146     unsigned int routing, addr;
0147     u32 val;
0148 
0149     routing = dev->dfsentry->shm32read_routing_next;
0150     addr = dev->dfsentry->shm32read_addr_next;
0151     if ((routing > B43_MAX_SHM_ROUTING) ||
0152         (addr > B43_MAX_SHM_ADDR))
0153         return -EDESTADDRREQ;
0154 
0155     val = b43_shm_read32(dev, routing, addr);
0156     fappend("0x%08X\n", val);
0157 
0158     return count;
0159 }
0160 
0161 static int shm32read__write_file(struct b43_wldev *dev,
0162                  const char *buf, size_t count)
0163 {
0164     unsigned int routing, addr;
0165     int res;
0166 
0167     res = sscanf(buf, "0x%X 0x%X", &routing, &addr);
0168     if (res != 2)
0169         return -EINVAL;
0170     if (routing > B43_MAX_SHM_ROUTING)
0171         return -EADDRNOTAVAIL;
0172     if (addr > B43_MAX_SHM_ADDR)
0173         return -EADDRNOTAVAIL;
0174     if (routing == B43_SHM_SHARED) {
0175         if ((addr % 2) != 0)
0176             return -EADDRNOTAVAIL;
0177     }
0178 
0179     dev->dfsentry->shm32read_routing_next = routing;
0180     dev->dfsentry->shm32read_addr_next = addr;
0181 
0182     return 0;
0183 }
0184 
0185 static int shm32write__write_file(struct b43_wldev *dev,
0186                   const char *buf, size_t count)
0187 {
0188     unsigned int routing, addr, mask, set;
0189     u32 val;
0190     int res;
0191 
0192     res = sscanf(buf, "0x%X 0x%X 0x%X 0x%X",
0193              &routing, &addr, &mask, &set);
0194     if (res != 4)
0195         return -EINVAL;
0196     if (routing > B43_MAX_SHM_ROUTING)
0197         return -EADDRNOTAVAIL;
0198     if (addr > B43_MAX_SHM_ADDR)
0199         return -EADDRNOTAVAIL;
0200     if (routing == B43_SHM_SHARED) {
0201         if ((addr % 2) != 0)
0202             return -EADDRNOTAVAIL;
0203     }
0204     if ((mask > 0xFFFFFFFF) || (set > 0xFFFFFFFF))
0205         return -E2BIG;
0206 
0207     if (mask == 0)
0208         val = 0;
0209     else
0210         val = b43_shm_read32(dev, routing, addr);
0211     val &= mask;
0212     val |= set;
0213     b43_shm_write32(dev, routing, addr, val);
0214 
0215     return 0;
0216 }
0217 
0218 /* The biggest MMIO address that we allow access to from the debugfs files. */
0219 #define B43_MAX_MMIO_ACCESS (0xF00 - 1)
0220 
0221 static ssize_t mmio16read__read_file(struct b43_wldev *dev,
0222                      char *buf, size_t bufsize)
0223 {
0224     ssize_t count = 0;
0225     unsigned int addr;
0226     u16 val;
0227 
0228     addr = dev->dfsentry->mmio16read_next;
0229     if (addr > B43_MAX_MMIO_ACCESS)
0230         return -EDESTADDRREQ;
0231 
0232     val = b43_read16(dev, addr);
0233     fappend("0x%04X\n", val);
0234 
0235     return count;
0236 }
0237 
0238 static int mmio16read__write_file(struct b43_wldev *dev,
0239                   const char *buf, size_t count)
0240 {
0241     unsigned int addr;
0242     int res;
0243 
0244     res = sscanf(buf, "0x%X", &addr);
0245     if (res != 1)
0246         return -EINVAL;
0247     if (addr > B43_MAX_MMIO_ACCESS)
0248         return -EADDRNOTAVAIL;
0249     if ((addr % 2) != 0)
0250         return -EINVAL;
0251 
0252     dev->dfsentry->mmio16read_next = addr;
0253 
0254     return 0;
0255 }
0256 
0257 static int mmio16write__write_file(struct b43_wldev *dev,
0258                    const char *buf, size_t count)
0259 {
0260     unsigned int addr, mask, set;
0261     int res;
0262     u16 val;
0263 
0264     res = sscanf(buf, "0x%X 0x%X 0x%X", &addr, &mask, &set);
0265     if (res != 3)
0266         return -EINVAL;
0267     if (addr > B43_MAX_MMIO_ACCESS)
0268         return -EADDRNOTAVAIL;
0269     if ((mask > 0xFFFF) || (set > 0xFFFF))
0270         return -E2BIG;
0271     if ((addr % 2) != 0)
0272         return -EINVAL;
0273 
0274     if (mask == 0)
0275         val = 0;
0276     else
0277         val = b43_read16(dev, addr);
0278     val &= mask;
0279     val |= set;
0280     b43_write16(dev, addr, val);
0281 
0282     return 0;
0283 }
0284 
0285 static ssize_t mmio32read__read_file(struct b43_wldev *dev,
0286                      char *buf, size_t bufsize)
0287 {
0288     ssize_t count = 0;
0289     unsigned int addr;
0290     u32 val;
0291 
0292     addr = dev->dfsentry->mmio32read_next;
0293     if (addr > B43_MAX_MMIO_ACCESS)
0294         return -EDESTADDRREQ;
0295 
0296     val = b43_read32(dev, addr);
0297     fappend("0x%08X\n", val);
0298 
0299     return count;
0300 }
0301 
0302 static int mmio32read__write_file(struct b43_wldev *dev,
0303                   const char *buf, size_t count)
0304 {
0305     unsigned int addr;
0306     int res;
0307 
0308     res = sscanf(buf, "0x%X", &addr);
0309     if (res != 1)
0310         return -EINVAL;
0311     if (addr > B43_MAX_MMIO_ACCESS)
0312         return -EADDRNOTAVAIL;
0313     if ((addr % 4) != 0)
0314         return -EINVAL;
0315 
0316     dev->dfsentry->mmio32read_next = addr;
0317 
0318     return 0;
0319 }
0320 
0321 static int mmio32write__write_file(struct b43_wldev *dev,
0322                    const char *buf, size_t count)
0323 {
0324     unsigned int addr, mask, set;
0325     int res;
0326     u32 val;
0327 
0328     res = sscanf(buf, "0x%X 0x%X 0x%X", &addr, &mask, &set);
0329     if (res != 3)
0330         return -EINVAL;
0331     if (addr > B43_MAX_MMIO_ACCESS)
0332         return -EADDRNOTAVAIL;
0333     if ((mask > 0xFFFFFFFF) || (set > 0xFFFFFFFF))
0334         return -E2BIG;
0335     if ((addr % 4) != 0)
0336         return -EINVAL;
0337 
0338     if (mask == 0)
0339         val = 0;
0340     else
0341         val = b43_read32(dev, addr);
0342     val &= mask;
0343     val |= set;
0344     b43_write32(dev, addr, val);
0345 
0346     return 0;
0347 }
0348 
0349 static ssize_t txstat_read_file(struct b43_wldev *dev,
0350                 char *buf, size_t bufsize)
0351 {
0352     struct b43_txstatus_log *log = &dev->dfsentry->txstatlog;
0353     ssize_t count = 0;
0354     int i, idx;
0355     struct b43_txstatus *stat;
0356 
0357     if (log->end < 0) {
0358         fappend("Nothing transmitted, yet\n");
0359         goto out;
0360     }
0361     fappend("b43 TX status reports:\n\n"
0362         "index | cookie | seq | phy_stat | frame_count | "
0363         "rts_count | supp_reason | pm_indicated | "
0364         "intermediate | for_ampdu | acked\n" "---\n");
0365     i = log->end + 1;
0366     idx = 0;
0367     while (1) {
0368         if (i == B43_NR_LOGGED_TXSTATUS)
0369             i = 0;
0370         stat = &(log->log[i]);
0371         if (stat->cookie) {
0372             fappend("%03d | "
0373                 "0x%04X | 0x%04X | 0x%02X | "
0374                 "0x%X | 0x%X | "
0375                 "%u | %u | "
0376                 "%u | %u | %u\n",
0377                 idx,
0378                 stat->cookie, stat->seq, stat->phy_stat,
0379                 stat->frame_count, stat->rts_count,
0380                 stat->supp_reason, stat->pm_indicated,
0381                 stat->intermediate, stat->for_ampdu,
0382                 stat->acked);
0383             idx++;
0384         }
0385         if (i == log->end)
0386             break;
0387         i++;
0388     }
0389 out:
0390 
0391     return count;
0392 }
0393 
0394 static int restart_write_file(struct b43_wldev *dev,
0395                   const char *buf, size_t count)
0396 {
0397     int err = 0;
0398 
0399     if (count > 0 && buf[0] == '1') {
0400         b43_controller_restart(dev, "manually restarted");
0401     } else
0402         err = -EINVAL;
0403 
0404     return err;
0405 }
0406 
0407 static unsigned long calc_expire_secs(unsigned long now,
0408                       unsigned long time,
0409                       unsigned long expire)
0410 {
0411     expire = time + expire;
0412 
0413     if (time_after(now, expire))
0414         return 0; /* expired */
0415     if (expire < now) {
0416         /* jiffies wrapped */
0417         expire -= MAX_JIFFY_OFFSET;
0418         now -= MAX_JIFFY_OFFSET;
0419     }
0420     B43_WARN_ON(expire < now);
0421 
0422     return (expire - now) / HZ;
0423 }
0424 
0425 static ssize_t loctls_read_file(struct b43_wldev *dev,
0426                 char *buf, size_t bufsize)
0427 {
0428     ssize_t count = 0;
0429     struct b43_txpower_lo_control *lo;
0430     int i, err = 0;
0431     struct b43_lo_calib *cal;
0432     unsigned long now = jiffies;
0433     struct b43_phy *phy = &dev->phy;
0434 
0435     if (phy->type != B43_PHYTYPE_G) {
0436         fappend("Device is not a G-PHY\n");
0437         err = -ENODEV;
0438         goto out;
0439     }
0440     lo = phy->g->lo_control;
0441     fappend("-- Local Oscillator calibration data --\n\n");
0442     fappend("HW-power-control enabled: %d\n",
0443         dev->phy.hardware_power_control);
0444     fappend("TX Bias: 0x%02X,  TX Magn: 0x%02X  (expire in %lu sec)\n",
0445         lo->tx_bias, lo->tx_magn,
0446         calc_expire_secs(now, lo->txctl_measured_time,
0447                  B43_LO_TXCTL_EXPIRE));
0448     fappend("Power Vector: 0x%08X%08X  (expires in %lu sec)\n",
0449         (unsigned int)((lo->power_vector & 0xFFFFFFFF00000000ULL) >> 32),
0450         (unsigned int)(lo->power_vector & 0x00000000FFFFFFFFULL),
0451         calc_expire_secs(now, lo->pwr_vec_read_time,
0452                  B43_LO_PWRVEC_EXPIRE));
0453 
0454     fappend("\nCalibrated settings:\n");
0455     list_for_each_entry(cal, &lo->calib_list, list) {
0456         bool active;
0457 
0458         active = (b43_compare_bbatt(&cal->bbatt, &phy->g->bbatt) &&
0459               b43_compare_rfatt(&cal->rfatt, &phy->g->rfatt));
0460         fappend("BB(%d), RF(%d,%d)  ->  I=%d, Q=%d  "
0461             "(expires in %lu sec)%s\n",
0462             cal->bbatt.att,
0463             cal->rfatt.att, cal->rfatt.with_padmix,
0464             cal->ctl.i, cal->ctl.q,
0465             calc_expire_secs(now, cal->calib_time,
0466                      B43_LO_CALIB_EXPIRE),
0467             active ? "  ACTIVE" : "");
0468     }
0469 
0470     fappend("\nUsed RF attenuation values:  Value(WithPadmix flag)\n");
0471     for (i = 0; i < lo->rfatt_list.len; i++) {
0472         fappend("%u(%d), ",
0473             lo->rfatt_list.list[i].att,
0474             lo->rfatt_list.list[i].with_padmix);
0475     }
0476     fappend("\n");
0477     fappend("\nUsed Baseband attenuation values:\n");
0478     for (i = 0; i < lo->bbatt_list.len; i++) {
0479         fappend("%u, ",
0480             lo->bbatt_list.list[i].att);
0481     }
0482     fappend("\n");
0483 
0484 out:
0485     return err ? err : count;
0486 }
0487 
0488 #undef fappend
0489 
0490 static ssize_t b43_debugfs_read(struct file *file, char __user *userbuf,
0491                 size_t count, loff_t *ppos)
0492 {
0493     struct b43_wldev *dev;
0494     struct b43_debugfs_fops *dfops;
0495     struct b43_dfs_file *dfile;
0496     ssize_t ret;
0497     char *buf;
0498     const size_t bufsize = 1024 * 16; /* 16 kiB buffer */
0499     const size_t buforder = get_order(bufsize);
0500     int err = 0;
0501 
0502     if (!count)
0503         return 0;
0504     dev = file->private_data;
0505     if (!dev)
0506         return -ENODEV;
0507 
0508     mutex_lock(&dev->wl->mutex);
0509     if (b43_status(dev) < B43_STAT_INITIALIZED) {
0510         err = -ENODEV;
0511         goto out_unlock;
0512     }
0513 
0514     dfops = container_of(debugfs_real_fops(file),
0515                  struct b43_debugfs_fops, fops);
0516     if (!dfops->read) {
0517         err = -ENOSYS;
0518         goto out_unlock;
0519     }
0520     dfile = fops_to_dfs_file(dev, dfops);
0521 
0522     if (!dfile->buffer) {
0523         buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
0524         if (!buf) {
0525             err = -ENOMEM;
0526             goto out_unlock;
0527         }
0528         memset(buf, 0, bufsize);
0529         ret = dfops->read(dev, buf, bufsize);
0530         if (ret <= 0) {
0531             free_pages((unsigned long)buf, buforder);
0532             err = ret;
0533             goto out_unlock;
0534         }
0535         dfile->data_len = ret;
0536         dfile->buffer = buf;
0537     }
0538 
0539     ret = simple_read_from_buffer(userbuf, count, ppos,
0540                       dfile->buffer,
0541                       dfile->data_len);
0542     if (*ppos >= dfile->data_len) {
0543         free_pages((unsigned long)dfile->buffer, buforder);
0544         dfile->buffer = NULL;
0545         dfile->data_len = 0;
0546     }
0547 out_unlock:
0548     mutex_unlock(&dev->wl->mutex);
0549 
0550     return err ? err : ret;
0551 }
0552 
0553 static ssize_t b43_debugfs_write(struct file *file,
0554                  const char __user *userbuf,
0555                  size_t count, loff_t *ppos)
0556 {
0557     struct b43_wldev *dev;
0558     struct b43_debugfs_fops *dfops;
0559     char *buf;
0560     int err = 0;
0561 
0562     if (!count)
0563         return 0;
0564     if (count > PAGE_SIZE)
0565         return -E2BIG;
0566     dev = file->private_data;
0567     if (!dev)
0568         return -ENODEV;
0569 
0570     mutex_lock(&dev->wl->mutex);
0571     if (b43_status(dev) < B43_STAT_INITIALIZED) {
0572         err = -ENODEV;
0573         goto out_unlock;
0574     }
0575 
0576     dfops = container_of(debugfs_real_fops(file),
0577                  struct b43_debugfs_fops, fops);
0578     if (!dfops->write) {
0579         err = -ENOSYS;
0580         goto out_unlock;
0581     }
0582 
0583     buf = (char *)get_zeroed_page(GFP_KERNEL);
0584     if (!buf) {
0585         err = -ENOMEM;
0586         goto out_unlock;
0587     }
0588     if (copy_from_user(buf, userbuf, count)) {
0589         err = -EFAULT;
0590         goto out_freepage;
0591     }
0592     err = dfops->write(dev, buf, count);
0593     if (err)
0594         goto out_freepage;
0595 
0596 out_freepage:
0597     free_page((unsigned long)buf);
0598 out_unlock:
0599     mutex_unlock(&dev->wl->mutex);
0600 
0601     return err ? err : count;
0602 }
0603 
0604 
0605 #define B43_DEBUGFS_FOPS(name, _read, _write)           \
0606     static struct b43_debugfs_fops fops_##name = {      \
0607         .read   = _read,                \
0608         .write  = _write,               \
0609         .fops   = {                 \
0610             .open   = simple_open,          \
0611             .read   = b43_debugfs_read,     \
0612             .write  = b43_debugfs_write,        \
0613             .llseek = generic_file_llseek,      \
0614         },                      \
0615         .file_struct_offset = offsetof(struct b43_dfsentry, \
0616                            file_##name),    \
0617     }
0618 
0619 B43_DEBUGFS_FOPS(shm16read, shm16read__read_file, shm16read__write_file);
0620 B43_DEBUGFS_FOPS(shm16write, NULL, shm16write__write_file);
0621 B43_DEBUGFS_FOPS(shm32read, shm32read__read_file, shm32read__write_file);
0622 B43_DEBUGFS_FOPS(shm32write, NULL, shm32write__write_file);
0623 B43_DEBUGFS_FOPS(mmio16read, mmio16read__read_file, mmio16read__write_file);
0624 B43_DEBUGFS_FOPS(mmio16write, NULL, mmio16write__write_file);
0625 B43_DEBUGFS_FOPS(mmio32read, mmio32read__read_file, mmio32read__write_file);
0626 B43_DEBUGFS_FOPS(mmio32write, NULL, mmio32write__write_file);
0627 B43_DEBUGFS_FOPS(txstat, txstat_read_file, NULL);
0628 B43_DEBUGFS_FOPS(restart, NULL, restart_write_file);
0629 B43_DEBUGFS_FOPS(loctls, loctls_read_file, NULL);
0630 
0631 
0632 bool b43_debug(struct b43_wldev *dev, enum b43_dyndbg feature)
0633 {
0634     bool enabled;
0635 
0636     enabled = (dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
0637     if (unlikely(enabled)) {
0638         /* Force full debugging messages, if the user enabled
0639          * some dynamic debugging feature. */
0640         b43_modparam_verbose = B43_VERBOSITY_MAX;
0641     }
0642 
0643     return enabled;
0644 }
0645 
0646 static void b43_add_dynamic_debug(struct b43_wldev *dev)
0647 {
0648     struct b43_dfsentry *e = dev->dfsentry;
0649 
0650 #define add_dyn_dbg(name, id, initstate) do {           \
0651     e->dyn_debug[id] = (initstate);             \
0652     debugfs_create_bool(name, 0600, e->subdir,      \
0653                 &(e->dyn_debug[id]));       \
0654     } while (0)
0655 
0656     add_dyn_dbg("debug_xmitpower", B43_DBG_XMITPOWER, false);
0657     add_dyn_dbg("debug_dmaoverflow", B43_DBG_DMAOVERFLOW, false);
0658     add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, false);
0659     add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, false);
0660     add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, false);
0661     add_dyn_dbg("debug_lo", B43_DBG_LO, false);
0662     add_dyn_dbg("debug_firmware", B43_DBG_FIRMWARE, false);
0663     add_dyn_dbg("debug_keys", B43_DBG_KEYS, false);
0664     add_dyn_dbg("debug_verbose_stats", B43_DBG_VERBOSESTATS, false);
0665 
0666 #undef add_dyn_dbg
0667 }
0668 
0669 void b43_debugfs_add_device(struct b43_wldev *dev)
0670 {
0671     struct b43_dfsentry *e;
0672     struct b43_txstatus_log *log;
0673     char devdir[16];
0674 
0675     B43_WARN_ON(!dev);
0676     e = kzalloc(sizeof(*e), GFP_KERNEL);
0677     if (!e) {
0678         b43err(dev->wl, "debugfs: add device OOM\n");
0679         return;
0680     }
0681     e->dev = dev;
0682     log = &e->txstatlog;
0683     log->log = kcalloc(B43_NR_LOGGED_TXSTATUS,
0684                sizeof(struct b43_txstatus), GFP_KERNEL);
0685     if (!log->log) {
0686         b43err(dev->wl, "debugfs: add device txstatus OOM\n");
0687         kfree(e);
0688         return;
0689     }
0690     log->end = -1;
0691 
0692     dev->dfsentry = e;
0693 
0694     snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
0695     e->subdir = debugfs_create_dir(devdir, rootdir);
0696 
0697     e->mmio16read_next = 0xFFFF; /* invalid address */
0698     e->mmio32read_next = 0xFFFF; /* invalid address */
0699     e->shm16read_routing_next = 0xFFFFFFFF; /* invalid routing */
0700     e->shm16read_addr_next = 0xFFFFFFFF; /* invalid address */
0701     e->shm32read_routing_next = 0xFFFFFFFF; /* invalid routing */
0702     e->shm32read_addr_next = 0xFFFFFFFF; /* invalid address */
0703 
0704 #define ADD_FILE(name, mode)    \
0705     do {                            \
0706         debugfs_create_file(__stringify(name),      \
0707                 mode, e->subdir, dev,       \
0708                 &fops_##name.fops);     \
0709     } while (0)
0710 
0711 
0712     ADD_FILE(shm16read, 0600);
0713     ADD_FILE(shm16write, 0200);
0714     ADD_FILE(shm32read, 0600);
0715     ADD_FILE(shm32write, 0200);
0716     ADD_FILE(mmio16read, 0600);
0717     ADD_FILE(mmio16write, 0200);
0718     ADD_FILE(mmio32read, 0600);
0719     ADD_FILE(mmio32write, 0200);
0720     ADD_FILE(txstat, 0400);
0721     ADD_FILE(restart, 0200);
0722     ADD_FILE(loctls, 0400);
0723 
0724 #undef ADD_FILE
0725 
0726     b43_add_dynamic_debug(dev);
0727 }
0728 
0729 void b43_debugfs_remove_device(struct b43_wldev *dev)
0730 {
0731     struct b43_dfsentry *e;
0732 
0733     if (!dev)
0734         return;
0735     e = dev->dfsentry;
0736     if (!e)
0737         return;
0738 
0739     debugfs_remove(e->subdir);
0740     kfree(e->txstatlog.log);
0741     kfree(e);
0742 }
0743 
0744 void b43_debugfs_log_txstat(struct b43_wldev *dev,
0745                 const struct b43_txstatus *status)
0746 {
0747     struct b43_dfsentry *e = dev->dfsentry;
0748     struct b43_txstatus_log *log;
0749     struct b43_txstatus *cur;
0750     int i;
0751 
0752     if (!e)
0753         return;
0754     log = &e->txstatlog;
0755     i = log->end + 1;
0756     if (i == B43_NR_LOGGED_TXSTATUS)
0757         i = 0;
0758     log->end = i;
0759     cur = &(log->log[i]);
0760     memcpy(cur, status, sizeof(*cur));
0761 }
0762 
0763 void b43_debugfs_init(void)
0764 {
0765     rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
0766 }
0767 
0768 void b43_debugfs_exit(void)
0769 {
0770     debugfs_remove(rootdir);
0771 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!