Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /*
  2  * cfg80211 debugfs
  3  *
  4  * Copyright 2009       Luis R. Rodriguez <lrodriguez@atheros.com>
  5  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 
 12 #include "core.h"
 13 #include "debugfs.h"
 14 
 15 static int cfg80211_open_file_generic(struct inode *inode, struct file *file)
 16 {
 17         file->private_data = inode->i_private;
 18         return 0;
 19 }
 20 
 21 #define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...)              \
 22 static ssize_t name## _read(struct file *file, char __user *userbuf,    \
 23                             size_t count, loff_t *ppos)                 \
 24 {                                                                       \
 25         struct wiphy *wiphy= file->private_data;                \
 26         char buf[buflen];                                               \
 27         int res;                                                        \
 28                                                                         \
 29         res = scnprintf(buf, buflen, fmt "\n", ##value);                \
 30         return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
 31 }                                                                       \
 32                                                                         \
 33 static const struct file_operations name## _ops = {                     \
 34         .read = name## _read,                                           \
 35         .open = cfg80211_open_file_generic,                             \
 36 };
 37 
 38 DEBUGFS_READONLY_FILE(rts_threshold, 20, "%d",
 39                       wiphy->rts_threshold)
 40 DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
 41                       wiphy->frag_threshold);
 42 DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
 43                       wiphy->retry_short)
 44 DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
 45                       wiphy->retry_long);
 46 
 47 static int ht_print_chan(struct ieee80211_channel *chan,
 48                          char *buf, int buf_size, int offset)
 49 {
 50         if (WARN_ON(offset > buf_size))
 51                 return 0;
 52 
 53         if (chan->flags & IEEE80211_CHAN_DISABLED)
 54                 return snprintf(buf + offset,
 55                                 buf_size - offset,
 56                                 "%d Disabled\n",
 57                                 chan->center_freq);
 58 
 59         return snprintf(buf + offset,
 60                         buf_size - offset,
 61                         "%d HT40 %c%c\n",
 62                         chan->center_freq,
 63                         (chan->flags & IEEE80211_CHAN_NO_HT40MINUS) ? ' ' : '-',
 64                         (chan->flags & IEEE80211_CHAN_NO_HT40PLUS)  ? ' ' : '+');
 65 }
 66 
 67 static ssize_t ht40allow_map_read(struct file *file,
 68                                   char __user *user_buf,
 69                                   size_t count, loff_t *ppos)
 70 {
 71         struct wiphy *wiphy = file->private_data;
 72         char *buf;
 73         unsigned int offset = 0, buf_size = PAGE_SIZE, i, r;
 74         enum ieee80211_band band;
 75         struct ieee80211_supported_band *sband;
 76 
 77         buf = kzalloc(buf_size, GFP_KERNEL);
 78         if (!buf)
 79                 return -ENOMEM;
 80 
 81         mutex_lock(&cfg80211_mutex);
 82 
 83         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 84                 sband = wiphy->bands[band];
 85                 if (!sband)
 86                         continue;
 87                 for (i = 0; i < sband->n_channels; i++)
 88                         offset += ht_print_chan(&sband->channels[i],
 89                                                 buf, buf_size, offset);
 90         }
 91 
 92         mutex_unlock(&cfg80211_mutex);
 93 
 94         r = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
 95 
 96         kfree(buf);
 97 
 98         return r;
 99 }
100 
101 static const struct file_operations ht40allow_map_ops = {
102         .read = ht40allow_map_read,
103         .open = cfg80211_open_file_generic,
104 };
105 
106 #define DEBUGFS_ADD(name)                                               \
107         drv->debugfs.name = debugfs_create_file(#name, S_IRUGO, phyd,   \
108                                                   &drv->wiphy, &name## _ops);
109 #define DEBUGFS_DEL(name)                                               \
110         debugfs_remove(drv->debugfs.name);                              \
111         drv->debugfs.name = NULL;
112 
113 void cfg80211_debugfs_drv_add(struct cfg80211_registered_device *drv)
114 {
115         struct dentry *phyd = drv->wiphy.debugfsdir;
116 
117         DEBUGFS_ADD(rts_threshold);
118         DEBUGFS_ADD(fragmentation_threshold);
119         DEBUGFS_ADD(short_retry_limit);
120         DEBUGFS_ADD(long_retry_limit);
121         DEBUGFS_ADD(ht40allow_map);
122 }
123 
124 void cfg80211_debugfs_drv_del(struct cfg80211_registered_device *drv)
125 {
126         DEBUGFS_DEL(rts_threshold);
127         DEBUGFS_DEL(fragmentation_threshold);
128         DEBUGFS_DEL(short_retry_limit);
129         DEBUGFS_DEL(long_retry_limit);
130         DEBUGFS_DEL(ht40allow_map);
131 }
132 
  This page was automatically generated by the LXR engine.