Merge branch 'omap-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind...
[linux-2.6] / drivers / net / wireless / libertas / debugfs.c
1 #include <linux/module.h>
2 #include <linux/dcache.h>
3 #include <linux/debugfs.h>
4 #include <linux/delay.h>
5 #include <linux/mm.h>
6 #include <linux/string.h>
7 #include <net/iw_handler.h>
8
9 #include "dev.h"
10 #include "decl.h"
11 #include "host.h"
12 #include "debugfs.h"
13
14 static struct dentry *libertas_dir = NULL;
15 static char *szStates[] = {
16         "Connected",
17         "Disconnected"
18 };
19
20 #ifdef PROC_DEBUG
21 static void libertas_debug_init(wlan_private * priv, struct net_device *dev);
22 #endif
23
24 static int open_file_generic(struct inode *inode, struct file *file)
25 {
26         file->private_data = inode->i_private;
27         return 0;
28 }
29
30 static ssize_t write_file_dummy(struct file *file, const char __user *buf,
31                                 size_t count, loff_t *ppos)
32 {
33         return -EINVAL;
34 }
35
36 static const size_t len = PAGE_SIZE;
37
38 static ssize_t libertas_dev_info(struct file *file, char __user *userbuf,
39                                   size_t count, loff_t *ppos)
40 {
41         wlan_private *priv = file->private_data;
42         size_t pos = 0;
43         unsigned long addr = get_zeroed_page(GFP_KERNEL);
44         char *buf = (char *)addr;
45         ssize_t res;
46
47         pos += snprintf(buf+pos, len-pos, "state = %s\n",
48                                 szStates[priv->adapter->connect_status]);
49         pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
50                                 (u32) priv->adapter->regioncode);
51
52         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
53
54         free_page(addr);
55         return res;
56 }
57
58
59 static ssize_t libertas_getscantable(struct file *file, char __user *userbuf,
60                                   size_t count, loff_t *ppos)
61 {
62         wlan_private *priv = file->private_data;
63         size_t pos = 0;
64         int numscansdone = 0, res;
65         unsigned long addr = get_zeroed_page(GFP_KERNEL);
66         char *buf = (char *)addr;
67         DECLARE_MAC_BUF(mac);
68         struct bss_descriptor * iter_bss;
69
70         pos += snprintf(buf+pos, len-pos,
71                 "# | ch  | rssi |       bssid       |   cap    | Qual | SSID \n");
72
73         mutex_lock(&priv->adapter->lock);
74         list_for_each_entry (iter_bss, &priv->adapter->network_list, list) {
75                 u16 ibss = (iter_bss->capability & WLAN_CAPABILITY_IBSS);
76                 u16 privacy = (iter_bss->capability & WLAN_CAPABILITY_PRIVACY);
77                 u16 spectrum_mgmt = (iter_bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT);
78
79                 pos += snprintf(buf+pos, len-pos,
80                         "%02u| %03d | %04ld | %s |",
81                         numscansdone, iter_bss->channel, iter_bss->rssi,
82                         print_mac(mac, iter_bss->bssid));
83                 pos += snprintf(buf+pos, len-pos, " %04x-", iter_bss->capability);
84                 pos += snprintf(buf+pos, len-pos, "%c%c%c |",
85                                 ibss ? 'A' : 'I', privacy ? 'P' : ' ',
86                                 spectrum_mgmt ? 'S' : ' ');
87                 pos += snprintf(buf+pos, len-pos, " %04d |", SCAN_RSSI(iter_bss->rssi));
88                 pos += snprintf(buf+pos, len-pos, " %s\n",
89                                 escape_essid(iter_bss->ssid, iter_bss->ssid_len));
90
91                 numscansdone++;
92         }
93         mutex_unlock(&priv->adapter->lock);
94
95         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
96
97         free_page(addr);
98         return res;
99 }
100
101 static ssize_t libertas_sleepparams_write(struct file *file,
102                                 const char __user *user_buf, size_t count,
103                                 loff_t *ppos)
104 {
105         wlan_private *priv = file->private_data;
106         ssize_t buf_size, res;
107         int p1, p2, p3, p4, p5, p6;
108         unsigned long addr = get_zeroed_page(GFP_KERNEL);
109         char *buf = (char *)addr;
110
111         buf_size = min(count, len - 1);
112         if (copy_from_user(buf, user_buf, buf_size)) {
113                 res = -EFAULT;
114                 goto out_unlock;
115         }
116         res = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6);
117         if (res != 6) {
118                 res = -EFAULT;
119                 goto out_unlock;
120         }
121         priv->adapter->sp.sp_error = p1;
122         priv->adapter->sp.sp_offset = p2;
123         priv->adapter->sp.sp_stabletime = p3;
124         priv->adapter->sp.sp_calcontrol = p4;
125         priv->adapter->sp.sp_extsleepclk = p5;
126         priv->adapter->sp.sp_reserved = p6;
127
128         res = libertas_prepare_and_send_command(priv,
129                                 CMD_802_11_SLEEP_PARAMS,
130                                 CMD_ACT_SET,
131                                 CMD_OPTION_WAITFORRSP, 0, NULL);
132
133         if (!res)
134                 res = count;
135         else
136                 res = -EINVAL;
137
138 out_unlock:
139         free_page(addr);
140         return res;
141 }
142
143 static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf,
144                                   size_t count, loff_t *ppos)
145 {
146         wlan_private *priv = file->private_data;
147         wlan_adapter *adapter = priv->adapter;
148         ssize_t res;
149         size_t pos = 0;
150         unsigned long addr = get_zeroed_page(GFP_KERNEL);
151         char *buf = (char *)addr;
152
153         res = libertas_prepare_and_send_command(priv,
154                                 CMD_802_11_SLEEP_PARAMS,
155                                 CMD_ACT_GET,
156                                 CMD_OPTION_WAITFORRSP, 0, NULL);
157         if (res) {
158                 res = -EFAULT;
159                 goto out_unlock;
160         }
161
162         pos += snprintf(buf, len, "%d %d %d %d %d %d\n", adapter->sp.sp_error,
163                         adapter->sp.sp_offset, adapter->sp.sp_stabletime,
164                         adapter->sp.sp_calcontrol, adapter->sp.sp_extsleepclk,
165                         adapter->sp.sp_reserved);
166
167         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
168
169 out_unlock:
170         free_page(addr);
171         return res;
172 }
173
174 static ssize_t libertas_extscan(struct file *file, const char __user *userbuf,
175                                   size_t count, loff_t *ppos)
176 {
177         wlan_private *priv = file->private_data;
178         ssize_t res, buf_size;
179         union iwreq_data wrqu;
180         unsigned long addr = get_zeroed_page(GFP_KERNEL);
181         char *buf = (char *)addr;
182
183         buf_size = min(count, len - 1);
184         if (copy_from_user(buf, userbuf, buf_size)) {
185                 res = -EFAULT;
186                 goto out_unlock;
187         }
188
189         libertas_send_specific_ssid_scan(priv, buf, strlen(buf)-1, 0);
190
191         memset(&wrqu, 0, sizeof(union iwreq_data));
192         wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
193
194 out_unlock:
195         free_page(addr);
196         return count;
197 }
198
199 static int libertas_parse_chan(char *buf, size_t count,
200                         struct wlan_ioctl_user_scan_cfg *scan_cfg, int dur)
201 {
202         char *start, *end, *hold, *str;
203         int i = 0;
204
205         start = strstr(buf, "chan=");
206         if (!start)
207                 return -EINVAL;
208         start += 5;
209         end = strchr(start, ' ');
210         if (!end)
211                 end = buf + count;
212         hold = kzalloc((end - start)+1, GFP_KERNEL);
213         if (!hold)
214                 return -ENOMEM;
215         strncpy(hold, start, end - start);
216         hold[(end-start)+1] = '\0';
217         while(hold && (str = strsep(&hold, ","))) {
218                 int chan;
219                 char band, passive = 0;
220                 sscanf(str, "%d%c%c", &chan, &band, &passive);
221                 scan_cfg->chanlist[i].channumber = chan;
222                 scan_cfg->chanlist[i].scantype = passive ? 1 : 0;
223                 if (band == 'b' || band == 'g')
224                         scan_cfg->chanlist[i].radiotype = 0;
225                 else if (band == 'a')
226                         scan_cfg->chanlist[i].radiotype = 1;
227
228                 scan_cfg->chanlist[i].scantime = dur;
229                 i++;
230         }
231
232         kfree(hold);
233         return i;
234 }
235
236 static void libertas_parse_bssid(char *buf, size_t count,
237                         struct wlan_ioctl_user_scan_cfg *scan_cfg)
238 {
239         char *hold;
240         unsigned int mac[ETH_ALEN];
241
242         hold = strstr(buf, "bssid=");
243         if (!hold)
244                 return;
245         hold += 6;
246         sscanf(hold, MAC_FMT, mac, mac+1, mac+2, mac+3, mac+4, mac+5);
247         memcpy(scan_cfg->bssid, mac, ETH_ALEN);
248 }
249
250 static void libertas_parse_ssid(char *buf, size_t count,
251                         struct wlan_ioctl_user_scan_cfg *scan_cfg)
252 {
253         char *hold, *end;
254         ssize_t size;
255
256         hold = strstr(buf, "ssid=");
257         if (!hold)
258                 return;
259         hold += 5;
260         end = strchr(hold, ' ');
261         if (!end)
262                 end = buf + count - 1;
263
264         size = min((size_t)IW_ESSID_MAX_SIZE, (size_t) (end - hold));
265         strncpy(scan_cfg->ssid, hold, size);
266
267         return;
268 }
269
270 static int libertas_parse_clear(char *buf, size_t count, const char *tag)
271 {
272         char *hold;
273         int val;
274
275         hold = strstr(buf, tag);
276         if (!hold)
277                 return 0;
278         hold += strlen(tag);
279         sscanf(hold, "%d", &val);
280
281         if (val != 0)
282                 val = 1;
283
284         return val;
285 }
286
287 static int libertas_parse_dur(char *buf, size_t count,
288                         struct wlan_ioctl_user_scan_cfg *scan_cfg)
289 {
290         char *hold;
291         int val;
292
293         hold = strstr(buf, "dur=");
294         if (!hold)
295                 return 0;
296         hold += 4;
297         sscanf(hold, "%d", &val);
298
299         return val;
300 }
301
302 static void libertas_parse_probes(char *buf, size_t count,
303                         struct wlan_ioctl_user_scan_cfg *scan_cfg)
304 {
305         char *hold;
306         int val;
307
308         hold = strstr(buf, "probes=");
309         if (!hold)
310                 return;
311         hold += 7;
312         sscanf(hold, "%d", &val);
313
314         scan_cfg->numprobes = val;
315
316         return;
317 }
318
319 static void libertas_parse_type(char *buf, size_t count,
320                         struct wlan_ioctl_user_scan_cfg *scan_cfg)
321 {
322         char *hold;
323         int val;
324
325         hold = strstr(buf, "type=");
326         if (!hold)
327                 return;
328         hold += 5;
329         sscanf(hold, "%d", &val);
330
331         /* type=1,2 or 3 */
332         if (val < 1 || val > 3)
333                 return;
334
335         scan_cfg->bsstype = val;
336
337         return;
338 }
339
340 static ssize_t libertas_setuserscan(struct file *file,
341                                     const char __user *userbuf,
342                                     size_t count, loff_t *ppos)
343 {
344         wlan_private *priv = file->private_data;
345         ssize_t res, buf_size;
346         struct wlan_ioctl_user_scan_cfg *scan_cfg;
347         union iwreq_data wrqu;
348         int dur;
349         unsigned long addr = get_zeroed_page(GFP_KERNEL);
350         char *buf = (char *)addr;
351
352         scan_cfg = kzalloc(sizeof(struct wlan_ioctl_user_scan_cfg), GFP_KERNEL);
353         if (!scan_cfg)
354                 return -ENOMEM;
355
356         buf_size = min(count, len - 1);
357         if (copy_from_user(buf, userbuf, buf_size)) {
358                 res = -EFAULT;
359                 goto out_unlock;
360         }
361
362         scan_cfg->bsstype = WLAN_SCAN_BSS_TYPE_ANY;
363
364         dur = libertas_parse_dur(buf, count, scan_cfg);
365         libertas_parse_chan(buf, count, scan_cfg, dur);
366         libertas_parse_bssid(buf, count, scan_cfg);
367         scan_cfg->clear_bssid = libertas_parse_clear(buf, count, "clear_bssid=");
368         libertas_parse_ssid(buf, count, scan_cfg);
369         scan_cfg->clear_ssid = libertas_parse_clear(buf, count, "clear_ssid=");
370         libertas_parse_probes(buf, count, scan_cfg);
371         libertas_parse_type(buf, count, scan_cfg);
372
373         wlan_scan_networks(priv, scan_cfg, 1);
374         wait_event_interruptible(priv->adapter->cmd_pending,
375                                  !priv->adapter->nr_cmd_pending);
376
377         memset(&wrqu, 0x00, sizeof(union iwreq_data));
378         wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
379
380 out_unlock:
381         free_page(addr);
382         kfree(scan_cfg);
383         return count;
384 }
385
386 static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
387                         struct cmd_ctrl_node **cmdnode,
388                         struct cmd_ds_command **cmd)
389 {
390         u16 wait_option = CMD_OPTION_WAITFORRSP;
391
392         if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
393                 lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
394                 return -ENOMEM;
395         }
396         if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) {
397                 lbs_deb_debugfs("failed to allocate response buffer!\n");
398                 return -ENOMEM;
399         }
400         libertas_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL);
401         init_waitqueue_head(&(*cmdnode)->cmdwait_q);
402         (*cmdnode)->pdata_buf = *response_buf;
403         (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
404         (*cmdnode)->cmdwaitqwoken = 0;
405         *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
406         (*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);
407         (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
408         (*cmd)->result = 0;
409         return 0;
410 }
411
412 static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
413                                   size_t count, loff_t *ppos)
414 {
415         wlan_private *priv = file->private_data;
416         wlan_adapter *adapter = priv->adapter;
417         struct cmd_ctrl_node *pcmdnode;
418         struct cmd_ds_command *pcmdptr;
419         struct cmd_ds_802_11_subscribe_event *event;
420         void *response_buf;
421         int res, cmd_len;
422         ssize_t pos = 0;
423         unsigned long addr = get_zeroed_page(GFP_KERNEL);
424         char *buf = (char *)addr;
425
426         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
427         if (res < 0) {
428                 free_page(addr);
429                 return res;
430         }
431
432         event = &pcmdptr->params.subscribe_event;
433         event->action = cpu_to_le16(CMD_ACT_GET);
434         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
435         libertas_queue_cmd(adapter, pcmdnode, 1);
436         wake_up_interruptible(&priv->waitq);
437
438         /* Sleep until response is generated by FW */
439         wait_event_interruptible(pcmdnode->cmdwait_q,
440                                  pcmdnode->cmdwaitqwoken);
441
442         pcmdptr = response_buf;
443         if (pcmdptr->result) {
444                 lbs_pr_err("%s: fail, result=%d\n", __func__,
445                            le16_to_cpu(pcmdptr->result));
446                 kfree(response_buf);
447                 free_page(addr);
448                 return 0;
449         }
450
451         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
452                 lbs_pr_err("command response incorrect!\n");
453                 kfree(response_buf);
454                 free_page(addr);
455                 return 0;
456         }
457
458         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
459         event = (void *)(response_buf + S_DS_GEN);
460         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
461                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
462                 switch (header->type) {
463                 struct mrvlietypes_rssithreshold  *Lowrssi;
464                 case __constant_cpu_to_le16(TLV_TYPE_RSSI_LOW):
465                         Lowrssi = (void *)(response_buf + cmd_len);
466                         pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
467                                         Lowrssi->rssivalue,
468                                         Lowrssi->rssifreq,
469                                         (event->events & cpu_to_le16(0x0001))?1:0);
470                 default:
471                         cmd_len += sizeof(struct mrvlietypes_snrthreshold);
472                         break;
473                 }
474         }
475
476         kfree(response_buf);
477         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
478         free_page(addr);
479         return res;
480 }
481
482 static u16 libertas_get_events_bitmap(wlan_private *priv)
483 {
484         wlan_adapter *adapter = priv->adapter;
485         struct cmd_ctrl_node *pcmdnode;
486         struct cmd_ds_command *pcmdptr;
487         struct cmd_ds_802_11_subscribe_event *event;
488         void *response_buf;
489         int res;
490         u16 event_bitmap;
491
492         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
493         if (res < 0)
494                 return res;
495
496         event = &pcmdptr->params.subscribe_event;
497         event->action = cpu_to_le16(CMD_ACT_GET);
498         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
499         libertas_queue_cmd(adapter, pcmdnode, 1);
500         wake_up_interruptible(&priv->waitq);
501
502         /* Sleep until response is generated by FW */
503         wait_event_interruptible(pcmdnode->cmdwait_q,
504                                  pcmdnode->cmdwaitqwoken);
505
506         pcmdptr = response_buf;
507
508         if (pcmdptr->result) {
509                 lbs_pr_err("%s: fail, result=%d\n", __func__,
510                            le16_to_cpu(pcmdptr->result));
511                 kfree(response_buf);
512                 return 0;
513         }
514
515         if (le16_to_cpu(pcmdptr->command) != CMD_RET(CMD_802_11_SUBSCRIBE_EVENT)) {
516                 lbs_pr_err("command response incorrect!\n");
517                 kfree(response_buf);
518                 return 0;
519         }
520
521         event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
522         event_bitmap = le16_to_cpu(event->events);
523         kfree(response_buf);
524         return event_bitmap;
525 }
526
527 static ssize_t libertas_lowrssi_write(struct file *file,
528                                     const char __user *userbuf,
529                                     size_t count, loff_t *ppos)
530 {
531         wlan_private *priv = file->private_data;
532         wlan_adapter *adapter = priv->adapter;
533         ssize_t res, buf_size;
534         int value, freq, subscribed, cmd_len;
535         struct cmd_ctrl_node *pcmdnode;
536         struct cmd_ds_command *pcmdptr;
537         struct cmd_ds_802_11_subscribe_event *event;
538         struct mrvlietypes_rssithreshold *rssi_threshold;
539         void *response_buf;
540         u16 event_bitmap;
541         u8 *ptr;
542         unsigned long addr = get_zeroed_page(GFP_KERNEL);
543         char *buf = (char *)addr;
544
545         buf_size = min(count, len - 1);
546         if (copy_from_user(buf, userbuf, buf_size)) {
547                 res = -EFAULT;
548                 goto out_unlock;
549         }
550         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
551         if (res != 3) {
552                 res = -EFAULT;
553                 goto out_unlock;
554         }
555
556         event_bitmap = libertas_get_events_bitmap(priv);
557
558         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
559         if (res < 0)
560                 goto out_unlock;
561
562         event = &pcmdptr->params.subscribe_event;
563         event->action = cpu_to_le16(CMD_ACT_SET);
564         pcmdptr->size = cpu_to_le16(S_DS_GEN +
565                 sizeof(struct cmd_ds_802_11_subscribe_event) +
566                 sizeof(struct mrvlietypes_rssithreshold));
567
568         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
569         ptr = (u8*) pcmdptr+cmd_len;
570         rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
571         rssi_threshold->header.type = cpu_to_le16(0x0104);
572         rssi_threshold->header.len = cpu_to_le16(2);
573         rssi_threshold->rssivalue = value;
574         rssi_threshold->rssifreq = freq;
575         event_bitmap |= subscribed ? 0x0001 : 0x0;
576         event->events = cpu_to_le16(event_bitmap);
577
578         libertas_queue_cmd(adapter, pcmdnode, 1);
579         wake_up_interruptible(&priv->waitq);
580
581         /* Sleep until response is generated by FW */
582         wait_event_interruptible(pcmdnode->cmdwait_q,
583                                  pcmdnode->cmdwaitqwoken);
584
585         pcmdptr = response_buf;
586
587         if (pcmdptr->result) {
588                 lbs_pr_err("%s: fail, result=%d\n", __func__,
589                            le16_to_cpu(pcmdptr->result));
590                 kfree(response_buf);
591                 free_page(addr);
592                 return 0;
593         }
594
595         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
596                 lbs_pr_err("command response incorrect!\n");
597                 kfree(response_buf);
598                 free_page(addr);
599                 return 0;
600         }
601
602         res = count;
603 out_unlock:
604         free_page(addr);
605         return res;
606 }
607
608 static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
609                                   size_t count, loff_t *ppos)
610 {
611         wlan_private *priv = file->private_data;
612         wlan_adapter *adapter = priv->adapter;
613         struct cmd_ctrl_node *pcmdnode;
614         struct cmd_ds_command *pcmdptr;
615         struct cmd_ds_802_11_subscribe_event *event;
616         void *response_buf;
617         int res, cmd_len;
618         ssize_t pos = 0;
619         unsigned long addr = get_zeroed_page(GFP_KERNEL);
620         char *buf = (char *)addr;
621
622         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
623         if (res < 0) {
624                 free_page(addr);
625                 return res;
626         }
627
628         event = &pcmdptr->params.subscribe_event;
629         event->action = cpu_to_le16(CMD_ACT_GET);
630         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
631         libertas_queue_cmd(adapter, pcmdnode, 1);
632         wake_up_interruptible(&priv->waitq);
633
634         /* Sleep until response is generated by FW */
635         wait_event_interruptible(pcmdnode->cmdwait_q,
636                                  pcmdnode->cmdwaitqwoken);
637
638         pcmdptr = response_buf;
639
640         if (pcmdptr->result) {
641                 lbs_pr_err("%s: fail, result=%d\n", __func__,
642                            le16_to_cpu(pcmdptr->result));
643                 kfree(response_buf);
644                 free_page(addr);
645                 return 0;
646         }
647
648         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
649                 lbs_pr_err("command response incorrect!\n");
650                 kfree(response_buf);
651                 free_page(addr);
652                 return 0;
653         }
654
655         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
656         event = (void *)(response_buf + S_DS_GEN);
657         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
658                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
659                 switch (header->type) {
660                 struct mrvlietypes_snrthreshold *LowSnr;
661                 case __constant_cpu_to_le16(TLV_TYPE_SNR_LOW):
662                         LowSnr = (void *)(response_buf + cmd_len);
663                         pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
664                                         LowSnr->snrvalue,
665                                         LowSnr->snrfreq,
666                                         (event->events & cpu_to_le16(0x0002))?1:0);
667                 default:
668                         cmd_len += sizeof(struct mrvlietypes_snrthreshold);
669                         break;
670                 }
671         }
672
673         kfree(response_buf);
674
675         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
676         free_page(addr);
677         return res;
678 }
679
680 static ssize_t libertas_lowsnr_write(struct file *file,
681                                     const char __user *userbuf,
682                                     size_t count, loff_t *ppos)
683 {
684         wlan_private *priv = file->private_data;
685         wlan_adapter *adapter = priv->adapter;
686         ssize_t res, buf_size;
687         int value, freq, subscribed, cmd_len;
688         struct cmd_ctrl_node *pcmdnode;
689         struct cmd_ds_command *pcmdptr;
690         struct cmd_ds_802_11_subscribe_event *event;
691         struct mrvlietypes_snrthreshold *snr_threshold;
692         void *response_buf;
693         u16 event_bitmap;
694         u8 *ptr;
695         unsigned long addr = get_zeroed_page(GFP_KERNEL);
696         char *buf = (char *)addr;
697
698         buf_size = min(count, len - 1);
699         if (copy_from_user(buf, userbuf, buf_size)) {
700                 res = -EFAULT;
701                 goto out_unlock;
702         }
703         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
704         if (res != 3) {
705                 res = -EFAULT;
706                 goto out_unlock;
707         }
708
709         event_bitmap = libertas_get_events_bitmap(priv);
710
711         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
712         if (res < 0)
713                 goto out_unlock;
714
715         event = &pcmdptr->params.subscribe_event;
716         event->action = cpu_to_le16(CMD_ACT_SET);
717         pcmdptr->size = cpu_to_le16(S_DS_GEN +
718                 sizeof(struct cmd_ds_802_11_subscribe_event) +
719                 sizeof(struct mrvlietypes_snrthreshold));
720         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
721         ptr = (u8*) pcmdptr+cmd_len;
722         snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
723         snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_LOW);
724         snr_threshold->header.len = cpu_to_le16(2);
725         snr_threshold->snrvalue = value;
726         snr_threshold->snrfreq = freq;
727         event_bitmap |= subscribed ? 0x0002 : 0x0;
728         event->events = cpu_to_le16(event_bitmap);
729
730         libertas_queue_cmd(adapter, pcmdnode, 1);
731         wake_up_interruptible(&priv->waitq);
732
733         /* Sleep until response is generated by FW */
734         wait_event_interruptible(pcmdnode->cmdwait_q,
735                                  pcmdnode->cmdwaitqwoken);
736
737         pcmdptr = response_buf;
738
739         if (pcmdptr->result) {
740                 lbs_pr_err("%s: fail, result=%d\n", __func__,
741                            le16_to_cpu(pcmdptr->result));
742                 kfree(response_buf);
743                 free_page(addr);
744                 return 0;
745         }
746
747         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
748                 lbs_pr_err("command response incorrect!\n");
749                 kfree(response_buf);
750                 free_page(addr);
751                 return 0;
752         }
753
754         res = count;
755
756 out_unlock:
757         free_page(addr);
758         return res;
759 }
760
761 static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
762                                   size_t count, loff_t *ppos)
763 {
764         wlan_private *priv = file->private_data;
765         wlan_adapter *adapter = priv->adapter;
766         struct cmd_ctrl_node *pcmdnode;
767         struct cmd_ds_command *pcmdptr;
768         struct cmd_ds_802_11_subscribe_event *event;
769         void *response_buf;
770         int res, cmd_len;
771         ssize_t pos = 0;
772         unsigned long addr = get_zeroed_page(GFP_KERNEL);
773         char *buf = (char *)addr;
774
775         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
776         if (res < 0) {
777                 free_page(addr);
778                 return res;
779         }
780
781         event = &pcmdptr->params.subscribe_event;
782         event->action = cpu_to_le16(CMD_ACT_GET);
783         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
784         libertas_queue_cmd(adapter, pcmdnode, 1);
785         wake_up_interruptible(&priv->waitq);
786
787         /* Sleep until response is generated by FW */
788         wait_event_interruptible(pcmdnode->cmdwait_q,
789                                  pcmdnode->cmdwaitqwoken);
790
791         pcmdptr = response_buf;
792
793         if (pcmdptr->result) {
794                 lbs_pr_err("%s: fail, result=%d\n", __func__,
795                            le16_to_cpu(pcmdptr->result));
796                 kfree(response_buf);
797                 free_page(addr);
798                 return 0;
799         }
800
801         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
802                 lbs_pr_err("command response incorrect!\n");
803                 kfree(response_buf);
804                 free_page(addr);
805                 return 0;
806         }
807
808         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
809         event = (void *)(response_buf + S_DS_GEN);
810         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
811                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
812                 switch (header->type) {
813                 struct mrvlietypes_failurecount *failcount;
814                 case __constant_cpu_to_le16(TLV_TYPE_FAILCOUNT):
815                         failcount = (void *)(response_buf + cmd_len);
816                         pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
817                                         failcount->failvalue,
818                                         failcount->Failfreq,
819                                         (event->events & cpu_to_le16(0x0004))?1:0);
820                 default:
821                         cmd_len += sizeof(struct mrvlietypes_failurecount);
822                         break;
823                 }
824         }
825
826         kfree(response_buf);
827         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
828         free_page(addr);
829         return res;
830 }
831
832 static ssize_t libertas_failcount_write(struct file *file,
833                                     const char __user *userbuf,
834                                     size_t count, loff_t *ppos)
835 {
836         wlan_private *priv = file->private_data;
837         wlan_adapter *adapter = priv->adapter;
838         ssize_t res, buf_size;
839         int value, freq, subscribed, cmd_len;
840         struct cmd_ctrl_node *pcmdnode;
841         struct cmd_ds_command *pcmdptr;
842         struct cmd_ds_802_11_subscribe_event *event;
843         struct mrvlietypes_failurecount *failcount;
844         void *response_buf;
845         u16 event_bitmap;
846         u8 *ptr;
847         unsigned long addr = get_zeroed_page(GFP_KERNEL);
848         char *buf = (char *)addr;
849
850         buf_size = min(count, len - 1);
851         if (copy_from_user(buf, userbuf, buf_size)) {
852                 res = -EFAULT;
853                 goto out_unlock;
854         }
855         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
856         if (res != 3) {
857                 res = -EFAULT;
858                 goto out_unlock;
859         }
860
861         event_bitmap = libertas_get_events_bitmap(priv);
862
863         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
864         if (res < 0)
865                 goto out_unlock;
866
867         event = &pcmdptr->params.subscribe_event;
868         event->action = cpu_to_le16(CMD_ACT_SET);
869         pcmdptr->size = cpu_to_le16(S_DS_GEN +
870                 sizeof(struct cmd_ds_802_11_subscribe_event) +
871                 sizeof(struct mrvlietypes_failurecount));
872         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
873         ptr = (u8*) pcmdptr+cmd_len;
874         failcount = (struct mrvlietypes_failurecount *)(ptr);
875         failcount->header.type = cpu_to_le16(TLV_TYPE_FAILCOUNT);
876         failcount->header.len = cpu_to_le16(2);
877         failcount->failvalue = value;
878         failcount->Failfreq = freq;
879         event_bitmap |= subscribed ? 0x0004 : 0x0;
880         event->events = cpu_to_le16(event_bitmap);
881
882         libertas_queue_cmd(adapter, pcmdnode, 1);
883         wake_up_interruptible(&priv->waitq);
884
885         /* Sleep until response is generated by FW */
886         wait_event_interruptible(pcmdnode->cmdwait_q,
887                                  pcmdnode->cmdwaitqwoken);
888
889         pcmdptr = (struct cmd_ds_command *)response_buf;
890
891         if (pcmdptr->result) {
892                 lbs_pr_err("%s: fail, result=%d\n", __func__,
893                            le16_to_cpu(pcmdptr->result));
894                 kfree(response_buf);
895                 free_page(addr);
896                 return 0;
897         }
898
899         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
900                 lbs_pr_err("command response incorrect!\n");
901                 kfree(response_buf);
902                 free_page(addr);
903                 return 0;
904         }
905
906         res = count;
907 out_unlock:
908         free_page(addr);
909         return res;
910 }
911
912 static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
913                                   size_t count, loff_t *ppos)
914 {
915         wlan_private *priv = file->private_data;
916         wlan_adapter *adapter = priv->adapter;
917         struct cmd_ctrl_node *pcmdnode;
918         struct cmd_ds_command *pcmdptr;
919         struct cmd_ds_802_11_subscribe_event *event;
920         void *response_buf;
921         int res, cmd_len;
922         ssize_t pos = 0;
923         unsigned long addr = get_zeroed_page(GFP_KERNEL);
924         char *buf = (char *)addr;
925
926         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
927         if (res < 0) {
928                 free_page(addr);
929                 return res;
930         }
931
932         event = &pcmdptr->params.subscribe_event;
933         event->action = cpu_to_le16(CMD_ACT_GET);
934         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
935         libertas_queue_cmd(adapter, pcmdnode, 1);
936         wake_up_interruptible(&priv->waitq);
937
938         /* Sleep until response is generated by FW */
939         wait_event_interruptible(pcmdnode->cmdwait_q,
940                                  pcmdnode->cmdwaitqwoken);
941
942         pcmdptr = response_buf;
943
944         if (pcmdptr->result) {
945                 lbs_pr_err("%s: fail, result=%d\n", __func__,
946                            le16_to_cpu(pcmdptr->result));
947                 free_page(addr);
948                 kfree(response_buf);
949                 return 0;
950         }
951
952         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
953                 lbs_pr_err("command response incorrect!\n");
954                 free_page(addr);
955                 kfree(response_buf);
956                 return 0;
957         }
958
959         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
960         event = (void *)(response_buf + S_DS_GEN);
961         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
962                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
963                 switch (header->type) {
964                 struct mrvlietypes_beaconsmissed *bcnmiss;
965                 case __constant_cpu_to_le16(TLV_TYPE_BCNMISS):
966                         bcnmiss = (void *)(response_buf + cmd_len);
967                         pos += snprintf(buf+pos, len-pos, "%d N/A %d\n",
968                                         bcnmiss->beaconmissed,
969                                         (event->events & cpu_to_le16(0x0008))?1:0);
970                 default:
971                         cmd_len += sizeof(struct mrvlietypes_beaconsmissed);
972                         break;
973                 }
974         }
975
976         kfree(response_buf);
977
978         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
979         free_page(addr);
980         return res;
981 }
982
983 static ssize_t libertas_bcnmiss_write(struct file *file,
984                                     const char __user *userbuf,
985                                     size_t count, loff_t *ppos)
986 {
987         wlan_private *priv = file->private_data;
988         wlan_adapter *adapter = priv->adapter;
989         ssize_t res, buf_size;
990         int value, freq, subscribed, cmd_len;
991         struct cmd_ctrl_node *pcmdnode;
992         struct cmd_ds_command *pcmdptr;
993         struct cmd_ds_802_11_subscribe_event *event;
994         struct mrvlietypes_beaconsmissed *bcnmiss;
995         void *response_buf;
996         u16 event_bitmap;
997         u8 *ptr;
998         unsigned long addr = get_zeroed_page(GFP_KERNEL);
999         char *buf = (char *)addr;
1000
1001         buf_size = min(count, len - 1);
1002         if (copy_from_user(buf, userbuf, buf_size)) {
1003                 res = -EFAULT;
1004                 goto out_unlock;
1005         }
1006         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1007         if (res != 3) {
1008                 res = -EFAULT;
1009                 goto out_unlock;
1010         }
1011
1012         event_bitmap = libertas_get_events_bitmap(priv);
1013
1014         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1015         if (res < 0)
1016                 goto out_unlock;
1017
1018         event = &pcmdptr->params.subscribe_event;
1019         event->action = cpu_to_le16(CMD_ACT_SET);
1020         pcmdptr->size = cpu_to_le16(S_DS_GEN +
1021                 sizeof(struct cmd_ds_802_11_subscribe_event) +
1022                 sizeof(struct mrvlietypes_beaconsmissed));
1023         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1024         ptr = (u8*) pcmdptr+cmd_len;
1025         bcnmiss = (struct mrvlietypes_beaconsmissed *)(ptr);
1026         bcnmiss->header.type = cpu_to_le16(TLV_TYPE_BCNMISS);
1027         bcnmiss->header.len = cpu_to_le16(2);
1028         bcnmiss->beaconmissed = value;
1029         event_bitmap |= subscribed ? 0x0008 : 0x0;
1030         event->events = cpu_to_le16(event_bitmap);
1031
1032         libertas_queue_cmd(adapter, pcmdnode, 1);
1033         wake_up_interruptible(&priv->waitq);
1034
1035         /* Sleep until response is generated by FW */
1036         wait_event_interruptible(pcmdnode->cmdwait_q,
1037                                  pcmdnode->cmdwaitqwoken);
1038
1039         pcmdptr = response_buf;
1040
1041         if (pcmdptr->result) {
1042                 lbs_pr_err("%s: fail, result=%d\n", __func__,
1043                            le16_to_cpu(pcmdptr->result));
1044                 kfree(response_buf);
1045                 free_page(addr);
1046                 return 0;
1047         }
1048
1049         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1050                 lbs_pr_err("command response incorrect!\n");
1051                 free_page(addr);
1052                 kfree(response_buf);
1053                 return 0;
1054         }
1055
1056         res = count;
1057 out_unlock:
1058         free_page(addr);
1059         return res;
1060 }
1061
1062 static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1063                                   size_t count, loff_t *ppos)
1064 {
1065         wlan_private *priv = file->private_data;
1066         wlan_adapter *adapter = priv->adapter;
1067         struct cmd_ctrl_node *pcmdnode;
1068         struct cmd_ds_command *pcmdptr;
1069         struct cmd_ds_802_11_subscribe_event *event;
1070         void *response_buf;
1071         int res, cmd_len;
1072         ssize_t pos = 0;
1073         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1074         char *buf = (char *)addr;
1075
1076         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1077         if (res < 0) {
1078                 free_page(addr);
1079                 return res;
1080         }
1081
1082         event = &pcmdptr->params.subscribe_event;
1083         event->action = cpu_to_le16(CMD_ACT_GET);
1084         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1085         libertas_queue_cmd(adapter, pcmdnode, 1);
1086         wake_up_interruptible(&priv->waitq);
1087
1088         /* Sleep until response is generated by FW */
1089         wait_event_interruptible(pcmdnode->cmdwait_q,
1090                                  pcmdnode->cmdwaitqwoken);
1091
1092         pcmdptr = response_buf;
1093
1094         if (pcmdptr->result) {
1095                 lbs_pr_err("%s: fail, result=%d\n", __func__,
1096                            le16_to_cpu(pcmdptr->result));
1097                 kfree(response_buf);
1098                 free_page(addr);
1099                 return 0;
1100         }
1101
1102         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1103                 lbs_pr_err("command response incorrect!\n");
1104                 kfree(response_buf);
1105                 free_page(addr);
1106                 return 0;
1107         }
1108
1109         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1110         event = (void *)(response_buf + S_DS_GEN);
1111         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1112                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1113                 switch (header->type) {
1114                 struct mrvlietypes_rssithreshold  *Highrssi;
1115                 case __constant_cpu_to_le16(TLV_TYPE_RSSI_HIGH):
1116                         Highrssi = (void *)(response_buf + cmd_len);
1117                         pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1118                                         Highrssi->rssivalue,
1119                                         Highrssi->rssifreq,
1120                                         (event->events & cpu_to_le16(0x0010))?1:0);
1121                 default:
1122                         cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1123                         break;
1124                 }
1125         }
1126
1127         kfree(response_buf);
1128
1129         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1130         free_page(addr);
1131         return res;
1132 }
1133
1134 static ssize_t libertas_highrssi_write(struct file *file,
1135                                     const char __user *userbuf,
1136                                     size_t count, loff_t *ppos)
1137 {
1138         wlan_private *priv = file->private_data;
1139         wlan_adapter *adapter = priv->adapter;
1140         ssize_t res, buf_size;
1141         int value, freq, subscribed, cmd_len;
1142         struct cmd_ctrl_node *pcmdnode;
1143         struct cmd_ds_command *pcmdptr;
1144         struct cmd_ds_802_11_subscribe_event *event;
1145         struct mrvlietypes_rssithreshold *rssi_threshold;
1146         void *response_buf;
1147         u16 event_bitmap;
1148         u8 *ptr;
1149         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1150         char *buf = (char *)addr;
1151
1152         buf_size = min(count, len - 1);
1153         if (copy_from_user(buf, userbuf, buf_size)) {
1154                 res = -EFAULT;
1155                 goto out_unlock;
1156         }
1157         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1158         if (res != 3) {
1159                 res = -EFAULT;
1160                 goto out_unlock;
1161         }
1162
1163         event_bitmap = libertas_get_events_bitmap(priv);
1164
1165         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1166         if (res < 0)
1167                 goto out_unlock;
1168
1169         event = &pcmdptr->params.subscribe_event;
1170         event->action = cpu_to_le16(CMD_ACT_SET);
1171         pcmdptr->size = cpu_to_le16(S_DS_GEN +
1172                 sizeof(struct cmd_ds_802_11_subscribe_event) +
1173                 sizeof(struct mrvlietypes_rssithreshold));
1174         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1175         ptr = (u8*) pcmdptr+cmd_len;
1176         rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
1177         rssi_threshold->header.type = cpu_to_le16(TLV_TYPE_RSSI_HIGH);
1178         rssi_threshold->header.len = cpu_to_le16(2);
1179         rssi_threshold->rssivalue = value;
1180         rssi_threshold->rssifreq = freq;
1181         event_bitmap |= subscribed ? 0x0010 : 0x0;
1182         event->events = cpu_to_le16(event_bitmap);
1183
1184         libertas_queue_cmd(adapter, pcmdnode, 1);
1185         wake_up_interruptible(&priv->waitq);
1186
1187         /* Sleep until response is generated by FW */
1188         wait_event_interruptible(pcmdnode->cmdwait_q,
1189                                  pcmdnode->cmdwaitqwoken);
1190
1191         pcmdptr = response_buf;
1192
1193         if (pcmdptr->result) {
1194                 lbs_pr_err("%s: fail, result=%d\n", __func__,
1195                            le16_to_cpu(pcmdptr->result));
1196                 kfree(response_buf);
1197                 return 0;
1198         }
1199
1200         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1201                 lbs_pr_err("command response incorrect!\n");
1202                 kfree(response_buf);
1203                 return 0;
1204         }
1205
1206         res = count;
1207 out_unlock:
1208         free_page(addr);
1209         return res;
1210 }
1211
1212 static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1213                                   size_t count, loff_t *ppos)
1214 {
1215         wlan_private *priv = file->private_data;
1216         wlan_adapter *adapter = priv->adapter;
1217         struct cmd_ctrl_node *pcmdnode;
1218         struct cmd_ds_command *pcmdptr;
1219         struct cmd_ds_802_11_subscribe_event *event;
1220         void *response_buf;
1221         int res, cmd_len;
1222         ssize_t pos = 0;
1223         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1224         char *buf = (char *)addr;
1225
1226         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1227         if (res < 0) {
1228                 free_page(addr);
1229                 return res;
1230         }
1231
1232         event = &pcmdptr->params.subscribe_event;
1233         event->action = cpu_to_le16(CMD_ACT_GET);
1234         pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1235         libertas_queue_cmd(adapter, pcmdnode, 1);
1236         wake_up_interruptible(&priv->waitq);
1237
1238         /* Sleep until response is generated by FW */
1239         wait_event_interruptible(pcmdnode->cmdwait_q,
1240                                  pcmdnode->cmdwaitqwoken);
1241
1242         pcmdptr = response_buf;
1243
1244         if (pcmdptr->result) {
1245                 lbs_pr_err("%s: fail, result=%d\n", __func__,
1246                            le16_to_cpu(pcmdptr->result));
1247                 kfree(response_buf);
1248                 free_page(addr);
1249                 return 0;
1250         }
1251
1252         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1253                 lbs_pr_err("command response incorrect!\n");
1254                 kfree(response_buf);
1255                 free_page(addr);
1256                 return 0;
1257         }
1258
1259         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1260         event = (void *)(response_buf + S_DS_GEN);
1261         while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1262                 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1263                 switch (header->type) {
1264                 struct mrvlietypes_snrthreshold *HighSnr;
1265                 case __constant_cpu_to_le16(TLV_TYPE_SNR_HIGH):
1266                         HighSnr = (void *)(response_buf + cmd_len);
1267                         pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1268                                         HighSnr->snrvalue,
1269                                         HighSnr->snrfreq,
1270                                         (event->events & cpu_to_le16(0x0020))?1:0);
1271                 default:
1272                         cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1273                         break;
1274                 }
1275         }
1276
1277         kfree(response_buf);
1278
1279         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1280         free_page(addr);
1281         return res;
1282 }
1283
1284 static ssize_t libertas_highsnr_write(struct file *file,
1285                                     const char __user *userbuf,
1286                                     size_t count, loff_t *ppos)
1287 {
1288         wlan_private *priv = file->private_data;
1289         wlan_adapter *adapter = priv->adapter;
1290         ssize_t res, buf_size;
1291         int value, freq, subscribed, cmd_len;
1292         struct cmd_ctrl_node *pcmdnode;
1293         struct cmd_ds_command *pcmdptr;
1294         struct cmd_ds_802_11_subscribe_event *event;
1295         struct mrvlietypes_snrthreshold *snr_threshold;
1296         void *response_buf;
1297         u16 event_bitmap;
1298         u8 *ptr;
1299         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1300         char *buf = (char *)addr;
1301
1302         buf_size = min(count, len - 1);
1303         if (copy_from_user(buf, userbuf, buf_size)) {
1304                 res = -EFAULT;
1305                 goto out_unlock;
1306         }
1307         res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1308         if (res != 3) {
1309                 res = -EFAULT;
1310                 goto out_unlock;
1311         }
1312
1313         event_bitmap = libertas_get_events_bitmap(priv);
1314
1315         res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1316         if (res < 0)
1317                 goto out_unlock;
1318
1319         event = &pcmdptr->params.subscribe_event;
1320         event->action = cpu_to_le16(CMD_ACT_SET);
1321         pcmdptr->size = cpu_to_le16(S_DS_GEN +
1322                 sizeof(struct cmd_ds_802_11_subscribe_event) +
1323                 sizeof(struct mrvlietypes_snrthreshold));
1324         cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1325         ptr = (u8*) pcmdptr+cmd_len;
1326         snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
1327         snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_HIGH);
1328         snr_threshold->header.len = cpu_to_le16(2);
1329         snr_threshold->snrvalue = value;
1330         snr_threshold->snrfreq = freq;
1331         event_bitmap |= subscribed ? 0x0020 : 0x0;
1332         event->events = cpu_to_le16(event_bitmap);
1333
1334         libertas_queue_cmd(adapter, pcmdnode, 1);
1335         wake_up_interruptible(&priv->waitq);
1336
1337         /* Sleep until response is generated by FW */
1338         wait_event_interruptible(pcmdnode->cmdwait_q,
1339                                  pcmdnode->cmdwaitqwoken);
1340
1341         pcmdptr = response_buf;
1342
1343         if (pcmdptr->result) {
1344                 lbs_pr_err("%s: fail, result=%d\n", __func__,
1345                            le16_to_cpu(pcmdptr->result));
1346                 kfree(response_buf);
1347                 free_page(addr);
1348                 return 0;
1349         }
1350
1351         if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1352                 lbs_pr_err("command response incorrect!\n");
1353                 kfree(response_buf);
1354                 free_page(addr);
1355                 return 0;
1356         }
1357
1358         res = count;
1359 out_unlock:
1360         free_page(addr);
1361         return res;
1362 }
1363
1364 static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1365                                   size_t count, loff_t *ppos)
1366 {
1367         wlan_private *priv = file->private_data;
1368         wlan_adapter *adapter = priv->adapter;
1369         struct wlan_offset_value offval;
1370         ssize_t pos = 0;
1371         int ret;
1372         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1373         char *buf = (char *)addr;
1374
1375         offval.offset = priv->mac_offset;
1376         offval.value = 0;
1377
1378         ret = libertas_prepare_and_send_command(priv,
1379                                 CMD_MAC_REG_ACCESS, 0,
1380                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1381         mdelay(10);
1382         pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
1383                                 priv->mac_offset, adapter->offsetvalue.value);
1384
1385         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1386         free_page(addr);
1387         return ret;
1388 }
1389
1390 static ssize_t libertas_rdmac_write(struct file *file,
1391                                     const char __user *userbuf,
1392                                     size_t count, loff_t *ppos)
1393 {
1394         wlan_private *priv = file->private_data;
1395         ssize_t res, buf_size;
1396         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1397         char *buf = (char *)addr;
1398
1399         buf_size = min(count, len - 1);
1400         if (copy_from_user(buf, userbuf, buf_size)) {
1401                 res = -EFAULT;
1402                 goto out_unlock;
1403         }
1404         priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
1405         res = count;
1406 out_unlock:
1407         free_page(addr);
1408         return res;
1409 }
1410
1411 static ssize_t libertas_wrmac_write(struct file *file,
1412                                     const char __user *userbuf,
1413                                     size_t count, loff_t *ppos)
1414 {
1415
1416         wlan_private *priv = file->private_data;
1417         ssize_t res, buf_size;
1418         u32 offset, value;
1419         struct wlan_offset_value offval;
1420         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1421         char *buf = (char *)addr;
1422
1423         buf_size = min(count, len - 1);
1424         if (copy_from_user(buf, userbuf, buf_size)) {
1425                 res = -EFAULT;
1426                 goto out_unlock;
1427         }
1428         res = sscanf(buf, "%x %x", &offset, &value);
1429         if (res != 2) {
1430                 res = -EFAULT;
1431                 goto out_unlock;
1432         }
1433
1434         offval.offset = offset;
1435         offval.value = value;
1436         res = libertas_prepare_and_send_command(priv,
1437                                 CMD_MAC_REG_ACCESS, 1,
1438                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1439         mdelay(10);
1440
1441         res = count;
1442 out_unlock:
1443         free_page(addr);
1444         return res;
1445 }
1446
1447 static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1448                                   size_t count, loff_t *ppos)
1449 {
1450         wlan_private *priv = file->private_data;
1451         wlan_adapter *adapter = priv->adapter;
1452         struct wlan_offset_value offval;
1453         ssize_t pos = 0;
1454         int ret;
1455         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1456         char *buf = (char *)addr;
1457
1458         offval.offset = priv->bbp_offset;
1459         offval.value = 0;
1460
1461         ret = libertas_prepare_and_send_command(priv,
1462                                 CMD_BBP_REG_ACCESS, 0,
1463                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1464         mdelay(10);
1465         pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
1466                                 priv->bbp_offset, adapter->offsetvalue.value);
1467
1468         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1469         free_page(addr);
1470
1471         return ret;
1472 }
1473
1474 static ssize_t libertas_rdbbp_write(struct file *file,
1475                                     const char __user *userbuf,
1476                                     size_t count, loff_t *ppos)
1477 {
1478         wlan_private *priv = file->private_data;
1479         ssize_t res, buf_size;
1480         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1481         char *buf = (char *)addr;
1482
1483         buf_size = min(count, len - 1);
1484         if (copy_from_user(buf, userbuf, buf_size)) {
1485                 res = -EFAULT;
1486                 goto out_unlock;
1487         }
1488         priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
1489         res = count;
1490 out_unlock:
1491         free_page(addr);
1492         return res;
1493 }
1494
1495 static ssize_t libertas_wrbbp_write(struct file *file,
1496                                     const char __user *userbuf,
1497                                     size_t count, loff_t *ppos)
1498 {
1499
1500         wlan_private *priv = file->private_data;
1501         ssize_t res, buf_size;
1502         u32 offset, value;
1503         struct wlan_offset_value offval;
1504         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1505         char *buf = (char *)addr;
1506
1507         buf_size = min(count, len - 1);
1508         if (copy_from_user(buf, userbuf, buf_size)) {
1509                 res = -EFAULT;
1510                 goto out_unlock;
1511         }
1512         res = sscanf(buf, "%x %x", &offset, &value);
1513         if (res != 2) {
1514                 res = -EFAULT;
1515                 goto out_unlock;
1516         }
1517
1518         offval.offset = offset;
1519         offval.value = value;
1520         res = libertas_prepare_and_send_command(priv,
1521                                 CMD_BBP_REG_ACCESS, 1,
1522                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1523         mdelay(10);
1524
1525         res = count;
1526 out_unlock:
1527         free_page(addr);
1528         return res;
1529 }
1530
1531 static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1532                                   size_t count, loff_t *ppos)
1533 {
1534         wlan_private *priv = file->private_data;
1535         wlan_adapter *adapter = priv->adapter;
1536         struct wlan_offset_value offval;
1537         ssize_t pos = 0;
1538         int ret;
1539         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1540         char *buf = (char *)addr;
1541
1542         offval.offset = priv->rf_offset;
1543         offval.value = 0;
1544
1545         ret = libertas_prepare_and_send_command(priv,
1546                                 CMD_RF_REG_ACCESS, 0,
1547                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1548         mdelay(10);
1549         pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
1550                                 priv->rf_offset, adapter->offsetvalue.value);
1551
1552         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1553         free_page(addr);
1554
1555         return ret;
1556 }
1557
1558 static ssize_t libertas_rdrf_write(struct file *file,
1559                                     const char __user *userbuf,
1560                                     size_t count, loff_t *ppos)
1561 {
1562         wlan_private *priv = file->private_data;
1563         ssize_t res, buf_size;
1564         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1565         char *buf = (char *)addr;
1566
1567         buf_size = min(count, len - 1);
1568         if (copy_from_user(buf, userbuf, buf_size)) {
1569                 res = -EFAULT;
1570                 goto out_unlock;
1571         }
1572         priv->rf_offset = simple_strtoul((char *)buf, NULL, 16);
1573         res = count;
1574 out_unlock:
1575         free_page(addr);
1576         return res;
1577 }
1578
1579 static ssize_t libertas_wrrf_write(struct file *file,
1580                                     const char __user *userbuf,
1581                                     size_t count, loff_t *ppos)
1582 {
1583
1584         wlan_private *priv = file->private_data;
1585         ssize_t res, buf_size;
1586         u32 offset, value;
1587         struct wlan_offset_value offval;
1588         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1589         char *buf = (char *)addr;
1590
1591         buf_size = min(count, len - 1);
1592         if (copy_from_user(buf, userbuf, buf_size)) {
1593                 res = -EFAULT;
1594                 goto out_unlock;
1595         }
1596         res = sscanf(buf, "%x %x", &offset, &value);
1597         if (res != 2) {
1598                 res = -EFAULT;
1599                 goto out_unlock;
1600         }
1601
1602         offval.offset = offset;
1603         offval.value = value;
1604         res = libertas_prepare_and_send_command(priv,
1605                                 CMD_RF_REG_ACCESS, 1,
1606                                 CMD_OPTION_WAITFORRSP, 0, &offval);
1607         mdelay(10);
1608
1609         res = count;
1610 out_unlock:
1611         free_page(addr);
1612         return res;
1613 }
1614
1615 #define FOPS(fread, fwrite) { \
1616         .owner = THIS_MODULE, \
1617         .open = open_file_generic, \
1618         .read = (fread), \
1619         .write = (fwrite), \
1620 }
1621
1622 struct libertas_debugfs_files {
1623         char *name;
1624         int perm;
1625         struct file_operations fops;
1626 };
1627
1628 static struct libertas_debugfs_files debugfs_files[] = {
1629         { "info", 0444, FOPS(libertas_dev_info, write_file_dummy), },
1630         { "getscantable", 0444, FOPS(libertas_getscantable,
1631                                         write_file_dummy), },
1632         { "sleepparams", 0644, FOPS(libertas_sleepparams_read,
1633                                 libertas_sleepparams_write), },
1634         { "extscan", 0600, FOPS(NULL, libertas_extscan), },
1635         { "setuserscan", 0600, FOPS(NULL, libertas_setuserscan), },
1636 };
1637
1638 static struct libertas_debugfs_files debugfs_events_files[] = {
1639         {"low_rssi", 0644, FOPS(libertas_lowrssi_read,
1640                                 libertas_lowrssi_write), },
1641         {"low_snr", 0644, FOPS(libertas_lowsnr_read,
1642                                 libertas_lowsnr_write), },
1643         {"failure_count", 0644, FOPS(libertas_failcount_read,
1644                                 libertas_failcount_write), },
1645         {"beacon_missed", 0644, FOPS(libertas_bcnmiss_read,
1646                                 libertas_bcnmiss_write), },
1647         {"high_rssi", 0644, FOPS(libertas_highrssi_read,
1648                                 libertas_highrssi_write), },
1649         {"high_snr", 0644, FOPS(libertas_highsnr_read,
1650                                 libertas_highsnr_write), },
1651 };
1652
1653 static struct libertas_debugfs_files debugfs_regs_files[] = {
1654         {"rdmac", 0644, FOPS(libertas_rdmac_read, libertas_rdmac_write), },
1655         {"wrmac", 0600, FOPS(NULL, libertas_wrmac_write), },
1656         {"rdbbp", 0644, FOPS(libertas_rdbbp_read, libertas_rdbbp_write), },
1657         {"wrbbp", 0600, FOPS(NULL, libertas_wrbbp_write), },
1658         {"rdrf", 0644, FOPS(libertas_rdrf_read, libertas_rdrf_write), },
1659         {"wrrf", 0600, FOPS(NULL, libertas_wrrf_write), },
1660 };
1661
1662 void libertas_debugfs_init(void)
1663 {
1664         if (!libertas_dir)
1665                 libertas_dir = debugfs_create_dir("libertas_wireless", NULL);
1666
1667         return;
1668 }
1669
1670 void libertas_debugfs_remove(void)
1671 {
1672         if (libertas_dir)
1673                  debugfs_remove(libertas_dir);
1674         return;
1675 }
1676
1677 void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev)
1678 {
1679         int i;
1680         struct libertas_debugfs_files *files;
1681         if (!libertas_dir)
1682                 goto exit;
1683
1684         priv->debugfs_dir = debugfs_create_dir(dev->name, libertas_dir);
1685         if (!priv->debugfs_dir)
1686                 goto exit;
1687
1688         for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
1689                 files = &debugfs_files[i];
1690                 priv->debugfs_files[i] = debugfs_create_file(files->name,
1691                                                              files->perm,
1692                                                              priv->debugfs_dir,
1693                                                              priv,
1694                                                              &files->fops);
1695         }
1696
1697         priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
1698         if (!priv->events_dir)
1699                 goto exit;
1700
1701         for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
1702                 files = &debugfs_events_files[i];
1703                 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
1704                                                              files->perm,
1705                                                              priv->events_dir,
1706                                                              priv,
1707                                                              &files->fops);
1708         }
1709
1710         priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
1711         if (!priv->regs_dir)
1712                 goto exit;
1713
1714         for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
1715                 files = &debugfs_regs_files[i];
1716                 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
1717                                                              files->perm,
1718                                                              priv->regs_dir,
1719                                                              priv,
1720                                                              &files->fops);
1721         }
1722
1723 #ifdef PROC_DEBUG
1724         libertas_debug_init(priv, dev);
1725 #endif
1726 exit:
1727         return;
1728 }
1729
1730 void libertas_debugfs_remove_one(wlan_private *priv)
1731 {
1732         int i;
1733
1734         for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
1735                 debugfs_remove(priv->debugfs_regs_files[i]);
1736
1737         debugfs_remove(priv->regs_dir);
1738
1739         for(i=0; i<ARRAY_SIZE(debugfs_events_files); i++)
1740                 debugfs_remove(priv->debugfs_events_files[i]);
1741
1742         debugfs_remove(priv->events_dir);
1743 #ifdef PROC_DEBUG
1744         debugfs_remove(priv->debugfs_debug);
1745 #endif
1746         for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
1747                 debugfs_remove(priv->debugfs_files[i]);
1748         debugfs_remove(priv->debugfs_dir);
1749 }
1750
1751
1752
1753 /* debug entry */
1754
1755 #ifdef PROC_DEBUG
1756
1757 #define item_size(n)    (FIELD_SIZEOF(wlan_adapter, n))
1758 #define item_addr(n)    (offsetof(wlan_adapter, n))
1759
1760
1761 struct debug_data {
1762         char name[32];
1763         u32 size;
1764         size_t addr;
1765 };
1766
1767 /* To debug any member of wlan_adapter, simply add one line here.
1768  */
1769 static struct debug_data items[] = {
1770         {"intcounter", item_size(intcounter), item_addr(intcounter)},
1771         {"psmode", item_size(psmode), item_addr(psmode)},
1772         {"psstate", item_size(psstate), item_addr(psstate)},
1773 };
1774
1775 static int num_of_items = ARRAY_SIZE(items);
1776
1777 /**
1778  *  @brief proc read function
1779  *
1780  *  @param page    pointer to buffer
1781  *  @param s       read data starting position
1782  *  @param off     offset
1783  *  @param cnt     counter
1784  *  @param eof     end of file flag
1785  *  @param data    data to output
1786  *  @return        number of output data
1787  */
1788 static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf,
1789                         size_t count, loff_t *ppos)
1790 {
1791         int val = 0;
1792         size_t pos = 0;
1793         ssize_t res;
1794         char *p;
1795         int i;
1796         struct debug_data *d;
1797         unsigned long addr = get_zeroed_page(GFP_KERNEL);
1798         char *buf = (char *)addr;
1799
1800         p = buf;
1801
1802         d = (struct debug_data *)file->private_data;
1803
1804         for (i = 0; i < num_of_items; i++) {
1805                 if (d[i].size == 1)
1806                         val = *((u8 *) d[i].addr);
1807                 else if (d[i].size == 2)
1808                         val = *((u16 *) d[i].addr);
1809                 else if (d[i].size == 4)
1810                         val = *((u32 *) d[i].addr);
1811                 else if (d[i].size == 8)
1812                         val = *((u64 *) d[i].addr);
1813
1814                 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
1815         }
1816
1817         res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
1818
1819         free_page(addr);
1820         return res;
1821 }
1822
1823 /**
1824  *  @brief proc write function
1825  *
1826  *  @param f       file pointer
1827  *  @param buf     pointer to data buffer
1828  *  @param cnt     data number to write
1829  *  @param data    data to write
1830  *  @return        number of data
1831  */
1832 static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf,
1833                             size_t cnt, loff_t *ppos)
1834 {
1835         int r, i;
1836         char *pdata;
1837         char *p;
1838         char *p0;
1839         char *p1;
1840         char *p2;
1841         struct debug_data *d = (struct debug_data *)f->private_data;
1842
1843         pdata = kmalloc(cnt, GFP_KERNEL);
1844         if (pdata == NULL)
1845                 return 0;
1846
1847         if (copy_from_user(pdata, buf, cnt)) {
1848                 lbs_deb_debugfs("Copy from user failed\n");
1849                 kfree(pdata);
1850                 return 0;
1851         }
1852
1853         p0 = pdata;
1854         for (i = 0; i < num_of_items; i++) {
1855                 do {
1856                         p = strstr(p0, d[i].name);
1857                         if (p == NULL)
1858                                 break;
1859                         p1 = strchr(p, '\n');
1860                         if (p1 == NULL)
1861                                 break;
1862                         p0 = p1++;
1863                         p2 = strchr(p, '=');
1864                         if (!p2)
1865                                 break;
1866                         p2++;
1867                         r = simple_strtoul(p2, NULL, 0);
1868                         if (d[i].size == 1)
1869                                 *((u8 *) d[i].addr) = (u8) r;
1870                         else if (d[i].size == 2)
1871                                 *((u16 *) d[i].addr) = (u16) r;
1872                         else if (d[i].size == 4)
1873                                 *((u32 *) d[i].addr) = (u32) r;
1874                         else if (d[i].size == 8)
1875                                 *((u64 *) d[i].addr) = (u64) r;
1876                         break;
1877                 } while (1);
1878         }
1879         kfree(pdata);
1880
1881         return (ssize_t)cnt;
1882 }
1883
1884 static struct file_operations libertas_debug_fops = {
1885         .owner = THIS_MODULE,
1886         .open = open_file_generic,
1887         .write = wlan_debugfs_write,
1888         .read = wlan_debugfs_read,
1889 };
1890
1891 /**
1892  *  @brief create debug proc file
1893  *
1894  *  @param priv    pointer wlan_private
1895  *  @param dev     pointer net_device
1896  *  @return        N/A
1897  */
1898 static void libertas_debug_init(wlan_private * priv, struct net_device *dev)
1899 {
1900         int i;
1901
1902         if (!priv->debugfs_dir)
1903                 return;
1904
1905         for (i = 0; i < num_of_items; i++)
1906                 items[i].addr += (size_t) priv->adapter;
1907
1908         priv->debugfs_debug = debugfs_create_file("debug", 0644,
1909                                                   priv->debugfs_dir, &items[0],
1910                                                   &libertas_debug_fops);
1911 }
1912 #endif
1913