1 #include <linux/module.h>
2 #include <linux/dcache.h>
3 #include <linux/debugfs.h>
4 #include <linux/delay.h>
6 #include <net/iw_handler.h>
12 static struct dentry *libertas_dir = NULL;
13 static char *szStates[] = {
18 void libertas_debug_init(wlan_private * priv, struct net_device *dev);
20 static int open_file_generic(struct inode *inode, struct file *file)
22 file->private_data = inode->i_private;
26 static ssize_t write_file_dummy(struct file *file, const char __user *buf,
27 size_t count, loff_t *ppos)
32 static const size_t len = PAGE_SIZE;
34 static ssize_t libertas_dev_info(struct file *file, char __user *userbuf,
35 size_t count, loff_t *ppos)
37 wlan_private *priv = file->private_data;
39 unsigned long addr = get_zeroed_page(GFP_KERNEL);
40 char *buf = (char *)addr;
43 pos += snprintf(buf+pos, len-pos, "state = %s\n",
44 szStates[priv->adapter->connect_status]);
45 pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
46 (u32) priv->adapter->regioncode);
48 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
55 static ssize_t libertas_getscantable(struct file *file, char __user *userbuf,
56 size_t count, loff_t *ppos)
58 wlan_private *priv = file->private_data;
60 int numscansdone = 0, res;
61 unsigned long addr = get_zeroed_page(GFP_KERNEL);
62 char *buf = (char *)addr;
64 pos += snprintf(buf+pos, len-pos,
65 "---------------------------------------");
66 pos += snprintf(buf+pos, len-pos,
67 "---------------------------------------\n");
68 pos += snprintf(buf+pos, len-pos,
69 "# | ch | ss | bssid | cap | TSF | Qual | SSID \n");
70 pos += snprintf(buf+pos, len-pos,
71 "---------------------------------------");
72 pos += snprintf(buf+pos, len-pos,
73 "---------------------------------------\n");
75 while (numscansdone < priv->adapter->numinscantable) {
76 struct bss_descriptor *pbssinfo;
79 pbssinfo = &priv->adapter->scantable[numscansdone];
80 memcpy(&cap, &pbssinfo->cap, sizeof(cap));
81 pos += snprintf(buf+pos, len-pos,
82 "%02u| %03d | %03ld | %02x:%02x:%02x:%02x:%02x:%02x |",
83 numscansdone, pbssinfo->channel, pbssinfo->rssi,
84 pbssinfo->macaddress[0], pbssinfo->macaddress[1],
85 pbssinfo->macaddress[2], pbssinfo->macaddress[3],
86 pbssinfo->macaddress[4], pbssinfo->macaddress[5]);
87 pos += snprintf(buf+pos, len-pos, " %04x-", cap);
88 pos += snprintf(buf+pos, len-pos, "%c%c%c |",
89 pbssinfo->cap.ibss ? 'A' : 'I',
90 pbssinfo->cap.privacy ? 'P' : ' ',
91 pbssinfo->cap.spectrummgmt ? 'S' : ' ');
92 pos += snprintf(buf+pos, len-pos, " %08llx |", pbssinfo->networktsf);
93 pos += snprintf(buf+pos, len-pos, " %d |",
94 SCAN_RSSI(priv->adapter->scantable[numscansdone].rssi));
96 pos += snprintf(buf+pos, len-pos, " %s\n", pbssinfo->ssid.ssid);
101 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
107 static ssize_t libertas_sleepparams_write(struct file *file,
108 const char __user *user_buf, size_t count,
111 wlan_private *priv = file->private_data;
112 ssize_t buf_size, res;
113 int p1, p2, p3, p4, p5, p6;
114 struct sleep_params sp;
115 unsigned long addr = get_zeroed_page(GFP_KERNEL);
116 char *buf = (char *)addr;
118 buf_size = min(count, len - 1);
119 if (copy_from_user(buf, user_buf, buf_size)) {
123 res = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6);
130 sp.sp_stabletime = p3;
131 sp.sp_calcontrol = p4;
132 sp.sp_extsleepclk = p5;
135 memcpy(&priv->adapter->sp, &sp, sizeof(struct sleep_params));
137 res = libertas_prepare_and_send_command(priv,
138 cmd_802_11_sleep_params,
140 cmd_option_waitforrsp, 0, NULL);
152 static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf,
153 size_t count, loff_t *ppos)
155 wlan_private *priv = file->private_data;
156 wlan_adapter *adapter = priv->adapter;
159 unsigned long addr = get_zeroed_page(GFP_KERNEL);
160 char *buf = (char *)addr;
162 res = libertas_prepare_and_send_command(priv,
163 cmd_802_11_sleep_params,
165 cmd_option_waitforrsp, 0, NULL);
171 pos += snprintf(buf, len, "%d %d %d %d %d %d\n", adapter->sp.sp_error,
172 adapter->sp.sp_offset, adapter->sp.sp_stabletime,
173 adapter->sp.sp_calcontrol, adapter->sp.sp_extsleepclk,
174 adapter->sp.sp_reserved);
176 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
183 static ssize_t libertas_extscan(struct file *file, const char __user *userbuf,
184 size_t count, loff_t *ppos)
186 wlan_private *priv = file->private_data;
187 ssize_t res, buf_size;
188 struct WLAN_802_11_SSID extscan_ssid;
189 union iwreq_data wrqu;
190 unsigned long addr = get_zeroed_page(GFP_KERNEL);
191 char *buf = (char *)addr;
193 buf_size = min(count, len - 1);
194 if (copy_from_user(buf, userbuf, buf_size)) {
199 memcpy(&extscan_ssid.ssid, buf, strlen(buf)-1);
200 extscan_ssid.ssidlength = strlen(buf)-1;
202 libertas_send_specific_SSID_scan(priv, &extscan_ssid, 1);
204 memset(&wrqu, 0, sizeof(union iwreq_data));
205 wireless_send_event(priv->wlan_dev.netdev, SIOCGIWSCAN, &wrqu, NULL);
212 static int libertas_parse_chan(char *buf, size_t count,
213 struct wlan_ioctl_user_scan_cfg *scan_cfg, int dur)
215 char *start, *end, *hold, *str;
218 start = strstr(buf, "chan=");
222 end = strstr(start, " ");
225 hold = kzalloc((end - start)+1, GFP_KERNEL);
228 strncpy(hold, start, end - start);
229 hold[(end-start)+1] = '\0';
230 while(hold && (str = strsep(&hold, ","))) {
232 char band, passive = 0;
233 sscanf(str, "%d%c%c", &chan, &band, &passive);
234 scan_cfg->chanlist[i].channumber = chan;
235 scan_cfg->chanlist[i].scantype = passive ? 1 : 0;
236 if (band == 'b' || band == 'g')
237 scan_cfg->chanlist[i].radiotype = 0;
238 else if (band == 'a')
239 scan_cfg->chanlist[i].radiotype = 1;
241 scan_cfg->chanlist[i].scantime = dur;
249 static void libertas_parse_bssid(char *buf, size_t count,
250 struct wlan_ioctl_user_scan_cfg *scan_cfg)
253 unsigned int mac[ETH_ALEN];
256 hold = strstr(buf, "bssid=");
260 sscanf(hold, "%2x:%2x:%2x:%2x:%2x:%2x", mac, mac+1, mac+2, mac+3,
262 for(i=0;i<ETH_ALEN;i++)
263 scan_cfg->specificBSSID[i] = mac[i];
266 static void libertas_parse_ssid(char *buf, size_t count,
267 struct wlan_ioctl_user_scan_cfg *scan_cfg)
272 hold = strstr(buf, "ssid=");
276 end = strstr(hold, " ");
278 end = buf + count - 1;
280 size = min((size_t)IW_ESSID_MAX_SIZE, (size_t) (end - hold));
281 strncpy(scan_cfg->specificSSID, hold, size);
286 static void libertas_parse_keep(char *buf, size_t count,
287 struct wlan_ioctl_user_scan_cfg *scan_cfg)
292 hold = strstr(buf, "keep=");
296 sscanf(hold, "%d", &val);
301 scan_cfg->keeppreviousscan = val;
305 static int libertas_parse_dur(char *buf, size_t count,
306 struct wlan_ioctl_user_scan_cfg *scan_cfg)
311 hold = strstr(buf, "dur=");
315 sscanf(hold, "%d", &val);
320 static void libertas_parse_probes(char *buf, size_t count,
321 struct wlan_ioctl_user_scan_cfg *scan_cfg)
326 hold = strstr(buf, "probes=");
330 sscanf(hold, "%d", &val);
332 scan_cfg->numprobes = val;
337 static void libertas_parse_type(char *buf, size_t count,
338 struct wlan_ioctl_user_scan_cfg *scan_cfg)
343 hold = strstr(buf, "type=");
347 sscanf(hold, "%d", &val);
350 if (val < 1 || val > 3)
353 scan_cfg->bsstype = val;
358 static ssize_t libertas_setuserscan(struct file *file,
359 const char __user *userbuf,
360 size_t count, loff_t *ppos)
362 wlan_private *priv = file->private_data;
363 ssize_t res, buf_size;
364 struct wlan_ioctl_user_scan_cfg *scan_cfg;
365 union iwreq_data wrqu;
367 unsigned long addr = get_zeroed_page(GFP_KERNEL);
368 char *buf = (char *)addr;
370 scan_cfg = kzalloc(sizeof(struct wlan_ioctl_user_scan_cfg), GFP_KERNEL);
374 buf_size = min(count, len - 1);
375 if (copy_from_user(buf, userbuf, buf_size)) {
380 scan_cfg->bsstype = WLAN_SCAN_BSS_TYPE_ANY;
382 dur = libertas_parse_dur(buf, count, scan_cfg);
383 libertas_parse_chan(buf, count, scan_cfg, dur);
384 libertas_parse_bssid(buf, count, scan_cfg);
385 libertas_parse_ssid(buf, count, scan_cfg);
386 libertas_parse_keep(buf, count, scan_cfg);
387 libertas_parse_probes(buf, count, scan_cfg);
388 libertas_parse_type(buf, count, scan_cfg);
390 wlan_scan_networks(priv, scan_cfg);
391 wait_event_interruptible(priv->adapter->cmd_pending,
392 !priv->adapter->nr_cmd_pending);
394 memset(&wrqu, 0x00, sizeof(union iwreq_data));
395 wireless_send_event(priv->wlan_dev.netdev, SIOCGIWSCAN, &wrqu, NULL);
403 static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
404 struct cmd_ctrl_node **cmdnode,
405 struct cmd_ds_command **cmd)
407 u16 wait_option = cmd_option_waitforrsp;
409 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
410 lbs_pr_debug(1, "failed libertas_get_free_cmd_ctrl_node\n");
413 if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) {
414 lbs_pr_debug(1, "failed to allocate response buffer!\n");
417 libertas_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL);
418 init_waitqueue_head(&(*cmdnode)->cmdwait_q);
419 (*cmdnode)->pdata_buf = *response_buf;
420 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
421 (*cmdnode)->cmdwaitqwoken = 0;
422 *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
423 (*cmd)->command = cmd_802_11_subscribe_event;
424 (*cmd)->seqnum = ++priv->adapter->seqnum;
429 static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
430 size_t count, loff_t *ppos)
432 wlan_private *priv = file->private_data;
433 wlan_adapter *adapter = priv->adapter;
434 struct cmd_ctrl_node *pcmdnode;
435 struct cmd_ds_command *pcmdptr;
436 struct cmd_ds_802_11_subscribe_event *event;
440 unsigned long addr = get_zeroed_page(GFP_KERNEL);
441 char *buf = (char *)addr;
443 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
449 event = &pcmdptr->params.subscribe_event;
450 event->action = cmd_act_get;
452 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
453 libertas_queue_cmd(adapter, pcmdnode, 1);
454 wake_up_interruptible(&priv->mainthread.waitq);
456 /* Sleep until response is generated by FW */
457 wait_event_interruptible(pcmdnode->cmdwait_q,
458 pcmdnode->cmdwaitqwoken);
460 pcmdptr = response_buf;
461 if (pcmdptr->result) {
462 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
469 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
470 lbs_pr_err("command response incorrect!\n");
476 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
477 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
478 while (cmd_len < pcmdptr->size) {
479 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
480 switch(header->type) {
481 struct mrvlietypes_rssithreshold *Lowrssi;
482 case TLV_TYPE_RSSI_LOW:
483 Lowrssi = (struct mrvlietypes_rssithreshold *)(response_buf + cmd_len);
484 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
487 (event->events & 0x0001)?1:0);
489 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
495 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
500 static u16 libertas_get_events_bitmap(wlan_private *priv)
502 wlan_adapter *adapter = priv->adapter;
503 struct cmd_ctrl_node *pcmdnode;
504 struct cmd_ds_command *pcmdptr;
505 struct cmd_ds_802_11_subscribe_event *event;
510 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
514 event = &pcmdptr->params.subscribe_event;
515 event->action = cmd_act_get;
517 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
518 libertas_queue_cmd(adapter, pcmdnode, 1);
519 wake_up_interruptible(&priv->mainthread.waitq);
521 /* Sleep until response is generated by FW */
522 wait_event_interruptible(pcmdnode->cmdwait_q,
523 pcmdnode->cmdwaitqwoken);
525 pcmdptr = response_buf;
527 if (pcmdptr->result) {
528 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
534 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
535 lbs_pr_err("command response incorrect!\n");
540 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
541 event_bitmap = event->events;
546 static ssize_t libertas_lowrssi_write(struct file *file,
547 const char __user *userbuf,
548 size_t count, loff_t *ppos)
550 wlan_private *priv = file->private_data;
551 wlan_adapter *adapter = priv->adapter;
552 ssize_t res, buf_size;
553 int value, freq, subscribed, cmd_len;
554 struct cmd_ctrl_node *pcmdnode;
555 struct cmd_ds_command *pcmdptr;
556 struct cmd_ds_802_11_subscribe_event *event;
557 struct mrvlietypes_rssithreshold *rssi_threshold;
561 unsigned long addr = get_zeroed_page(GFP_KERNEL);
562 char *buf = (char *)addr;
564 buf_size = min(count, len - 1);
565 if (copy_from_user(buf, userbuf, buf_size)) {
569 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
575 event_bitmap = libertas_get_events_bitmap(priv);
577 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
581 event = &pcmdptr->params.subscribe_event;
582 event->action = cmd_act_set;
583 pcmdptr->size = cpu_to_le16(S_DS_GEN +
584 sizeof(struct cmd_ds_802_11_subscribe_event) +
585 sizeof(struct mrvlietypes_rssithreshold));
587 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
588 ptr = (u8*) pcmdptr+cmd_len;
589 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
590 rssi_threshold->header.type = cpu_to_le16(0x0104);
591 rssi_threshold->header.len = 2;
592 rssi_threshold->rssivalue = cpu_to_le16(value);
593 rssi_threshold->rssifreq = cpu_to_le16(freq);
594 event_bitmap |= subscribed ? 0x0001 : 0x0;
595 event->events = event_bitmap;
597 libertas_queue_cmd(adapter, pcmdnode, 1);
598 wake_up_interruptible(&priv->mainthread.waitq);
600 /* Sleep until response is generated by FW */
601 wait_event_interruptible(pcmdnode->cmdwait_q,
602 pcmdnode->cmdwaitqwoken);
604 pcmdptr = response_buf;
606 if (pcmdptr->result) {
607 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
614 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
615 lbs_pr_err("command response incorrect!\n");
627 static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
628 size_t count, loff_t *ppos)
630 wlan_private *priv = file->private_data;
631 wlan_adapter *adapter = priv->adapter;
632 struct cmd_ctrl_node *pcmdnode;
633 struct cmd_ds_command *pcmdptr;
634 struct cmd_ds_802_11_subscribe_event *event;
638 unsigned long addr = get_zeroed_page(GFP_KERNEL);
639 char *buf = (char *)addr;
641 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
647 event = &pcmdptr->params.subscribe_event;
648 event->action = cmd_act_get;
650 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
651 libertas_queue_cmd(adapter, pcmdnode, 1);
652 wake_up_interruptible(&priv->mainthread.waitq);
654 /* Sleep until response is generated by FW */
655 wait_event_interruptible(pcmdnode->cmdwait_q,
656 pcmdnode->cmdwaitqwoken);
658 pcmdptr = response_buf;
660 if (pcmdptr->result) {
661 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
668 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
669 lbs_pr_err("command response incorrect!\n");
675 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
676 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
677 while (cmd_len < pcmdptr->size) {
678 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
679 switch(header->type) {
680 struct mrvlietypes_snrthreshold *LowSnr;
681 case TLV_TYPE_SNR_LOW:
682 LowSnr = (struct mrvlietypes_snrthreshold *)(response_buf + cmd_len);
683 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
686 (event->events & 0x0002)?1:0);
688 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
695 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
700 static ssize_t libertas_lowsnr_write(struct file *file,
701 const char __user *userbuf,
702 size_t count, loff_t *ppos)
704 wlan_private *priv = file->private_data;
705 wlan_adapter *adapter = priv->adapter;
706 ssize_t res, buf_size;
707 int value, freq, subscribed, cmd_len;
708 struct cmd_ctrl_node *pcmdnode;
709 struct cmd_ds_command *pcmdptr;
710 struct cmd_ds_802_11_subscribe_event *event;
711 struct mrvlietypes_snrthreshold *snr_threshold;
715 unsigned long addr = get_zeroed_page(GFP_KERNEL);
716 char *buf = (char *)addr;
718 buf_size = min(count, len - 1);
719 if (copy_from_user(buf, userbuf, buf_size)) {
723 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
729 event_bitmap = libertas_get_events_bitmap(priv);
731 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
735 event = &pcmdptr->params.subscribe_event;
736 event->action = cmd_act_set;
737 pcmdptr->size = cpu_to_le16(S_DS_GEN +
738 sizeof(struct cmd_ds_802_11_subscribe_event) +
739 sizeof(struct mrvlietypes_snrthreshold));
740 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
741 ptr = (u8*) pcmdptr+cmd_len;
742 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
743 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_LOW);
744 snr_threshold->header.len = 2;
745 snr_threshold->snrvalue = cpu_to_le16(value);
746 snr_threshold->snrfreq = cpu_to_le16(freq);
747 event_bitmap |= subscribed ? 0x0002 : 0x0;
748 event->events = event_bitmap;
750 libertas_queue_cmd(adapter, pcmdnode, 1);
751 wake_up_interruptible(&priv->mainthread.waitq);
753 /* Sleep until response is generated by FW */
754 wait_event_interruptible(pcmdnode->cmdwait_q,
755 pcmdnode->cmdwaitqwoken);
757 pcmdptr = response_buf;
759 if (pcmdptr->result) {
760 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
767 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
768 lbs_pr_err("command response incorrect!\n");
781 static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
782 size_t count, loff_t *ppos)
784 wlan_private *priv = file->private_data;
785 wlan_adapter *adapter = priv->adapter;
786 struct cmd_ctrl_node *pcmdnode;
787 struct cmd_ds_command *pcmdptr;
788 struct cmd_ds_802_11_subscribe_event *event;
792 unsigned long addr = get_zeroed_page(GFP_KERNEL);
793 char *buf = (char *)addr;
795 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
801 event = &pcmdptr->params.subscribe_event;
802 event->action = cmd_act_get;
804 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
805 libertas_queue_cmd(adapter, pcmdnode, 1);
806 wake_up_interruptible(&priv->mainthread.waitq);
808 /* Sleep until response is generated by FW */
809 wait_event_interruptible(pcmdnode->cmdwait_q,
810 pcmdnode->cmdwaitqwoken);
812 pcmdptr = response_buf;
814 if (pcmdptr->result) {
815 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
822 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
823 lbs_pr_err("command response incorrect!\n");
829 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
830 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
831 while (cmd_len < pcmdptr->size) {
832 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
833 switch(header->type) {
834 struct mrvlietypes_failurecount *failcount;
835 case TLV_TYPE_FAILCOUNT:
836 failcount = (struct mrvlietypes_failurecount *)(response_buf + cmd_len);
837 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
838 failcount->failvalue,
840 (event->events & 0x0004)?1:0);
842 cmd_len += sizeof(struct mrvlietypes_failurecount);
848 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
853 static ssize_t libertas_failcount_write(struct file *file,
854 const char __user *userbuf,
855 size_t count, loff_t *ppos)
857 wlan_private *priv = file->private_data;
858 wlan_adapter *adapter = priv->adapter;
859 ssize_t res, buf_size;
860 int value, freq, subscribed, cmd_len;
861 struct cmd_ctrl_node *pcmdnode;
862 struct cmd_ds_command *pcmdptr;
863 struct cmd_ds_802_11_subscribe_event *event;
864 struct mrvlietypes_failurecount *failcount;
868 unsigned long addr = get_zeroed_page(GFP_KERNEL);
869 char *buf = (char *)addr;
871 buf_size = min(count, len - 1);
872 if (copy_from_user(buf, userbuf, buf_size)) {
876 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
882 event_bitmap = libertas_get_events_bitmap(priv);
884 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
888 event = &pcmdptr->params.subscribe_event;
889 event->action = cmd_act_set;
890 pcmdptr->size = cpu_to_le16(S_DS_GEN +
891 sizeof(struct cmd_ds_802_11_subscribe_event) +
892 sizeof(struct mrvlietypes_failurecount));
893 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
894 ptr = (u8*) pcmdptr+cmd_len;
895 failcount = (struct mrvlietypes_failurecount *)(ptr);
896 failcount->header.type = cpu_to_le16(TLV_TYPE_FAILCOUNT);
897 failcount->header.len = 2;
898 failcount->failvalue = cpu_to_le16(value);
899 failcount->Failfreq = cpu_to_le16(freq);
900 event_bitmap |= subscribed ? 0x0004 : 0x0;
901 event->events = event_bitmap;
903 libertas_queue_cmd(adapter, pcmdnode, 1);
904 wake_up_interruptible(&priv->mainthread.waitq);
906 /* Sleep until response is generated by FW */
907 wait_event_interruptible(pcmdnode->cmdwait_q,
908 pcmdnode->cmdwaitqwoken);
910 pcmdptr = (struct cmd_ds_command *)response_buf;
912 if (pcmdptr->result) {
913 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
920 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
921 lbs_pr_err("command response incorrect!\n");
933 static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
934 size_t count, loff_t *ppos)
936 wlan_private *priv = file->private_data;
937 wlan_adapter *adapter = priv->adapter;
938 struct cmd_ctrl_node *pcmdnode;
939 struct cmd_ds_command *pcmdptr;
940 struct cmd_ds_802_11_subscribe_event *event;
944 unsigned long addr = get_zeroed_page(GFP_KERNEL);
945 char *buf = (char *)addr;
947 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
953 event = &pcmdptr->params.subscribe_event;
954 event->action = cmd_act_get;
956 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
957 libertas_queue_cmd(adapter, pcmdnode, 1);
958 wake_up_interruptible(&priv->mainthread.waitq);
960 /* Sleep until response is generated by FW */
961 wait_event_interruptible(pcmdnode->cmdwait_q,
962 pcmdnode->cmdwaitqwoken);
964 pcmdptr = response_buf;
966 if (pcmdptr->result) {
967 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
974 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
975 lbs_pr_err("command response incorrect!\n");
981 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
982 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
983 while (cmd_len < pcmdptr->size) {
984 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
985 switch(header->type) {
986 struct mrvlietypes_beaconsmissed *bcnmiss;
987 case TLV_TYPE_BCNMISS:
988 bcnmiss = (struct mrvlietypes_beaconsmissed *)(response_buf + cmd_len);
989 pos += snprintf(buf+pos, len-pos, "%d N/A %d\n",
990 bcnmiss->beaconmissed,
991 (event->events & 0x0008)?1:0);
993 cmd_len += sizeof(struct mrvlietypes_beaconsmissed);
1000 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1005 static ssize_t libertas_bcnmiss_write(struct file *file,
1006 const char __user *userbuf,
1007 size_t count, loff_t *ppos)
1009 wlan_private *priv = file->private_data;
1010 wlan_adapter *adapter = priv->adapter;
1011 ssize_t res, buf_size;
1012 int value, freq, subscribed, cmd_len;
1013 struct cmd_ctrl_node *pcmdnode;
1014 struct cmd_ds_command *pcmdptr;
1015 struct cmd_ds_802_11_subscribe_event *event;
1016 struct mrvlietypes_beaconsmissed *bcnmiss;
1020 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1021 char *buf = (char *)addr;
1023 buf_size = min(count, len - 1);
1024 if (copy_from_user(buf, userbuf, buf_size)) {
1028 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1034 event_bitmap = libertas_get_events_bitmap(priv);
1036 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1040 event = &pcmdptr->params.subscribe_event;
1041 event->action = cmd_act_set;
1042 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1043 sizeof(struct cmd_ds_802_11_subscribe_event) +
1044 sizeof(struct mrvlietypes_beaconsmissed));
1045 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1046 ptr = (u8*) pcmdptr+cmd_len;
1047 bcnmiss = (struct mrvlietypes_beaconsmissed *)(ptr);
1048 bcnmiss->header.type = cpu_to_le16(TLV_TYPE_BCNMISS);
1049 bcnmiss->header.len = 2;
1050 bcnmiss->beaconmissed = cpu_to_le16(value);
1051 event_bitmap |= subscribed ? 0x0008 : 0x0;
1052 event->events = event_bitmap;
1054 libertas_queue_cmd(adapter, pcmdnode, 1);
1055 wake_up_interruptible(&priv->mainthread.waitq);
1057 /* Sleep until response is generated by FW */
1058 wait_event_interruptible(pcmdnode->cmdwait_q,
1059 pcmdnode->cmdwaitqwoken);
1061 pcmdptr = response_buf;
1063 if (pcmdptr->result) {
1064 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
1066 kfree(response_buf);
1071 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
1072 lbs_pr_err("command response incorrect!\n");
1074 kfree(response_buf);
1084 static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1085 size_t count, loff_t *ppos)
1087 wlan_private *priv = file->private_data;
1088 wlan_adapter *adapter = priv->adapter;
1089 struct cmd_ctrl_node *pcmdnode;
1090 struct cmd_ds_command *pcmdptr;
1091 struct cmd_ds_802_11_subscribe_event *event;
1095 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1096 char *buf = (char *)addr;
1098 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1104 event = &pcmdptr->params.subscribe_event;
1105 event->action = cmd_act_get;
1107 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
1108 libertas_queue_cmd(adapter, pcmdnode, 1);
1109 wake_up_interruptible(&priv->mainthread.waitq);
1111 /* Sleep until response is generated by FW */
1112 wait_event_interruptible(pcmdnode->cmdwait_q,
1113 pcmdnode->cmdwaitqwoken);
1115 pcmdptr = response_buf;
1117 if (pcmdptr->result) {
1118 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
1120 kfree(response_buf);
1125 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
1126 lbs_pr_err("command response incorrect!\n");
1127 kfree(response_buf);
1132 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1133 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
1134 while (cmd_len < pcmdptr->size) {
1135 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
1136 switch(header->type) {
1137 struct mrvlietypes_rssithreshold *Highrssi;
1138 case TLV_TYPE_RSSI_HIGH:
1139 Highrssi = (struct mrvlietypes_rssithreshold *)(response_buf + cmd_len);
1140 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1141 Highrssi->rssivalue,
1143 (event->events & 0x0010)?1:0);
1145 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1150 kfree(response_buf);
1152 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1157 static ssize_t libertas_highrssi_write(struct file *file,
1158 const char __user *userbuf,
1159 size_t count, loff_t *ppos)
1161 wlan_private *priv = file->private_data;
1162 wlan_adapter *adapter = priv->adapter;
1163 ssize_t res, buf_size;
1164 int value, freq, subscribed, cmd_len;
1165 struct cmd_ctrl_node *pcmdnode;
1166 struct cmd_ds_command *pcmdptr;
1167 struct cmd_ds_802_11_subscribe_event *event;
1168 struct mrvlietypes_rssithreshold *rssi_threshold;
1172 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1173 char *buf = (char *)addr;
1175 buf_size = min(count, len - 1);
1176 if (copy_from_user(buf, userbuf, buf_size)) {
1180 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1186 event_bitmap = libertas_get_events_bitmap(priv);
1188 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1192 event = &pcmdptr->params.subscribe_event;
1193 event->action = cmd_act_set;
1194 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1195 sizeof(struct cmd_ds_802_11_subscribe_event) +
1196 sizeof(struct mrvlietypes_rssithreshold));
1197 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1198 ptr = (u8*) pcmdptr+cmd_len;
1199 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
1200 rssi_threshold->header.type = cpu_to_le16(TLV_TYPE_RSSI_HIGH);
1201 rssi_threshold->header.len = 2;
1202 rssi_threshold->rssivalue = cpu_to_le16(value);
1203 rssi_threshold->rssifreq = cpu_to_le16(freq);
1204 event_bitmap |= subscribed ? 0x0010 : 0x0;
1205 event->events = event_bitmap;
1207 libertas_queue_cmd(adapter, pcmdnode, 1);
1208 wake_up_interruptible(&priv->mainthread.waitq);
1210 /* Sleep until response is generated by FW */
1211 wait_event_interruptible(pcmdnode->cmdwait_q,
1212 pcmdnode->cmdwaitqwoken);
1214 pcmdptr = response_buf;
1216 if (pcmdptr->result) {
1217 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
1219 kfree(response_buf);
1223 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
1224 lbs_pr_err("command response incorrect!\n");
1225 kfree(response_buf);
1235 static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1236 size_t count, loff_t *ppos)
1238 wlan_private *priv = file->private_data;
1239 wlan_adapter *adapter = priv->adapter;
1240 struct cmd_ctrl_node *pcmdnode;
1241 struct cmd_ds_command *pcmdptr;
1242 struct cmd_ds_802_11_subscribe_event *event;
1246 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1247 char *buf = (char *)addr;
1249 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1255 event = &pcmdptr->params.subscribe_event;
1256 event->action = cmd_act_get;
1258 cpu_to_le16(sizeof(struct cmd_ds_802_11_subscribe_event) + S_DS_GEN);
1259 libertas_queue_cmd(adapter, pcmdnode, 1);
1260 wake_up_interruptible(&priv->mainthread.waitq);
1262 /* Sleep until response is generated by FW */
1263 wait_event_interruptible(pcmdnode->cmdwait_q,
1264 pcmdnode->cmdwaitqwoken);
1266 pcmdptr = response_buf;
1268 if (pcmdptr->result) {
1269 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
1271 kfree(response_buf);
1276 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
1277 lbs_pr_err("command response incorrect!\n");
1278 kfree(response_buf);
1283 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1284 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
1285 while (cmd_len < pcmdptr->size) {
1286 struct mrvlietypesheader *header = (struct mrvlietypesheader *)(response_buf + cmd_len);
1287 switch(header->type) {
1288 struct mrvlietypes_snrthreshold *HighSnr;
1289 case TLV_TYPE_SNR_HIGH:
1290 HighSnr = (struct mrvlietypes_snrthreshold *)(response_buf + cmd_len);
1291 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1294 (event->events & 0x0020)?1:0);
1296 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1301 kfree(response_buf);
1303 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1308 static ssize_t libertas_highsnr_write(struct file *file,
1309 const char __user *userbuf,
1310 size_t count, loff_t *ppos)
1312 wlan_private *priv = file->private_data;
1313 wlan_adapter *adapter = priv->adapter;
1314 ssize_t res, buf_size;
1315 int value, freq, subscribed, cmd_len;
1316 struct cmd_ctrl_node *pcmdnode;
1317 struct cmd_ds_command *pcmdptr;
1318 struct cmd_ds_802_11_subscribe_event *event;
1319 struct mrvlietypes_snrthreshold *snr_threshold;
1323 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1324 char *buf = (char *)addr;
1326 buf_size = min(count, len - 1);
1327 if (copy_from_user(buf, userbuf, buf_size)) {
1331 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1337 event_bitmap = libertas_get_events_bitmap(priv);
1339 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1343 event = &pcmdptr->params.subscribe_event;
1344 event->action = cmd_act_set;
1345 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1346 sizeof(struct cmd_ds_802_11_subscribe_event) +
1347 sizeof(struct mrvlietypes_snrthreshold));
1348 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1349 ptr = (u8*) pcmdptr+cmd_len;
1350 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
1351 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_HIGH);
1352 snr_threshold->header.len = 2;
1353 snr_threshold->snrvalue = cpu_to_le16(value);
1354 snr_threshold->snrfreq = cpu_to_le16(freq);
1355 event_bitmap |= subscribed ? 0x0020 : 0x0;
1356 event->events = event_bitmap;
1358 libertas_queue_cmd(adapter, pcmdnode, 1);
1359 wake_up_interruptible(&priv->mainthread.waitq);
1361 /* Sleep until response is generated by FW */
1362 wait_event_interruptible(pcmdnode->cmdwait_q,
1363 pcmdnode->cmdwaitqwoken);
1365 pcmdptr = response_buf;
1367 if (pcmdptr->result) {
1368 lbs_pr_err("%s: fail, result=%d\n", __FUNCTION__,
1370 kfree(response_buf);
1375 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
1376 lbs_pr_err("command response incorrect!\n");
1377 kfree(response_buf);
1388 static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1389 size_t count, loff_t *ppos)
1391 wlan_private *priv = file->private_data;
1392 wlan_adapter *adapter = priv->adapter;
1393 struct wlan_offset_value offval;
1396 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1397 char *buf = (char *)addr;
1399 offval.offset = priv->mac_offset;
1402 ret = libertas_prepare_and_send_command(priv,
1403 cmd_mac_reg_access, 0,
1404 cmd_option_waitforrsp, 0, &offval);
1406 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
1407 priv->mac_offset, adapter->offsetvalue.value);
1409 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1414 static ssize_t libertas_rdmac_write(struct file *file,
1415 const char __user *userbuf,
1416 size_t count, loff_t *ppos)
1418 wlan_private *priv = file->private_data;
1419 ssize_t res, buf_size;
1420 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1421 char *buf = (char *)addr;
1423 buf_size = min(count, len - 1);
1424 if (copy_from_user(buf, userbuf, buf_size)) {
1428 priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
1435 static ssize_t libertas_wrmac_write(struct file *file,
1436 const char __user *userbuf,
1437 size_t count, loff_t *ppos)
1440 wlan_private *priv = file->private_data;
1441 ssize_t res, buf_size;
1443 struct wlan_offset_value offval;
1444 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1445 char *buf = (char *)addr;
1447 buf_size = min(count, len - 1);
1448 if (copy_from_user(buf, userbuf, buf_size)) {
1452 res = sscanf(buf, "%x %x", &offset, &value);
1458 offval.offset = offset;
1459 offval.value = value;
1460 res = libertas_prepare_and_send_command(priv,
1461 cmd_mac_reg_access, 1,
1462 cmd_option_waitforrsp, 0, &offval);
1471 static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1472 size_t count, loff_t *ppos)
1474 wlan_private *priv = file->private_data;
1475 wlan_adapter *adapter = priv->adapter;
1476 struct wlan_offset_value offval;
1479 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1480 char *buf = (char *)addr;
1482 offval.offset = priv->bbp_offset;
1485 ret = libertas_prepare_and_send_command(priv,
1486 cmd_bbp_reg_access, 0,
1487 cmd_option_waitforrsp, 0, &offval);
1489 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
1490 priv->bbp_offset, adapter->offsetvalue.value);
1492 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1498 static ssize_t libertas_rdbbp_write(struct file *file,
1499 const char __user *userbuf,
1500 size_t count, loff_t *ppos)
1502 wlan_private *priv = file->private_data;
1503 ssize_t res, buf_size;
1504 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1505 char *buf = (char *)addr;
1507 buf_size = min(count, len - 1);
1508 if (copy_from_user(buf, userbuf, buf_size)) {
1512 priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
1519 static ssize_t libertas_wrbbp_write(struct file *file,
1520 const char __user *userbuf,
1521 size_t count, loff_t *ppos)
1524 wlan_private *priv = file->private_data;
1525 ssize_t res, buf_size;
1527 struct wlan_offset_value offval;
1528 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1529 char *buf = (char *)addr;
1531 buf_size = min(count, len - 1);
1532 if (copy_from_user(buf, userbuf, buf_size)) {
1536 res = sscanf(buf, "%x %x", &offset, &value);
1542 offval.offset = offset;
1543 offval.value = value;
1544 res = libertas_prepare_and_send_command(priv,
1545 cmd_bbp_reg_access, 1,
1546 cmd_option_waitforrsp, 0, &offval);
1555 static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1556 size_t count, loff_t *ppos)
1558 wlan_private *priv = file->private_data;
1559 wlan_adapter *adapter = priv->adapter;
1560 struct wlan_offset_value offval;
1563 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1564 char *buf = (char *)addr;
1566 offval.offset = priv->rf_offset;
1569 ret = libertas_prepare_and_send_command(priv,
1570 cmd_rf_reg_access, 0,
1571 cmd_option_waitforrsp, 0, &offval);
1573 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
1574 priv->rf_offset, adapter->offsetvalue.value);
1576 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1582 static ssize_t libertas_rdrf_write(struct file *file,
1583 const char __user *userbuf,
1584 size_t count, loff_t *ppos)
1586 wlan_private *priv = file->private_data;
1587 ssize_t res, buf_size;
1588 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1589 char *buf = (char *)addr;
1591 buf_size = min(count, len - 1);
1592 if (copy_from_user(buf, userbuf, buf_size)) {
1596 priv->rf_offset = simple_strtoul((char *)buf, NULL, 16);
1603 static ssize_t libertas_wrrf_write(struct file *file,
1604 const char __user *userbuf,
1605 size_t count, loff_t *ppos)
1608 wlan_private *priv = file->private_data;
1609 ssize_t res, buf_size;
1611 struct wlan_offset_value offval;
1612 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1613 char *buf = (char *)addr;
1615 buf_size = min(count, len - 1);
1616 if (copy_from_user(buf, userbuf, buf_size)) {
1620 res = sscanf(buf, "%x %x", &offset, &value);
1626 offval.offset = offset;
1627 offval.value = value;
1628 res = libertas_prepare_and_send_command(priv,
1629 cmd_rf_reg_access, 1,
1630 cmd_option_waitforrsp, 0, &offval);
1639 #define FOPS(fread, fwrite) { \
1640 .owner = THIS_MODULE, \
1641 .open = open_file_generic, \
1643 .write = (fwrite), \
1646 struct libertas_debugfs_files {
1649 struct file_operations fops;
1652 static struct libertas_debugfs_files debugfs_files[] = {
1653 { "info", 0444, FOPS(libertas_dev_info, write_file_dummy), },
1654 { "getscantable", 0444, FOPS(libertas_getscantable,
1655 write_file_dummy), },
1656 { "sleepparams", 0644, FOPS(libertas_sleepparams_read,
1657 libertas_sleepparams_write), },
1658 { "extscan", 0600, FOPS(NULL, libertas_extscan), },
1659 { "setuserscan", 0600, FOPS(NULL, libertas_setuserscan), },
1662 static struct libertas_debugfs_files debugfs_events_files[] = {
1663 {"low_rssi", 0644, FOPS(libertas_lowrssi_read,
1664 libertas_lowrssi_write), },
1665 {"low_snr", 0644, FOPS(libertas_lowsnr_read,
1666 libertas_lowsnr_write), },
1667 {"failure_count", 0644, FOPS(libertas_failcount_read,
1668 libertas_failcount_write), },
1669 {"beacon_missed", 0644, FOPS(libertas_bcnmiss_read,
1670 libertas_bcnmiss_write), },
1671 {"high_rssi", 0644, FOPS(libertas_highrssi_read,
1672 libertas_highrssi_write), },
1673 {"high_snr", 0644, FOPS(libertas_highsnr_read,
1674 libertas_highsnr_write), },
1677 static struct libertas_debugfs_files debugfs_regs_files[] = {
1678 {"rdmac", 0644, FOPS(libertas_rdmac_read, libertas_rdmac_write), },
1679 {"wrmac", 0600, FOPS(NULL, libertas_wrmac_write), },
1680 {"rdbbp", 0644, FOPS(libertas_rdbbp_read, libertas_rdbbp_write), },
1681 {"wrbbp", 0600, FOPS(NULL, libertas_wrbbp_write), },
1682 {"rdrf", 0644, FOPS(libertas_rdrf_read, libertas_rdrf_write), },
1683 {"wrrf", 0600, FOPS(NULL, libertas_wrrf_write), },
1686 void libertas_debugfs_init(void)
1689 libertas_dir = debugfs_create_dir("libertas_wireless", NULL);
1694 void libertas_debugfs_remove(void)
1697 debugfs_remove(libertas_dir);
1701 void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev)
1704 struct libertas_debugfs_files *files;
1708 priv->debugfs_dir = debugfs_create_dir(dev->name, libertas_dir);
1709 if (!priv->debugfs_dir)
1712 for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
1713 files = &debugfs_files[i];
1714 priv->debugfs_files[i] = debugfs_create_file(files->name,
1721 priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
1722 if (!priv->events_dir)
1725 for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
1726 files = &debugfs_events_files[i];
1727 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
1734 priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
1735 if (!priv->regs_dir)
1738 for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
1739 files = &debugfs_regs_files[i];
1740 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
1748 libertas_debug_init(priv, dev);
1754 void libertas_debugfs_remove_one(wlan_private *priv)
1758 for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
1759 debugfs_remove(priv->debugfs_regs_files[i]);
1761 debugfs_remove(priv->regs_dir);
1763 for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
1764 debugfs_remove(priv->debugfs_events_files[i]);
1766 debugfs_remove(priv->events_dir);
1768 debugfs_remove(priv->debugfs_debug);
1770 for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
1771 debugfs_remove(priv->debugfs_files[i]);
1776 #define item_size(n) (FIELD_SIZEOF(wlan_adapter, n))
1777 #define item_addr(n) (offsetof(wlan_adapter, n))
1785 /* To debug any member of wlan_adapter, simply add one line here.
1787 static struct debug_data items[] = {
1788 {"intcounter", item_size(intcounter), item_addr(intcounter)},
1789 {"psmode", item_size(psmode), item_addr(psmode)},
1790 {"psstate", item_size(psstate), item_addr(psstate)},
1793 static int num_of_items = ARRAY_SIZE(items);
1796 * @brief proc read function
1798 * @param page pointer to buffer
1799 * @param s read data starting position
1801 * @param cnt counter
1802 * @param eof end of file flag
1803 * @param data data to output
1804 * @return number of output data
1806 static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf,
1807 size_t count, loff_t *ppos)
1814 struct debug_data *d;
1815 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1816 char *buf = (char *)addr;
1820 d = (struct debug_data *)file->private_data;
1822 for (i = 0; i < num_of_items; i++) {
1824 val = *((u8 *) d[i].addr);
1825 else if (d[i].size == 2)
1826 val = *((u16 *) d[i].addr);
1827 else if (d[i].size == 4)
1828 val = *((u32 *) d[i].addr);
1829 else if (d[i].size == 8)
1830 val = *((u64 *) d[i].addr);
1832 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
1835 res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
1842 * @brief proc write function
1844 * @param f file pointer
1845 * @param buf pointer to data buffer
1846 * @param cnt data number to write
1847 * @param data data to write
1848 * @return number of data
1850 static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf,
1851 size_t cnt, loff_t *ppos)
1859 struct debug_data *d = (struct debug_data *)f->private_data;
1861 pdata = (char *)kmalloc(cnt, GFP_KERNEL);
1865 if (copy_from_user(pdata, buf, cnt)) {
1866 lbs_pr_debug(1, "Copy from user failed\n");
1872 for (i = 0; i < num_of_items; i++) {
1874 p = strstr(p0, d[i].name);
1877 p1 = strchr(p, '\n');
1881 p2 = strchr(p, '=');
1885 r = simple_strtoul(p2, NULL, 0);
1887 *((u8 *) d[i].addr) = (u8) r;
1888 else if (d[i].size == 2)
1889 *((u16 *) d[i].addr) = (u16) r;
1890 else if (d[i].size == 4)
1891 *((u32 *) d[i].addr) = (u32) r;
1892 else if (d[i].size == 8)
1893 *((u64 *) d[i].addr) = (u64) r;
1899 return (ssize_t)cnt;
1902 static struct file_operations libertas_debug_fops = {
1903 .owner = THIS_MODULE,
1904 .open = open_file_generic,
1905 .write = wlan_debugfs_write,
1906 .read = wlan_debugfs_read,
1910 * @brief create debug proc file
1912 * @param priv pointer wlan_private
1913 * @param dev pointer net_device
1916 void libertas_debug_init(wlan_private * priv, struct net_device *dev)
1920 if (!priv->debugfs_dir)
1923 for (i = 0; i < num_of_items; i++)
1924 items[i].addr += (size_t) priv->adapter;
1926 priv->debugfs_debug = debugfs_create_file("debug", 0644,
1927 priv->debugfs_dir, &items[0],
1928 &libertas_debug_fops);