Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-next-2.6
[linux-2.6.git] / drivers / net / wimax / i2400m / debugfs.c
1 /*
2  * Intel Wireless WiMAX Connection 2400m
3  * Debugfs interfaces to manipulate driver and device information
4  *
5  *
6  * Copyright (C) 2007 Intel Corporation <linux-wimax@intel.com>
7  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License version
11  * 2 as published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21  * 02110-1301, USA.
22  */
23
24 #include <linux/debugfs.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/spinlock.h>
28 #include <linux/device.h>
29 #include "i2400m.h"
30
31
32 #define D_SUBMODULE debugfs
33 #include "debug-levels.h"
34
35 static
36 int debugfs_netdev_queue_stopped_get(void *data, u64 *val)
37 {
38         struct i2400m *i2400m = data;
39         *val = netif_queue_stopped(i2400m->wimax_dev.net_dev);
40         return 0;
41 }
42 DEFINE_SIMPLE_ATTRIBUTE(fops_netdev_queue_stopped,
43                         debugfs_netdev_queue_stopped_get,
44                         NULL, "%llu\n");
45
46
47 static
48 struct dentry *debugfs_create_netdev_queue_stopped(
49         const char *name, struct dentry *parent, struct i2400m *i2400m)
50 {
51         return debugfs_create_file(name, 0400, parent, i2400m,
52                                    &fops_netdev_queue_stopped);
53 }
54
55
56 /*
57  * inode->i_private has the @data argument to debugfs_create_file()
58  */
59 static
60 int i2400m_stats_open(struct inode *inode, struct file *filp)
61 {
62         filp->private_data = inode->i_private;
63         return 0;
64 }
65
66 /*
67  * We don't allow partial reads of this file, as then the reader would
68  * get weirdly confused data as it is updated.
69  *
70  * So or you read it all or nothing; if you try to read with an offset
71  * != 0, we consider you are done reading.
72  */
73 static
74 ssize_t i2400m_rx_stats_read(struct file *filp, char __user *buffer,
75                              size_t count, loff_t *ppos)
76 {
77         struct i2400m *i2400m = filp->private_data;
78         char buf[128];
79         unsigned long flags;
80
81         if (*ppos != 0)
82                 return 0;
83         if (count < sizeof(buf))
84                 return -ENOSPC;
85         spin_lock_irqsave(&i2400m->rx_lock, flags);
86         snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
87                  i2400m->rx_pl_num, i2400m->rx_pl_min,
88                  i2400m->rx_pl_max, i2400m->rx_num,
89                  i2400m->rx_size_acc,
90                  i2400m->rx_size_min, i2400m->rx_size_max);
91         spin_unlock_irqrestore(&i2400m->rx_lock, flags);
92         return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
93 }
94
95
96 /* Any write clears the stats */
97 static
98 ssize_t i2400m_rx_stats_write(struct file *filp, const char __user *buffer,
99                               size_t count, loff_t *ppos)
100 {
101         struct i2400m *i2400m = filp->private_data;
102         unsigned long flags;
103
104         spin_lock_irqsave(&i2400m->rx_lock, flags);
105         i2400m->rx_pl_num = 0;
106         i2400m->rx_pl_max = 0;
107         i2400m->rx_pl_min = UINT_MAX;
108         i2400m->rx_num = 0;
109         i2400m->rx_size_acc = 0;
110         i2400m->rx_size_min = UINT_MAX;
111         i2400m->rx_size_max = 0;
112         spin_unlock_irqrestore(&i2400m->rx_lock, flags);
113         return count;
114 }
115
116 static
117 const struct file_operations i2400m_rx_stats_fops = {
118         .owner =        THIS_MODULE,
119         .open =         i2400m_stats_open,
120         .read =         i2400m_rx_stats_read,
121         .write =        i2400m_rx_stats_write,
122 };
123
124
125 /* See i2400m_rx_stats_read() */
126 static
127 ssize_t i2400m_tx_stats_read(struct file *filp, char __user *buffer,
128                              size_t count, loff_t *ppos)
129 {
130         struct i2400m *i2400m = filp->private_data;
131         char buf[128];
132         unsigned long flags;
133
134         if (*ppos != 0)
135                 return 0;
136         if (count < sizeof(buf))
137                 return -ENOSPC;
138         spin_lock_irqsave(&i2400m->tx_lock, flags);
139         snprintf(buf, sizeof(buf), "%u %u %u %u %u %u %u\n",
140                  i2400m->tx_pl_num, i2400m->tx_pl_min,
141                  i2400m->tx_pl_max, i2400m->tx_num,
142                  i2400m->tx_size_acc,
143                  i2400m->tx_size_min, i2400m->tx_size_max);
144         spin_unlock_irqrestore(&i2400m->tx_lock, flags);
145         return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));
146 }
147
148 /* Any write clears the stats */
149 static
150 ssize_t i2400m_tx_stats_write(struct file *filp, const char __user *buffer,
151                               size_t count, loff_t *ppos)
152 {
153         struct i2400m *i2400m = filp->private_data;
154         unsigned long flags;
155
156         spin_lock_irqsave(&i2400m->tx_lock, flags);
157         i2400m->tx_pl_num = 0;
158         i2400m->tx_pl_max = 0;
159         i2400m->tx_pl_min = UINT_MAX;
160         i2400m->tx_num = 0;
161         i2400m->tx_size_acc = 0;
162         i2400m->tx_size_min = UINT_MAX;
163         i2400m->tx_size_max = 0;
164         spin_unlock_irqrestore(&i2400m->tx_lock, flags);
165         return count;
166 }
167
168 static
169 const struct file_operations i2400m_tx_stats_fops = {
170         .owner =        THIS_MODULE,
171         .open =         i2400m_stats_open,
172         .read =         i2400m_tx_stats_read,
173         .write =        i2400m_tx_stats_write,
174 };
175
176
177 /* Write 1 to ask the device to go into suspend */
178 static
179 int debugfs_i2400m_suspend_set(void *data, u64 val)
180 {
181         int result;
182         struct i2400m *i2400m = data;
183         result = i2400m_cmd_enter_powersave(i2400m);
184         if (result >= 0)
185                 result = 0;
186         return result;
187 }
188 DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_suspend,
189                         NULL, debugfs_i2400m_suspend_set,
190                         "%llu\n");
191
192 static
193 struct dentry *debugfs_create_i2400m_suspend(
194         const char *name, struct dentry *parent, struct i2400m *i2400m)
195 {
196         return debugfs_create_file(name, 0200, parent, i2400m,
197                                    &fops_i2400m_suspend);
198 }
199
200
201 /*
202  * Reset the device
203  *
204  * Write 0 to ask the device to soft reset, 1 to cold reset, 2 to bus
205  * reset (as defined by enum i2400m_reset_type).
206  */
207 static
208 int debugfs_i2400m_reset_set(void *data, u64 val)
209 {
210         int result;
211         struct i2400m *i2400m = data;
212         enum i2400m_reset_type rt = val;
213         switch(rt) {
214         case I2400M_RT_WARM:
215         case I2400M_RT_COLD:
216         case I2400M_RT_BUS:
217                 result = i2400m_reset(i2400m, rt);
218                 if (result >= 0)
219                         result = 0;
220         default:
221                 result = -EINVAL;
222         }
223         return result;
224 }
225 DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_reset,
226                         NULL, debugfs_i2400m_reset_set,
227                         "%llu\n");
228
229 static
230 struct dentry *debugfs_create_i2400m_reset(
231         const char *name, struct dentry *parent, struct i2400m *i2400m)
232 {
233         return debugfs_create_file(name, 0200, parent, i2400m,
234                                    &fops_i2400m_reset);
235 }
236
237
238 #define __debugfs_register(prefix, name, parent)                        \
239 do {                                                                    \
240         result = d_level_register_debugfs(prefix, name, parent);        \
241         if (result < 0)                                                 \
242                 goto error;                                             \
243 } while (0)
244
245
246 int i2400m_debugfs_add(struct i2400m *i2400m)
247 {
248         int result;
249         struct device *dev = i2400m_dev(i2400m);
250         struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry;
251         struct dentry *fd;
252
253         dentry = debugfs_create_dir("i2400m", dentry);
254         result = PTR_ERR(dentry);
255         if (IS_ERR(dentry)) {
256                 if (result == -ENODEV)
257                         result = 0;     /* No debugfs support */
258                 goto error;
259         }
260         i2400m->debugfs_dentry = dentry;
261         __debugfs_register("dl_", control, dentry);
262         __debugfs_register("dl_", driver, dentry);
263         __debugfs_register("dl_", debugfs, dentry);
264         __debugfs_register("dl_", fw, dentry);
265         __debugfs_register("dl_", netdev, dentry);
266         __debugfs_register("dl_", rfkill, dentry);
267         __debugfs_register("dl_", rx, dentry);
268         __debugfs_register("dl_", tx, dentry);
269
270         fd = debugfs_create_size_t("tx_in", 0400, dentry,
271                                    &i2400m->tx_in);
272         result = PTR_ERR(fd);
273         if (IS_ERR(fd) && result != -ENODEV) {
274                 dev_err(dev, "Can't create debugfs entry "
275                         "tx_in: %d\n", result);
276                 goto error;
277         }
278
279         fd = debugfs_create_size_t("tx_out", 0400, dentry,
280                                    &i2400m->tx_out);
281         result = PTR_ERR(fd);
282         if (IS_ERR(fd) && result != -ENODEV) {
283                 dev_err(dev, "Can't create debugfs entry "
284                         "tx_out: %d\n", result);
285                 goto error;
286         }
287
288         fd = debugfs_create_u32("state", 0600, dentry,
289                                 &i2400m->state);
290         result = PTR_ERR(fd);
291         if (IS_ERR(fd) && result != -ENODEV) {
292                 dev_err(dev, "Can't create debugfs entry "
293                         "state: %d\n", result);
294                 goto error;
295         }
296
297         /*
298          * Trace received messages from user space
299          *
300          * In order to tap the bidirectional message stream in the
301          * 'msg' pipe, user space can read from the 'msg' pipe;
302          * however, due to limitations in libnl, we can't know what
303          * the different applications are sending down to the kernel.
304          *
305          * So we have this hack where the driver will echo any message
306          * received on the msg pipe from user space [through a call to
307          * wimax_dev->op_msg_from_user() into
308          * i2400m_op_msg_from_user()] into the 'trace' pipe that this
309          * driver creates.
310          *
311          * So then, reading from both the 'trace' and 'msg' pipes in
312          * user space will provide a full dump of the traffic.
313          *
314          * Write 1 to activate, 0 to clear.
315          *
316          * It is not really very atomic, but it is also not too
317          * critical.
318          */
319         fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry,
320                                &i2400m->trace_msg_from_user);
321         result = PTR_ERR(fd);
322         if (IS_ERR(fd) && result != -ENODEV) {
323                 dev_err(dev, "Can't create debugfs entry "
324                         "trace_msg_from_user: %d\n", result);
325                 goto error;
326         }
327
328         fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped",
329                                                  dentry, i2400m);
330         result = PTR_ERR(fd);
331         if (IS_ERR(fd) && result != -ENODEV) {
332                 dev_err(dev, "Can't create debugfs entry "
333                         "netdev_queue_stopped: %d\n", result);
334                 goto error;
335         }
336
337         fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m,
338                                  &i2400m_rx_stats_fops);
339         result = PTR_ERR(fd);
340         if (IS_ERR(fd) && result != -ENODEV) {
341                 dev_err(dev, "Can't create debugfs entry "
342                         "rx_stats: %d\n", result);
343                 goto error;
344         }
345
346         fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m,
347                                  &i2400m_tx_stats_fops);
348         result = PTR_ERR(fd);
349         if (IS_ERR(fd) && result != -ENODEV) {
350                 dev_err(dev, "Can't create debugfs entry "
351                         "tx_stats: %d\n", result);
352                 goto error;
353         }
354
355         fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m);
356         result = PTR_ERR(fd);
357         if (IS_ERR(fd) && result != -ENODEV) {
358                 dev_err(dev, "Can't create debugfs entry suspend: %d\n",
359                         result);
360                 goto error;
361         }
362
363         fd = debugfs_create_i2400m_reset("reset", dentry, i2400m);
364         result = PTR_ERR(fd);
365         if (IS_ERR(fd) && result != -ENODEV) {
366                 dev_err(dev, "Can't create debugfs entry reset: %d\n", result);
367                 goto error;
368         }
369
370         result = 0;
371 error:
372         return result;
373 }
374
375 void i2400m_debugfs_rm(struct i2400m *i2400m)
376 {
377         debugfs_remove_recursive(i2400m->debugfs_dentry);
378 }