LCOV - code coverage report
Current view: top level - drivers/net/wireless/broadcom/b43legacy - debugfs.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 3 213 1.4 %
Date: 2022-04-01 13:59:58 Functions: 1 14 7.1 %
Branches: 0 100 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            : 
       4                 :            :   Broadcom B43legacy wireless driver
       5                 :            : 
       6                 :            :   debugfs driver debugging code
       7                 :            : 
       8                 :            :   Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>
       9                 :            : 
      10                 :            : 
      11                 :            : */
      12                 :            : 
      13                 :            : #include <linux/fs.h>
      14                 :            : #include <linux/debugfs.h>
      15                 :            : #include <linux/slab.h>
      16                 :            : #include <linux/netdevice.h>
      17                 :            : #include <linux/pci.h>
      18                 :            : #include <linux/mutex.h>
      19                 :            : 
      20                 :            : #include "b43legacy.h"
      21                 :            : #include "main.h"
      22                 :            : #include "debugfs.h"
      23                 :            : #include "dma.h"
      24                 :            : #include "pio.h"
      25                 :            : #include "xmit.h"
      26                 :            : 
      27                 :            : 
      28                 :            : /* The root directory. */
      29                 :            : static struct dentry *rootdir;
      30                 :            : 
      31                 :            : struct b43legacy_debugfs_fops {
      32                 :            :         ssize_t (*read)(struct b43legacy_wldev *dev, char *buf, size_t bufsize);
      33                 :            :         int (*write)(struct b43legacy_wldev *dev, const char *buf, size_t count);
      34                 :            :         struct file_operations fops;
      35                 :            :         /* Offset of struct b43legacy_dfs_file in struct b43legacy_dfsentry */
      36                 :            :         size_t file_struct_offset;
      37                 :            :         /* Take wl->irq_lock before calling read/write? */
      38                 :            :         bool take_irqlock;
      39                 :            : };
      40                 :            : 
      41                 :            : static inline
      42                 :          0 : struct b43legacy_dfs_file * fops_to_dfs_file(struct b43legacy_wldev *dev,
      43                 :            :                                        const struct b43legacy_debugfs_fops *dfops)
      44                 :            : {
      45                 :          0 :         void *p;
      46                 :            : 
      47                 :          0 :         p = dev->dfsentry;
      48                 :          0 :         p += dfops->file_struct_offset;
      49                 :            : 
      50                 :          0 :         return p;
      51                 :            : }
      52                 :            : 
      53                 :            : 
      54                 :            : #define fappend(fmt, x...)      \
      55                 :            :         do {                                                    \
      56                 :            :                 if (bufsize - count)                            \
      57                 :            :                         count += snprintf(buf + count,          \
      58                 :            :                                           bufsize - count,      \
      59                 :            :                                           fmt , ##x);           \
      60                 :            :                 else                                            \
      61                 :            :                         printk(KERN_ERR "b43legacy: fappend overflow\n"); \
      62                 :            :         } while (0)
      63                 :            : 
      64                 :            : 
      65                 :            : /* wl->irq_lock is locked */
      66                 :          0 : static ssize_t tsf_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
      67                 :            : {
      68                 :          0 :         ssize_t count = 0;
      69                 :          0 :         u64 tsf;
      70                 :            : 
      71                 :          0 :         b43legacy_tsf_read(dev, &tsf);
      72         [ #  # ]:          0 :         fappend("0x%08x%08x\n",
      73                 :            :                 (unsigned int)((tsf & 0xFFFFFFFF00000000ULL) >> 32),
      74                 :            :                 (unsigned int)(tsf & 0xFFFFFFFFULL));
      75                 :            : 
      76                 :          0 :         return count;
      77                 :            : }
      78                 :            : 
      79                 :            : /* wl->irq_lock is locked */
      80                 :          0 : static int tsf_write_file(struct b43legacy_wldev *dev, const char *buf, size_t count)
      81                 :            : {
      82                 :          0 :         u64 tsf;
      83                 :            : 
      84         [ #  # ]:          0 :         if (sscanf(buf, "%llu", (unsigned long long *)(&tsf)) != 1)
      85                 :            :                 return -EINVAL;
      86                 :          0 :         b43legacy_tsf_write(dev, tsf);
      87                 :            : 
      88                 :          0 :         return 0;
      89                 :            : }
      90                 :            : 
      91                 :            : /* wl->irq_lock is locked */
      92                 :          0 : static ssize_t ucode_regs_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
      93                 :            : {
      94                 :          0 :         ssize_t count = 0;
      95                 :          0 :         int i;
      96                 :            : 
      97         [ #  # ]:          0 :         for (i = 0; i < 64; i++) {
      98         [ #  # ]:          0 :                 fappend("r%d = 0x%04x\n", i,
      99                 :            :                         b43legacy_shm_read16(dev, B43legacy_SHM_WIRELESS, i));
     100                 :            :         }
     101                 :            : 
     102                 :          0 :         return count;
     103                 :            : }
     104                 :            : 
     105                 :            : /* wl->irq_lock is locked */
     106                 :          0 : static ssize_t shm_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
     107                 :            : {
     108                 :          0 :         ssize_t count = 0;
     109                 :          0 :         int i;
     110                 :          0 :         u16 tmp;
     111                 :          0 :         __le16 *le16buf = (__le16 *)buf;
     112                 :            : 
     113         [ #  # ]:          0 :         for (i = 0; i < 0x1000; i++) {
     114         [ #  # ]:          0 :                 if (bufsize < sizeof(tmp))
     115                 :            :                         break;
     116                 :          0 :                 tmp = b43legacy_shm_read16(dev, B43legacy_SHM_SHARED, 2 * i);
     117                 :          0 :                 le16buf[i] = cpu_to_le16(tmp);
     118                 :          0 :                 count += sizeof(tmp);
     119                 :          0 :                 bufsize -= sizeof(tmp);
     120                 :            :         }
     121                 :            : 
     122                 :          0 :         return count;
     123                 :            : }
     124                 :            : 
     125                 :          0 : static ssize_t txstat_read_file(struct b43legacy_wldev *dev, char *buf, size_t bufsize)
     126                 :            : {
     127                 :          0 :         struct b43legacy_txstatus_log *log = &dev->dfsentry->txstatlog;
     128                 :          0 :         ssize_t count = 0;
     129                 :          0 :         unsigned long flags;
     130                 :          0 :         int i, idx;
     131                 :          0 :         struct b43legacy_txstatus *stat;
     132                 :            : 
     133                 :          0 :         spin_lock_irqsave(&log->lock, flags);
     134         [ #  # ]:          0 :         if (log->end < 0) {
     135         [ #  # ]:          0 :                 fappend("Nothing transmitted, yet\n");
     136                 :          0 :                 goto out_unlock;
     137                 :            :         }
     138         [ #  # ]:          0 :         fappend("b43legacy TX status reports:\n\n"
     139                 :            :                 "index | cookie | seq | phy_stat | frame_count | "
     140                 :            :                 "rts_count | supp_reason | pm_indicated | "
     141                 :            :                 "intermediate | for_ampdu | acked\n" "---\n");
     142                 :          0 :         i = log->end + 1;
     143                 :          0 :         idx = 0;
     144                 :          0 :         while (1) {
     145         [ #  # ]:          0 :                 if (i == B43legacy_NR_LOGGED_TXSTATUS)
     146                 :          0 :                         i = 0;
     147                 :          0 :                 stat = &(log->log[i]);
     148         [ #  # ]:          0 :                 if (stat->cookie) {
     149         [ #  # ]:          0 :                         fappend("%03d | "
     150                 :            :                                 "0x%04X | 0x%04X | 0x%02X | "
     151                 :            :                                 "0x%X | 0x%X | "
     152                 :            :                                 "%u | %u | "
     153                 :            :                                 "%u | %u | %u\n",
     154                 :            :                                 idx,
     155                 :            :                                 stat->cookie, stat->seq, stat->phy_stat,
     156                 :            :                                 stat->frame_count, stat->rts_count,
     157                 :            :                                 stat->supp_reason, stat->pm_indicated,
     158                 :            :                                 stat->intermediate, stat->for_ampdu,
     159                 :            :                                 stat->acked);
     160                 :          0 :                         idx++;
     161                 :            :                 }
     162         [ #  # ]:          0 :                 if (i == log->end)
     163                 :            :                         break;
     164                 :          0 :                 i++;
     165                 :            :         }
     166                 :          0 : out_unlock:
     167                 :          0 :         spin_unlock_irqrestore(&log->lock, flags);
     168                 :            : 
     169                 :          0 :         return count;
     170                 :            : }
     171                 :            : 
     172                 :            : /* wl->irq_lock is locked */
     173                 :          0 : static int restart_write_file(struct b43legacy_wldev *dev, const char *buf, size_t count)
     174                 :            : {
     175                 :          0 :         int err = 0;
     176                 :            : 
     177   [ #  #  #  # ]:          0 :         if (count > 0 && buf[0] == '1') {
     178                 :          0 :                 b43legacy_controller_restart(dev, "manually restarted");
     179                 :            :         } else
     180                 :            :                 err = -EINVAL;
     181                 :            : 
     182                 :          0 :         return err;
     183                 :            : }
     184                 :            : 
     185                 :            : #undef fappend
     186                 :            : 
     187                 :          0 : static ssize_t b43legacy_debugfs_read(struct file *file, char __user *userbuf,
     188                 :            :                                 size_t count, loff_t *ppos)
     189                 :            : {
     190                 :          0 :         struct b43legacy_wldev *dev;
     191                 :          0 :         struct b43legacy_debugfs_fops *dfops;
     192                 :          0 :         struct b43legacy_dfs_file *dfile;
     193                 :          0 :         ssize_t uninitialized_var(ret);
     194                 :          0 :         char *buf;
     195                 :          0 :         const size_t bufsize = 1024 * 16; /* 16 KiB buffer */
     196         [ #  # ]:          0 :         const size_t buforder = get_order(bufsize);
     197                 :          0 :         int err = 0;
     198                 :            : 
     199         [ #  # ]:          0 :         if (!count)
     200                 :            :                 return 0;
     201                 :          0 :         dev = file->private_data;
     202         [ #  # ]:          0 :         if (!dev)
     203                 :            :                 return -ENODEV;
     204                 :            : 
     205                 :          0 :         mutex_lock(&dev->wl->mutex);
     206         [ #  # ]:          0 :         if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
     207                 :          0 :                 err = -ENODEV;
     208                 :          0 :                 goto out_unlock;
     209                 :            :         }
     210                 :            : 
     211                 :          0 :         dfops = container_of(debugfs_real_fops(file),
     212                 :            :                              struct b43legacy_debugfs_fops, fops);
     213         [ #  # ]:          0 :         if (!dfops->read) {
     214                 :          0 :                 err = -ENOSYS;
     215                 :          0 :                 goto out_unlock;
     216                 :            :         }
     217                 :          0 :         dfile = fops_to_dfs_file(dev, dfops);
     218                 :            : 
     219         [ #  # ]:          0 :         if (!dfile->buffer) {
     220                 :          0 :                 buf = (char *)__get_free_pages(GFP_KERNEL, buforder);
     221         [ #  # ]:          0 :                 if (!buf) {
     222                 :          0 :                         err = -ENOMEM;
     223                 :          0 :                         goto out_unlock;
     224                 :            :                 }
     225                 :          0 :                 memset(buf, 0, bufsize);
     226         [ #  # ]:          0 :                 if (dfops->take_irqlock) {
     227                 :          0 :                         spin_lock_irq(&dev->wl->irq_lock);
     228                 :          0 :                         ret = dfops->read(dev, buf, bufsize);
     229                 :          0 :                         spin_unlock_irq(&dev->wl->irq_lock);
     230                 :            :                 } else
     231                 :          0 :                         ret = dfops->read(dev, buf, bufsize);
     232         [ #  # ]:          0 :                 if (ret <= 0) {
     233                 :          0 :                         free_pages((unsigned long)buf, buforder);
     234                 :          0 :                         err = ret;
     235                 :          0 :                         goto out_unlock;
     236                 :            :                 }
     237                 :          0 :                 dfile->data_len = ret;
     238                 :          0 :                 dfile->buffer = buf;
     239                 :            :         }
     240                 :            : 
     241                 :          0 :         ret = simple_read_from_buffer(userbuf, count, ppos,
     242                 :          0 :                                       dfile->buffer,
     243                 :            :                                       dfile->data_len);
     244         [ #  # ]:          0 :         if (*ppos >= dfile->data_len) {
     245                 :          0 :                 free_pages((unsigned long)dfile->buffer, buforder);
     246                 :          0 :                 dfile->buffer = NULL;
     247                 :          0 :                 dfile->data_len = 0;
     248                 :            :         }
     249                 :          0 : out_unlock:
     250                 :          0 :         mutex_unlock(&dev->wl->mutex);
     251                 :            : 
     252         [ #  # ]:          0 :         return err ? err : ret;
     253                 :            : }
     254                 :            : 
     255                 :          0 : static ssize_t b43legacy_debugfs_write(struct file *file,
     256                 :            :                                  const char __user *userbuf,
     257                 :            :                                  size_t count, loff_t *ppos)
     258                 :            : {
     259                 :          0 :         struct b43legacy_wldev *dev;
     260                 :          0 :         struct b43legacy_debugfs_fops *dfops;
     261                 :          0 :         char *buf;
     262                 :          0 :         int err = 0;
     263                 :            : 
     264         [ #  # ]:          0 :         if (!count)
     265                 :            :                 return 0;
     266         [ #  # ]:          0 :         if (count > PAGE_SIZE)
     267                 :            :                 return -E2BIG;
     268                 :          0 :         dev = file->private_data;
     269         [ #  # ]:          0 :         if (!dev)
     270                 :            :                 return -ENODEV;
     271                 :            : 
     272                 :          0 :         mutex_lock(&dev->wl->mutex);
     273         [ #  # ]:          0 :         if (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED) {
     274                 :          0 :                 err = -ENODEV;
     275                 :          0 :                 goto out_unlock;
     276                 :            :         }
     277                 :            : 
     278                 :          0 :         dfops = container_of(debugfs_real_fops(file),
     279                 :            :                              struct b43legacy_debugfs_fops, fops);
     280         [ #  # ]:          0 :         if (!dfops->write) {
     281                 :          0 :                 err = -ENOSYS;
     282                 :          0 :                 goto out_unlock;
     283                 :            :         }
     284                 :            : 
     285                 :          0 :         buf = (char *)get_zeroed_page(GFP_KERNEL);
     286         [ #  # ]:          0 :         if (!buf) {
     287                 :          0 :                 err = -ENOMEM;
     288                 :          0 :                 goto out_unlock;
     289                 :            :         }
     290   [ #  #  #  # ]:          0 :         if (copy_from_user(buf, userbuf, count)) {
     291                 :          0 :                 err = -EFAULT;
     292                 :          0 :                 goto out_freepage;
     293                 :            :         }
     294         [ #  # ]:          0 :         if (dfops->take_irqlock) {
     295                 :          0 :                 spin_lock_irq(&dev->wl->irq_lock);
     296                 :          0 :                 err = dfops->write(dev, buf, count);
     297                 :          0 :                 spin_unlock_irq(&dev->wl->irq_lock);
     298                 :            :         } else
     299                 :          0 :                 err = dfops->write(dev, buf, count);
     300         [ #  # ]:          0 :         if (err)
     301                 :          0 :                 goto out_freepage;
     302                 :            : 
     303                 :          0 : out_freepage:
     304                 :          0 :         free_page((unsigned long)buf);
     305                 :          0 : out_unlock:
     306                 :          0 :         mutex_unlock(&dev->wl->mutex);
     307                 :            : 
     308         [ #  # ]:          0 :         return err ? err : count;
     309                 :            : }
     310                 :            : 
     311                 :            : 
     312                 :            : #define B43legacy_DEBUGFS_FOPS(name, _read, _write, _take_irqlock)      \
     313                 :            :         static struct b43legacy_debugfs_fops fops_##name = {            \
     314                 :            :                 .read   = _read,                                \
     315                 :            :                 .write  = _write,                               \
     316                 :            :                 .fops   = {                                     \
     317                 :            :                         .open   = simple_open,                          \
     318                 :            :                         .read   = b43legacy_debugfs_read,               \
     319                 :            :                         .write  = b43legacy_debugfs_write,              \
     320                 :            :                         .llseek = generic_file_llseek,                  \
     321                 :            :                 },                                              \
     322                 :            :                 .file_struct_offset = offsetof(struct b43legacy_dfsentry, \
     323                 :            :                                                file_##name),    \
     324                 :            :                 .take_irqlock   = _take_irqlock,                \
     325                 :            :         }
     326                 :            : 
     327                 :            : B43legacy_DEBUGFS_FOPS(tsf, tsf_read_file, tsf_write_file, 1);
     328                 :            : B43legacy_DEBUGFS_FOPS(ucode_regs, ucode_regs_read_file, NULL, 1);
     329                 :            : B43legacy_DEBUGFS_FOPS(shm, shm_read_file, NULL, 1);
     330                 :            : B43legacy_DEBUGFS_FOPS(txstat, txstat_read_file, NULL, 0);
     331                 :            : B43legacy_DEBUGFS_FOPS(restart, NULL, restart_write_file, 1);
     332                 :            : 
     333                 :            : 
     334                 :          0 : int b43legacy_debug(struct b43legacy_wldev *dev, enum b43legacy_dyndbg feature)
     335                 :            : {
     336   [ #  #  #  # ]:          0 :         return !!(dev->dfsentry && dev->dfsentry->dyn_debug[feature]);
     337                 :            : }
     338                 :            : 
     339                 :            : static void b43legacy_remove_dynamic_debug(struct b43legacy_wldev *dev)
     340                 :            : {
     341                 :            :         struct b43legacy_dfsentry *e = dev->dfsentry;
     342                 :            :         int i;
     343                 :            : 
     344         [ #  # ]:          0 :         for (i = 0; i < __B43legacy_NR_DYNDBG; i++)
     345                 :          0 :                 debugfs_remove(e->dyn_debug_dentries[i]);
     346                 :            : }
     347                 :            : 
     348                 :            : static void b43legacy_add_dynamic_debug(struct b43legacy_wldev *dev)
     349                 :            : {
     350                 :            :         struct b43legacy_dfsentry *e = dev->dfsentry;
     351                 :            : 
     352                 :            : #define add_dyn_dbg(name, id, initstate) do {                   \
     353                 :            :         e->dyn_debug[id] = (initstate);                              \
     354                 :            :         e->dyn_debug_dentries[id] =                          \
     355                 :            :                 debugfs_create_bool(name, 0600, e->subdir,   \
     356                 :            :                                 &(e->dyn_debug[id]));            \
     357                 :            :         } while (0)
     358                 :            : 
     359                 :            :         add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, false);
     360                 :            :         add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, false);
     361                 :            :         add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, false);
     362                 :            :         add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, false);
     363                 :            :         add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, false);
     364                 :            : 
     365                 :            : #undef add_dyn_dbg
     366                 :            : }
     367                 :            : 
     368                 :          0 : void b43legacy_debugfs_add_device(struct b43legacy_wldev *dev)
     369                 :            : {
     370                 :          0 :         struct b43legacy_dfsentry *e;
     371                 :          0 :         struct b43legacy_txstatus_log *log;
     372                 :          0 :         char devdir[16];
     373                 :            : 
     374         [ #  # ]:          0 :         B43legacy_WARN_ON(!dev);
     375                 :          0 :         e = kzalloc(sizeof(*e), GFP_KERNEL);
     376         [ #  # ]:          0 :         if (!e) {
     377                 :          0 :                 b43legacyerr(dev->wl, "debugfs: add device OOM\n");
     378                 :          0 :                 return;
     379                 :            :         }
     380                 :          0 :         e->dev = dev;
     381                 :          0 :         log = &e->txstatlog;
     382                 :          0 :         log->log = kcalloc(B43legacy_NR_LOGGED_TXSTATUS,
     383                 :            :                            sizeof(struct b43legacy_txstatus), GFP_KERNEL);
     384         [ #  # ]:          0 :         if (!log->log) {
     385                 :          0 :                 b43legacyerr(dev->wl, "debugfs: add device txstatus OOM\n");
     386                 :          0 :                 kfree(e);
     387                 :          0 :                 return;
     388                 :            :         }
     389                 :          0 :         log->end = -1;
     390         [ #  # ]:          0 :         spin_lock_init(&log->lock);
     391                 :            : 
     392                 :          0 :         dev->dfsentry = e;
     393                 :            : 
     394         [ #  # ]:          0 :         snprintf(devdir, sizeof(devdir), "%s", wiphy_name(dev->wl->hw->wiphy));
     395                 :          0 :         e->subdir = debugfs_create_dir(devdir, rootdir);
     396                 :            : 
     397                 :            : #define ADD_FILE(name, mode)    \
     398                 :            :         do {                                                    \
     399                 :            :                 e->file_##name.dentry =                              \
     400                 :            :                         debugfs_create_file(__stringify(name),  \
     401                 :            :                                         mode, e->subdir, dev,        \
     402                 :            :                                         &fops_##name.fops); \
     403                 :            :                 e->file_##name.dentry = NULL;                        \
     404                 :            :         } while (0)
     405                 :            : 
     406                 :            : 
     407                 :          0 :         ADD_FILE(tsf, 0600);
     408                 :          0 :         ADD_FILE(ucode_regs, 0400);
     409                 :          0 :         ADD_FILE(shm, 0400);
     410                 :          0 :         ADD_FILE(txstat, 0400);
     411                 :          0 :         ADD_FILE(restart, 0200);
     412                 :            : 
     413                 :            : #undef ADD_FILE
     414                 :            : 
     415                 :          0 :         b43legacy_add_dynamic_debug(dev);
     416                 :            : }
     417                 :            : 
     418                 :          0 : void b43legacy_debugfs_remove_device(struct b43legacy_wldev *dev)
     419                 :            : {
     420                 :          0 :         struct b43legacy_dfsentry *e;
     421                 :            : 
     422         [ #  # ]:          0 :         if (!dev)
     423                 :            :                 return;
     424                 :          0 :         e = dev->dfsentry;
     425         [ #  # ]:          0 :         if (!e)
     426                 :            :                 return;
     427                 :            :         b43legacy_remove_dynamic_debug(dev);
     428                 :            : 
     429                 :          0 :         debugfs_remove(e->file_tsf.dentry);
     430                 :          0 :         debugfs_remove(e->file_ucode_regs.dentry);
     431                 :          0 :         debugfs_remove(e->file_shm.dentry);
     432                 :          0 :         debugfs_remove(e->file_txstat.dentry);
     433                 :          0 :         debugfs_remove(e->file_restart.dentry);
     434                 :            : 
     435                 :          0 :         debugfs_remove(e->subdir);
     436                 :          0 :         kfree(e->txstatlog.log);
     437                 :          0 :         kfree(e);
     438                 :            : }
     439                 :            : 
     440                 :          0 : void b43legacy_debugfs_log_txstat(struct b43legacy_wldev *dev,
     441                 :            :                             const struct b43legacy_txstatus *status)
     442                 :            : {
     443                 :          0 :         struct b43legacy_dfsentry *e = dev->dfsentry;
     444                 :          0 :         struct b43legacy_txstatus_log *log;
     445                 :          0 :         struct b43legacy_txstatus *cur;
     446                 :          0 :         int i;
     447                 :            : 
     448         [ #  # ]:          0 :         if (!e)
     449                 :            :                 return;
     450                 :          0 :         log = &e->txstatlog;
     451         [ #  # ]:          0 :         B43legacy_WARN_ON(!irqs_disabled());
     452                 :          0 :         spin_lock(&log->lock);
     453                 :          0 :         i = log->end + 1;
     454         [ #  # ]:          0 :         if (i == B43legacy_NR_LOGGED_TXSTATUS)
     455                 :          0 :                 i = 0;
     456                 :          0 :         log->end = i;
     457                 :          0 :         cur = &(log->log[i]);
     458                 :          0 :         memcpy(cur, status, sizeof(*cur));
     459                 :          0 :         spin_unlock(&log->lock);
     460                 :            : }
     461                 :            : 
     462                 :         78 : void b43legacy_debugfs_init(void)
     463                 :            : {
     464                 :         78 :         rootdir = debugfs_create_dir(KBUILD_MODNAME, NULL);
     465                 :         78 : }
     466                 :            : 
     467                 :          0 : void b43legacy_debugfs_exit(void)
     468                 :            : {
     469                 :          0 :         debugfs_remove(rootdir);
     470                 :          0 : }

Generated by: LCOV version 1.14