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>
13 static struct dentry *libertas_dir = NULL;
14 static char *szStates[] = {
20 static void libertas_debug_init(wlan_private * priv, struct net_device *dev);
23 static int open_file_generic(struct inode *inode, struct file *file)
25 file->private_data = inode->i_private;
29 static ssize_t write_file_dummy(struct file *file, const char __user *buf,
30 size_t count, loff_t *ppos)
35 static const size_t len = PAGE_SIZE;
37 static ssize_t libertas_dev_info(struct file *file, char __user *userbuf,
38 size_t count, loff_t *ppos)
40 wlan_private *priv = file->private_data;
42 unsigned long addr = get_zeroed_page(GFP_KERNEL);
43 char *buf = (char *)addr;
46 pos += snprintf(buf+pos, len-pos, "state = %s\n",
47 szStates[priv->adapter->connect_status]);
48 pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
49 (u32) priv->adapter->regioncode);
51 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
58 static ssize_t libertas_getscantable(struct file *file, char __user *userbuf,
59 size_t count, loff_t *ppos)
61 wlan_private *priv = file->private_data;
63 int numscansdone = 0, res;
64 unsigned long addr = get_zeroed_page(GFP_KERNEL);
65 char *buf = (char *)addr;
66 struct bss_descriptor * iter_bss;
68 pos += snprintf(buf+pos, len-pos,
69 "# | ch | rssi | bssid | cap | Qual | SSID \n");
71 mutex_lock(&priv->adapter->lock);
72 list_for_each_entry (iter_bss, &priv->adapter->network_list, list) {
73 u16 ibss = (iter_bss->capability & WLAN_CAPABILITY_IBSS);
74 u16 privacy = (iter_bss->capability & WLAN_CAPABILITY_PRIVACY);
75 u16 spectrum_mgmt = (iter_bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT);
77 pos += snprintf(buf+pos, len-pos,
78 "%02u| %03d | %04ld | " MAC_FMT " |",
79 numscansdone, iter_bss->channel, iter_bss->rssi,
80 MAC_ARG(iter_bss->bssid));
81 pos += snprintf(buf+pos, len-pos, " %04x-", iter_bss->capability);
82 pos += snprintf(buf+pos, len-pos, "%c%c%c |",
83 ibss ? 'A' : 'I', privacy ? 'P' : ' ',
84 spectrum_mgmt ? 'S' : ' ');
85 pos += snprintf(buf+pos, len-pos, " %04d |", SCAN_RSSI(iter_bss->rssi));
86 pos += snprintf(buf+pos, len-pos, " %s\n",
87 escape_essid(iter_bss->ssid, iter_bss->ssid_len));
91 mutex_unlock(&priv->adapter->lock);
93 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
99 static ssize_t libertas_sleepparams_write(struct file *file,
100 const char __user *user_buf, size_t count,
103 wlan_private *priv = file->private_data;
104 ssize_t buf_size, res;
105 int p1, p2, p3, p4, p5, p6;
106 unsigned long addr = get_zeroed_page(GFP_KERNEL);
107 char *buf = (char *)addr;
109 buf_size = min(count, len - 1);
110 if (copy_from_user(buf, user_buf, buf_size)) {
114 res = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6);
119 priv->adapter->sp.sp_error = p1;
120 priv->adapter->sp.sp_offset = p2;
121 priv->adapter->sp.sp_stabletime = p3;
122 priv->adapter->sp.sp_calcontrol = p4;
123 priv->adapter->sp.sp_extsleepclk = p5;
124 priv->adapter->sp.sp_reserved = p6;
126 res = libertas_prepare_and_send_command(priv,
127 CMD_802_11_SLEEP_PARAMS,
129 CMD_OPTION_WAITFORRSP, 0, NULL);
141 static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf,
142 size_t count, loff_t *ppos)
144 wlan_private *priv = file->private_data;
145 wlan_adapter *adapter = priv->adapter;
148 unsigned long addr = get_zeroed_page(GFP_KERNEL);
149 char *buf = (char *)addr;
151 res = libertas_prepare_and_send_command(priv,
152 CMD_802_11_SLEEP_PARAMS,
154 CMD_OPTION_WAITFORRSP, 0, NULL);
160 pos += snprintf(buf, len, "%d %d %d %d %d %d\n", adapter->sp.sp_error,
161 adapter->sp.sp_offset, adapter->sp.sp_stabletime,
162 adapter->sp.sp_calcontrol, adapter->sp.sp_extsleepclk,
163 adapter->sp.sp_reserved);
165 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
172 static ssize_t libertas_extscan(struct file *file, const char __user *userbuf,
173 size_t count, loff_t *ppos)
175 wlan_private *priv = file->private_data;
176 ssize_t res, buf_size;
177 union iwreq_data wrqu;
178 unsigned long addr = get_zeroed_page(GFP_KERNEL);
179 char *buf = (char *)addr;
181 buf_size = min(count, len - 1);
182 if (copy_from_user(buf, userbuf, buf_size)) {
187 libertas_send_specific_ssid_scan(priv, buf, strlen(buf)-1, 0);
189 memset(&wrqu, 0, sizeof(union iwreq_data));
190 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
197 static int libertas_parse_chan(char *buf, size_t count,
198 struct wlan_ioctl_user_scan_cfg *scan_cfg, int dur)
200 char *start, *end, *hold, *str;
203 start = strstr(buf, "chan=");
207 end = strstr(start, " ");
210 hold = kzalloc((end - start)+1, GFP_KERNEL);
213 strncpy(hold, start, end - start);
214 hold[(end-start)+1] = '\0';
215 while(hold && (str = strsep(&hold, ","))) {
217 char band, passive = 0;
218 sscanf(str, "%d%c%c", &chan, &band, &passive);
219 scan_cfg->chanlist[i].channumber = chan;
220 scan_cfg->chanlist[i].scantype = passive ? 1 : 0;
221 if (band == 'b' || band == 'g')
222 scan_cfg->chanlist[i].radiotype = 0;
223 else if (band == 'a')
224 scan_cfg->chanlist[i].radiotype = 1;
226 scan_cfg->chanlist[i].scantime = dur;
234 static void libertas_parse_bssid(char *buf, size_t count,
235 struct wlan_ioctl_user_scan_cfg *scan_cfg)
238 unsigned int mac[ETH_ALEN];
240 hold = strstr(buf, "bssid=");
244 sscanf(hold, MAC_FMT, mac, mac+1, mac+2, mac+3, mac+4, mac+5);
245 memcpy(scan_cfg->bssid, mac, ETH_ALEN);
248 static void libertas_parse_ssid(char *buf, size_t count,
249 struct wlan_ioctl_user_scan_cfg *scan_cfg)
254 hold = strstr(buf, "ssid=");
258 end = strstr(hold, " ");
260 end = buf + count - 1;
262 size = min((size_t)IW_ESSID_MAX_SIZE, (size_t) (end - hold));
263 strncpy(scan_cfg->ssid, hold, size);
268 static int libertas_parse_clear(char *buf, size_t count, const char *tag)
273 hold = strstr(buf, tag);
277 sscanf(hold, "%d", &val);
285 static int libertas_parse_dur(char *buf, size_t count,
286 struct wlan_ioctl_user_scan_cfg *scan_cfg)
291 hold = strstr(buf, "dur=");
295 sscanf(hold, "%d", &val);
300 static void libertas_parse_probes(char *buf, size_t count,
301 struct wlan_ioctl_user_scan_cfg *scan_cfg)
306 hold = strstr(buf, "probes=");
310 sscanf(hold, "%d", &val);
312 scan_cfg->numprobes = val;
317 static void libertas_parse_type(char *buf, size_t count,
318 struct wlan_ioctl_user_scan_cfg *scan_cfg)
323 hold = strstr(buf, "type=");
327 sscanf(hold, "%d", &val);
330 if (val < 1 || val > 3)
333 scan_cfg->bsstype = val;
338 static ssize_t libertas_setuserscan(struct file *file,
339 const char __user *userbuf,
340 size_t count, loff_t *ppos)
342 wlan_private *priv = file->private_data;
343 ssize_t res, buf_size;
344 struct wlan_ioctl_user_scan_cfg *scan_cfg;
345 union iwreq_data wrqu;
347 unsigned long addr = get_zeroed_page(GFP_KERNEL);
348 char *buf = (char *)addr;
350 scan_cfg = kzalloc(sizeof(struct wlan_ioctl_user_scan_cfg), GFP_KERNEL);
354 buf_size = min(count, len - 1);
355 if (copy_from_user(buf, userbuf, buf_size)) {
360 scan_cfg->bsstype = WLAN_SCAN_BSS_TYPE_ANY;
362 dur = libertas_parse_dur(buf, count, scan_cfg);
363 libertas_parse_chan(buf, count, scan_cfg, dur);
364 libertas_parse_bssid(buf, count, scan_cfg);
365 scan_cfg->clear_bssid = libertas_parse_clear(buf, count, "clear_bssid=");
366 libertas_parse_ssid(buf, count, scan_cfg);
367 scan_cfg->clear_ssid = libertas_parse_clear(buf, count, "clear_ssid=");
368 libertas_parse_probes(buf, count, scan_cfg);
369 libertas_parse_type(buf, count, scan_cfg);
371 wlan_scan_networks(priv, scan_cfg, 1);
372 wait_event_interruptible(priv->adapter->cmd_pending,
373 !priv->adapter->nr_cmd_pending);
375 memset(&wrqu, 0x00, sizeof(union iwreq_data));
376 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
384 static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
385 struct cmd_ctrl_node **cmdnode,
386 struct cmd_ds_command **cmd)
388 u16 wait_option = CMD_OPTION_WAITFORRSP;
390 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
391 lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
394 if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) {
395 lbs_deb_debugfs("failed to allocate response buffer!\n");
398 libertas_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL);
399 init_waitqueue_head(&(*cmdnode)->cmdwait_q);
400 (*cmdnode)->pdata_buf = *response_buf;
401 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
402 (*cmdnode)->cmdwaitqwoken = 0;
403 *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
404 (*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);
405 (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
410 static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
411 size_t count, loff_t *ppos)
413 wlan_private *priv = file->private_data;
414 wlan_adapter *adapter = priv->adapter;
415 struct cmd_ctrl_node *pcmdnode;
416 struct cmd_ds_command *pcmdptr;
417 struct cmd_ds_802_11_subscribe_event *event;
421 unsigned long addr = get_zeroed_page(GFP_KERNEL);
422 char *buf = (char *)addr;
424 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
430 event = &pcmdptr->params.subscribe_event;
431 event->action = cpu_to_le16(CMD_ACT_GET);
432 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
433 libertas_queue_cmd(adapter, pcmdnode, 1);
434 wake_up_interruptible(&priv->waitq);
436 /* Sleep until response is generated by FW */
437 wait_event_interruptible(pcmdnode->cmdwait_q,
438 pcmdnode->cmdwaitqwoken);
440 pcmdptr = response_buf;
441 if (pcmdptr->result) {
442 lbs_pr_err("%s: fail, result=%d\n", __func__,
443 le16_to_cpu(pcmdptr->result));
449 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
450 lbs_pr_err("command response incorrect!\n");
456 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
457 event = (void *)(response_buf + S_DS_GEN);
458 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
459 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
460 switch (header->type) {
461 struct mrvlietypes_rssithreshold *Lowrssi;
462 case __constant_cpu_to_le16(TLV_TYPE_RSSI_LOW):
463 Lowrssi = (void *)(response_buf + cmd_len);
464 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
467 (event->events & cpu_to_le16(0x0001))?1:0);
469 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
475 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
480 static u16 libertas_get_events_bitmap(wlan_private *priv)
482 wlan_adapter *adapter = priv->adapter;
483 struct cmd_ctrl_node *pcmdnode;
484 struct cmd_ds_command *pcmdptr;
485 struct cmd_ds_802_11_subscribe_event *event;
490 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
494 event = &pcmdptr->params.subscribe_event;
495 event->action = cpu_to_le16(CMD_ACT_GET);
496 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
497 libertas_queue_cmd(adapter, pcmdnode, 1);
498 wake_up_interruptible(&priv->waitq);
500 /* Sleep until response is generated by FW */
501 wait_event_interruptible(pcmdnode->cmdwait_q,
502 pcmdnode->cmdwaitqwoken);
504 pcmdptr = response_buf;
506 if (pcmdptr->result) {
507 lbs_pr_err("%s: fail, result=%d\n", __func__,
508 le16_to_cpu(pcmdptr->result));
513 if (le16_to_cpu(pcmdptr->command) != CMD_RET(CMD_802_11_SUBSCRIBE_EVENT)) {
514 lbs_pr_err("command response incorrect!\n");
519 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
520 event_bitmap = le16_to_cpu(event->events);
525 static ssize_t libertas_lowrssi_write(struct file *file,
526 const char __user *userbuf,
527 size_t count, loff_t *ppos)
529 wlan_private *priv = file->private_data;
530 wlan_adapter *adapter = priv->adapter;
531 ssize_t res, buf_size;
532 int value, freq, subscribed, cmd_len;
533 struct cmd_ctrl_node *pcmdnode;
534 struct cmd_ds_command *pcmdptr;
535 struct cmd_ds_802_11_subscribe_event *event;
536 struct mrvlietypes_rssithreshold *rssi_threshold;
540 unsigned long addr = get_zeroed_page(GFP_KERNEL);
541 char *buf = (char *)addr;
543 buf_size = min(count, len - 1);
544 if (copy_from_user(buf, userbuf, buf_size)) {
548 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
554 event_bitmap = libertas_get_events_bitmap(priv);
556 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
560 event = &pcmdptr->params.subscribe_event;
561 event->action = cpu_to_le16(CMD_ACT_SET);
562 pcmdptr->size = cpu_to_le16(S_DS_GEN +
563 sizeof(struct cmd_ds_802_11_subscribe_event) +
564 sizeof(struct mrvlietypes_rssithreshold));
566 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
567 ptr = (u8*) pcmdptr+cmd_len;
568 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
569 rssi_threshold->header.type = cpu_to_le16(0x0104);
570 rssi_threshold->header.len = cpu_to_le16(2);
571 rssi_threshold->rssivalue = value;
572 rssi_threshold->rssifreq = freq;
573 event_bitmap |= subscribed ? 0x0001 : 0x0;
574 event->events = cpu_to_le16(event_bitmap);
576 libertas_queue_cmd(adapter, pcmdnode, 1);
577 wake_up_interruptible(&priv->waitq);
579 /* Sleep until response is generated by FW */
580 wait_event_interruptible(pcmdnode->cmdwait_q,
581 pcmdnode->cmdwaitqwoken);
583 pcmdptr = response_buf;
585 if (pcmdptr->result) {
586 lbs_pr_err("%s: fail, result=%d\n", __func__,
587 le16_to_cpu(pcmdptr->result));
593 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
594 lbs_pr_err("command response incorrect!\n");
606 static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
607 size_t count, loff_t *ppos)
609 wlan_private *priv = file->private_data;
610 wlan_adapter *adapter = priv->adapter;
611 struct cmd_ctrl_node *pcmdnode;
612 struct cmd_ds_command *pcmdptr;
613 struct cmd_ds_802_11_subscribe_event *event;
617 unsigned long addr = get_zeroed_page(GFP_KERNEL);
618 char *buf = (char *)addr;
620 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
626 event = &pcmdptr->params.subscribe_event;
627 event->action = cpu_to_le16(CMD_ACT_GET);
628 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
629 libertas_queue_cmd(adapter, pcmdnode, 1);
630 wake_up_interruptible(&priv->waitq);
632 /* Sleep until response is generated by FW */
633 wait_event_interruptible(pcmdnode->cmdwait_q,
634 pcmdnode->cmdwaitqwoken);
636 pcmdptr = response_buf;
638 if (pcmdptr->result) {
639 lbs_pr_err("%s: fail, result=%d\n", __func__,
640 le16_to_cpu(pcmdptr->result));
646 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
647 lbs_pr_err("command response incorrect!\n");
653 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
654 event = (void *)(response_buf + S_DS_GEN);
655 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
656 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
657 switch (header->type) {
658 struct mrvlietypes_snrthreshold *LowSnr;
659 case __constant_cpu_to_le16(TLV_TYPE_SNR_LOW):
660 LowSnr = (void *)(response_buf + cmd_len);
661 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
664 (event->events & cpu_to_le16(0x0002))?1:0);
666 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
673 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
678 static ssize_t libertas_lowsnr_write(struct file *file,
679 const char __user *userbuf,
680 size_t count, loff_t *ppos)
682 wlan_private *priv = file->private_data;
683 wlan_adapter *adapter = priv->adapter;
684 ssize_t res, buf_size;
685 int value, freq, subscribed, cmd_len;
686 struct cmd_ctrl_node *pcmdnode;
687 struct cmd_ds_command *pcmdptr;
688 struct cmd_ds_802_11_subscribe_event *event;
689 struct mrvlietypes_snrthreshold *snr_threshold;
693 unsigned long addr = get_zeroed_page(GFP_KERNEL);
694 char *buf = (char *)addr;
696 buf_size = min(count, len - 1);
697 if (copy_from_user(buf, userbuf, buf_size)) {
701 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
707 event_bitmap = libertas_get_events_bitmap(priv);
709 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
713 event = &pcmdptr->params.subscribe_event;
714 event->action = cpu_to_le16(CMD_ACT_SET);
715 pcmdptr->size = cpu_to_le16(S_DS_GEN +
716 sizeof(struct cmd_ds_802_11_subscribe_event) +
717 sizeof(struct mrvlietypes_snrthreshold));
718 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
719 ptr = (u8*) pcmdptr+cmd_len;
720 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
721 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_LOW);
722 snr_threshold->header.len = cpu_to_le16(2);
723 snr_threshold->snrvalue = value;
724 snr_threshold->snrfreq = freq;
725 event_bitmap |= subscribed ? 0x0002 : 0x0;
726 event->events = cpu_to_le16(event_bitmap);
728 libertas_queue_cmd(adapter, pcmdnode, 1);
729 wake_up_interruptible(&priv->waitq);
731 /* Sleep until response is generated by FW */
732 wait_event_interruptible(pcmdnode->cmdwait_q,
733 pcmdnode->cmdwaitqwoken);
735 pcmdptr = response_buf;
737 if (pcmdptr->result) {
738 lbs_pr_err("%s: fail, result=%d\n", __func__,
739 le16_to_cpu(pcmdptr->result));
745 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
746 lbs_pr_err("command response incorrect!\n");
759 static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
760 size_t count, loff_t *ppos)
762 wlan_private *priv = file->private_data;
763 wlan_adapter *adapter = priv->adapter;
764 struct cmd_ctrl_node *pcmdnode;
765 struct cmd_ds_command *pcmdptr;
766 struct cmd_ds_802_11_subscribe_event *event;
770 unsigned long addr = get_zeroed_page(GFP_KERNEL);
771 char *buf = (char *)addr;
773 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
779 event = &pcmdptr->params.subscribe_event;
780 event->action = cpu_to_le16(CMD_ACT_GET);
781 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
782 libertas_queue_cmd(adapter, pcmdnode, 1);
783 wake_up_interruptible(&priv->waitq);
785 /* Sleep until response is generated by FW */
786 wait_event_interruptible(pcmdnode->cmdwait_q,
787 pcmdnode->cmdwaitqwoken);
789 pcmdptr = response_buf;
791 if (pcmdptr->result) {
792 lbs_pr_err("%s: fail, result=%d\n", __func__,
793 le16_to_cpu(pcmdptr->result));
799 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
800 lbs_pr_err("command response incorrect!\n");
806 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
807 event = (void *)(response_buf + S_DS_GEN);
808 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
809 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
810 switch (header->type) {
811 struct mrvlietypes_failurecount *failcount;
812 case __constant_cpu_to_le16(TLV_TYPE_FAILCOUNT):
813 failcount = (void *)(response_buf + cmd_len);
814 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
815 failcount->failvalue,
817 (event->events & cpu_to_le16(0x0004))?1:0);
819 cmd_len += sizeof(struct mrvlietypes_failurecount);
825 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
830 static ssize_t libertas_failcount_write(struct file *file,
831 const char __user *userbuf,
832 size_t count, loff_t *ppos)
834 wlan_private *priv = file->private_data;
835 wlan_adapter *adapter = priv->adapter;
836 ssize_t res, buf_size;
837 int value, freq, subscribed, cmd_len;
838 struct cmd_ctrl_node *pcmdnode;
839 struct cmd_ds_command *pcmdptr;
840 struct cmd_ds_802_11_subscribe_event *event;
841 struct mrvlietypes_failurecount *failcount;
845 unsigned long addr = get_zeroed_page(GFP_KERNEL);
846 char *buf = (char *)addr;
848 buf_size = min(count, len - 1);
849 if (copy_from_user(buf, userbuf, buf_size)) {
853 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
859 event_bitmap = libertas_get_events_bitmap(priv);
861 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
865 event = &pcmdptr->params.subscribe_event;
866 event->action = cpu_to_le16(CMD_ACT_SET);
867 pcmdptr->size = cpu_to_le16(S_DS_GEN +
868 sizeof(struct cmd_ds_802_11_subscribe_event) +
869 sizeof(struct mrvlietypes_failurecount));
870 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
871 ptr = (u8*) pcmdptr+cmd_len;
872 failcount = (struct mrvlietypes_failurecount *)(ptr);
873 failcount->header.type = cpu_to_le16(TLV_TYPE_FAILCOUNT);
874 failcount->header.len = cpu_to_le16(2);
875 failcount->failvalue = value;
876 failcount->Failfreq = freq;
877 event_bitmap |= subscribed ? 0x0004 : 0x0;
878 event->events = cpu_to_le16(event_bitmap);
880 libertas_queue_cmd(adapter, pcmdnode, 1);
881 wake_up_interruptible(&priv->waitq);
883 /* Sleep until response is generated by FW */
884 wait_event_interruptible(pcmdnode->cmdwait_q,
885 pcmdnode->cmdwaitqwoken);
887 pcmdptr = (struct cmd_ds_command *)response_buf;
889 if (pcmdptr->result) {
890 lbs_pr_err("%s: fail, result=%d\n", __func__,
891 le16_to_cpu(pcmdptr->result));
897 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
898 lbs_pr_err("command response incorrect!\n");
910 static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
911 size_t count, loff_t *ppos)
913 wlan_private *priv = file->private_data;
914 wlan_adapter *adapter = priv->adapter;
915 struct cmd_ctrl_node *pcmdnode;
916 struct cmd_ds_command *pcmdptr;
917 struct cmd_ds_802_11_subscribe_event *event;
921 unsigned long addr = get_zeroed_page(GFP_KERNEL);
922 char *buf = (char *)addr;
924 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
930 event = &pcmdptr->params.subscribe_event;
931 event->action = cpu_to_le16(CMD_ACT_GET);
932 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
933 libertas_queue_cmd(adapter, pcmdnode, 1);
934 wake_up_interruptible(&priv->waitq);
936 /* Sleep until response is generated by FW */
937 wait_event_interruptible(pcmdnode->cmdwait_q,
938 pcmdnode->cmdwaitqwoken);
940 pcmdptr = response_buf;
942 if (pcmdptr->result) {
943 lbs_pr_err("%s: fail, result=%d\n", __func__,
944 le16_to_cpu(pcmdptr->result));
950 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
951 lbs_pr_err("command response incorrect!\n");
957 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
958 event = (void *)(response_buf + S_DS_GEN);
959 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
960 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
961 switch (header->type) {
962 struct mrvlietypes_beaconsmissed *bcnmiss;
963 case __constant_cpu_to_le16(TLV_TYPE_BCNMISS):
964 bcnmiss = (void *)(response_buf + cmd_len);
965 pos += snprintf(buf+pos, len-pos, "%d N/A %d\n",
966 bcnmiss->beaconmissed,
967 (event->events & cpu_to_le16(0x0008))?1:0);
969 cmd_len += sizeof(struct mrvlietypes_beaconsmissed);
976 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
981 static ssize_t libertas_bcnmiss_write(struct file *file,
982 const char __user *userbuf,
983 size_t count, loff_t *ppos)
985 wlan_private *priv = file->private_data;
986 wlan_adapter *adapter = priv->adapter;
987 ssize_t res, buf_size;
988 int value, freq, subscribed, cmd_len;
989 struct cmd_ctrl_node *pcmdnode;
990 struct cmd_ds_command *pcmdptr;
991 struct cmd_ds_802_11_subscribe_event *event;
992 struct mrvlietypes_beaconsmissed *bcnmiss;
996 unsigned long addr = get_zeroed_page(GFP_KERNEL);
997 char *buf = (char *)addr;
999 buf_size = min(count, len - 1);
1000 if (copy_from_user(buf, userbuf, buf_size)) {
1004 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1010 event_bitmap = libertas_get_events_bitmap(priv);
1012 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1016 event = &pcmdptr->params.subscribe_event;
1017 event->action = cpu_to_le16(CMD_ACT_SET);
1018 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1019 sizeof(struct cmd_ds_802_11_subscribe_event) +
1020 sizeof(struct mrvlietypes_beaconsmissed));
1021 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1022 ptr = (u8*) pcmdptr+cmd_len;
1023 bcnmiss = (struct mrvlietypes_beaconsmissed *)(ptr);
1024 bcnmiss->header.type = cpu_to_le16(TLV_TYPE_BCNMISS);
1025 bcnmiss->header.len = cpu_to_le16(2);
1026 bcnmiss->beaconmissed = value;
1027 event_bitmap |= subscribed ? 0x0008 : 0x0;
1028 event->events = cpu_to_le16(event_bitmap);
1030 libertas_queue_cmd(adapter, pcmdnode, 1);
1031 wake_up_interruptible(&priv->waitq);
1033 /* Sleep until response is generated by FW */
1034 wait_event_interruptible(pcmdnode->cmdwait_q,
1035 pcmdnode->cmdwaitqwoken);
1037 pcmdptr = response_buf;
1039 if (pcmdptr->result) {
1040 lbs_pr_err("%s: fail, result=%d\n", __func__,
1041 le16_to_cpu(pcmdptr->result));
1042 kfree(response_buf);
1047 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1048 lbs_pr_err("command response incorrect!\n");
1050 kfree(response_buf);
1060 static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1061 size_t count, loff_t *ppos)
1063 wlan_private *priv = file->private_data;
1064 wlan_adapter *adapter = priv->adapter;
1065 struct cmd_ctrl_node *pcmdnode;
1066 struct cmd_ds_command *pcmdptr;
1067 struct cmd_ds_802_11_subscribe_event *event;
1071 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1072 char *buf = (char *)addr;
1074 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1080 event = &pcmdptr->params.subscribe_event;
1081 event->action = cpu_to_le16(CMD_ACT_GET);
1082 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1083 libertas_queue_cmd(adapter, pcmdnode, 1);
1084 wake_up_interruptible(&priv->waitq);
1086 /* Sleep until response is generated by FW */
1087 wait_event_interruptible(pcmdnode->cmdwait_q,
1088 pcmdnode->cmdwaitqwoken);
1090 pcmdptr = response_buf;
1092 if (pcmdptr->result) {
1093 lbs_pr_err("%s: fail, result=%d\n", __func__,
1094 le16_to_cpu(pcmdptr->result));
1095 kfree(response_buf);
1100 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1101 lbs_pr_err("command response incorrect!\n");
1102 kfree(response_buf);
1107 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1108 event = (void *)(response_buf + S_DS_GEN);
1109 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1110 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1111 switch (header->type) {
1112 struct mrvlietypes_rssithreshold *Highrssi;
1113 case __constant_cpu_to_le16(TLV_TYPE_RSSI_HIGH):
1114 Highrssi = (void *)(response_buf + cmd_len);
1115 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1116 Highrssi->rssivalue,
1118 (event->events & cpu_to_le16(0x0010))?1:0);
1120 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1125 kfree(response_buf);
1127 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1132 static ssize_t libertas_highrssi_write(struct file *file,
1133 const char __user *userbuf,
1134 size_t count, loff_t *ppos)
1136 wlan_private *priv = file->private_data;
1137 wlan_adapter *adapter = priv->adapter;
1138 ssize_t res, buf_size;
1139 int value, freq, subscribed, cmd_len;
1140 struct cmd_ctrl_node *pcmdnode;
1141 struct cmd_ds_command *pcmdptr;
1142 struct cmd_ds_802_11_subscribe_event *event;
1143 struct mrvlietypes_rssithreshold *rssi_threshold;
1147 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1148 char *buf = (char *)addr;
1150 buf_size = min(count, len - 1);
1151 if (copy_from_user(buf, userbuf, buf_size)) {
1155 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1161 event_bitmap = libertas_get_events_bitmap(priv);
1163 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1167 event = &pcmdptr->params.subscribe_event;
1168 event->action = cpu_to_le16(CMD_ACT_SET);
1169 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1170 sizeof(struct cmd_ds_802_11_subscribe_event) +
1171 sizeof(struct mrvlietypes_rssithreshold));
1172 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1173 ptr = (u8*) pcmdptr+cmd_len;
1174 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
1175 rssi_threshold->header.type = cpu_to_le16(TLV_TYPE_RSSI_HIGH);
1176 rssi_threshold->header.len = cpu_to_le16(2);
1177 rssi_threshold->rssivalue = value;
1178 rssi_threshold->rssifreq = freq;
1179 event_bitmap |= subscribed ? 0x0010 : 0x0;
1180 event->events = cpu_to_le16(event_bitmap);
1182 libertas_queue_cmd(adapter, pcmdnode, 1);
1183 wake_up_interruptible(&priv->waitq);
1185 /* Sleep until response is generated by FW */
1186 wait_event_interruptible(pcmdnode->cmdwait_q,
1187 pcmdnode->cmdwaitqwoken);
1189 pcmdptr = response_buf;
1191 if (pcmdptr->result) {
1192 lbs_pr_err("%s: fail, result=%d\n", __func__,
1193 le16_to_cpu(pcmdptr->result));
1194 kfree(response_buf);
1198 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1199 lbs_pr_err("command response incorrect!\n");
1200 kfree(response_buf);
1210 static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1211 size_t count, loff_t *ppos)
1213 wlan_private *priv = file->private_data;
1214 wlan_adapter *adapter = priv->adapter;
1215 struct cmd_ctrl_node *pcmdnode;
1216 struct cmd_ds_command *pcmdptr;
1217 struct cmd_ds_802_11_subscribe_event *event;
1221 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1222 char *buf = (char *)addr;
1224 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1230 event = &pcmdptr->params.subscribe_event;
1231 event->action = cpu_to_le16(CMD_ACT_GET);
1232 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1233 libertas_queue_cmd(adapter, pcmdnode, 1);
1234 wake_up_interruptible(&priv->waitq);
1236 /* Sleep until response is generated by FW */
1237 wait_event_interruptible(pcmdnode->cmdwait_q,
1238 pcmdnode->cmdwaitqwoken);
1240 pcmdptr = response_buf;
1242 if (pcmdptr->result) {
1243 lbs_pr_err("%s: fail, result=%d\n", __func__,
1244 le16_to_cpu(pcmdptr->result));
1245 kfree(response_buf);
1250 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1251 lbs_pr_err("command response incorrect!\n");
1252 kfree(response_buf);
1257 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1258 event = (void *)(response_buf + S_DS_GEN);
1259 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1260 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1261 switch (header->type) {
1262 struct mrvlietypes_snrthreshold *HighSnr;
1263 case __constant_cpu_to_le16(TLV_TYPE_SNR_HIGH):
1264 HighSnr = (void *)(response_buf + cmd_len);
1265 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1268 (event->events & cpu_to_le16(0x0020))?1:0);
1270 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1275 kfree(response_buf);
1277 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1282 static ssize_t libertas_highsnr_write(struct file *file,
1283 const char __user *userbuf,
1284 size_t count, loff_t *ppos)
1286 wlan_private *priv = file->private_data;
1287 wlan_adapter *adapter = priv->adapter;
1288 ssize_t res, buf_size;
1289 int value, freq, subscribed, cmd_len;
1290 struct cmd_ctrl_node *pcmdnode;
1291 struct cmd_ds_command *pcmdptr;
1292 struct cmd_ds_802_11_subscribe_event *event;
1293 struct mrvlietypes_snrthreshold *snr_threshold;
1297 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1298 char *buf = (char *)addr;
1300 buf_size = min(count, len - 1);
1301 if (copy_from_user(buf, userbuf, buf_size)) {
1305 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1311 event_bitmap = libertas_get_events_bitmap(priv);
1313 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1317 event = &pcmdptr->params.subscribe_event;
1318 event->action = cpu_to_le16(CMD_ACT_SET);
1319 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1320 sizeof(struct cmd_ds_802_11_subscribe_event) +
1321 sizeof(struct mrvlietypes_snrthreshold));
1322 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1323 ptr = (u8*) pcmdptr+cmd_len;
1324 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
1325 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_HIGH);
1326 snr_threshold->header.len = cpu_to_le16(2);
1327 snr_threshold->snrvalue = value;
1328 snr_threshold->snrfreq = freq;
1329 event_bitmap |= subscribed ? 0x0020 : 0x0;
1330 event->events = cpu_to_le16(event_bitmap);
1332 libertas_queue_cmd(adapter, pcmdnode, 1);
1333 wake_up_interruptible(&priv->waitq);
1335 /* Sleep until response is generated by FW */
1336 wait_event_interruptible(pcmdnode->cmdwait_q,
1337 pcmdnode->cmdwaitqwoken);
1339 pcmdptr = response_buf;
1341 if (pcmdptr->result) {
1342 lbs_pr_err("%s: fail, result=%d\n", __func__,
1343 le16_to_cpu(pcmdptr->result));
1344 kfree(response_buf);
1349 if (pcmdptr->command != cpu_to_le16(CMD_RET(CMD_802_11_SUBSCRIBE_EVENT))) {
1350 lbs_pr_err("command response incorrect!\n");
1351 kfree(response_buf);
1362 static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1363 size_t count, loff_t *ppos)
1365 wlan_private *priv = file->private_data;
1366 wlan_adapter *adapter = priv->adapter;
1367 struct wlan_offset_value offval;
1370 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1371 char *buf = (char *)addr;
1373 offval.offset = priv->mac_offset;
1376 ret = libertas_prepare_and_send_command(priv,
1377 CMD_MAC_REG_ACCESS, 0,
1378 CMD_OPTION_WAITFORRSP, 0, &offval);
1380 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
1381 priv->mac_offset, adapter->offsetvalue.value);
1383 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1388 static ssize_t libertas_rdmac_write(struct file *file,
1389 const char __user *userbuf,
1390 size_t count, loff_t *ppos)
1392 wlan_private *priv = file->private_data;
1393 ssize_t res, buf_size;
1394 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1395 char *buf = (char *)addr;
1397 buf_size = min(count, len - 1);
1398 if (copy_from_user(buf, userbuf, buf_size)) {
1402 priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
1409 static ssize_t libertas_wrmac_write(struct file *file,
1410 const char __user *userbuf,
1411 size_t count, loff_t *ppos)
1414 wlan_private *priv = file->private_data;
1415 ssize_t res, buf_size;
1417 struct wlan_offset_value offval;
1418 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1419 char *buf = (char *)addr;
1421 buf_size = min(count, len - 1);
1422 if (copy_from_user(buf, userbuf, buf_size)) {
1426 res = sscanf(buf, "%x %x", &offset, &value);
1432 offval.offset = offset;
1433 offval.value = value;
1434 res = libertas_prepare_and_send_command(priv,
1435 CMD_MAC_REG_ACCESS, 1,
1436 CMD_OPTION_WAITFORRSP, 0, &offval);
1445 static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1446 size_t count, loff_t *ppos)
1448 wlan_private *priv = file->private_data;
1449 wlan_adapter *adapter = priv->adapter;
1450 struct wlan_offset_value offval;
1453 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1454 char *buf = (char *)addr;
1456 offval.offset = priv->bbp_offset;
1459 ret = libertas_prepare_and_send_command(priv,
1460 CMD_BBP_REG_ACCESS, 0,
1461 CMD_OPTION_WAITFORRSP, 0, &offval);
1463 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
1464 priv->bbp_offset, adapter->offsetvalue.value);
1466 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1472 static ssize_t libertas_rdbbp_write(struct file *file,
1473 const char __user *userbuf,
1474 size_t count, loff_t *ppos)
1476 wlan_private *priv = file->private_data;
1477 ssize_t res, buf_size;
1478 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1479 char *buf = (char *)addr;
1481 buf_size = min(count, len - 1);
1482 if (copy_from_user(buf, userbuf, buf_size)) {
1486 priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
1493 static ssize_t libertas_wrbbp_write(struct file *file,
1494 const char __user *userbuf,
1495 size_t count, loff_t *ppos)
1498 wlan_private *priv = file->private_data;
1499 ssize_t res, buf_size;
1501 struct wlan_offset_value offval;
1502 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1503 char *buf = (char *)addr;
1505 buf_size = min(count, len - 1);
1506 if (copy_from_user(buf, userbuf, buf_size)) {
1510 res = sscanf(buf, "%x %x", &offset, &value);
1516 offval.offset = offset;
1517 offval.value = value;
1518 res = libertas_prepare_and_send_command(priv,
1519 CMD_BBP_REG_ACCESS, 1,
1520 CMD_OPTION_WAITFORRSP, 0, &offval);
1529 static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1530 size_t count, loff_t *ppos)
1532 wlan_private *priv = file->private_data;
1533 wlan_adapter *adapter = priv->adapter;
1534 struct wlan_offset_value offval;
1537 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1538 char *buf = (char *)addr;
1540 offval.offset = priv->rf_offset;
1543 ret = libertas_prepare_and_send_command(priv,
1544 CMD_RF_REG_ACCESS, 0,
1545 CMD_OPTION_WAITFORRSP, 0, &offval);
1547 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
1548 priv->rf_offset, adapter->offsetvalue.value);
1550 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1556 static ssize_t libertas_rdrf_write(struct file *file,
1557 const char __user *userbuf,
1558 size_t count, loff_t *ppos)
1560 wlan_private *priv = file->private_data;
1561 ssize_t res, buf_size;
1562 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1563 char *buf = (char *)addr;
1565 buf_size = min(count, len - 1);
1566 if (copy_from_user(buf, userbuf, buf_size)) {
1570 priv->rf_offset = simple_strtoul((char *)buf, NULL, 16);
1577 static ssize_t libertas_wrrf_write(struct file *file,
1578 const char __user *userbuf,
1579 size_t count, loff_t *ppos)
1582 wlan_private *priv = file->private_data;
1583 ssize_t res, buf_size;
1585 struct wlan_offset_value offval;
1586 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1587 char *buf = (char *)addr;
1589 buf_size = min(count, len - 1);
1590 if (copy_from_user(buf, userbuf, buf_size)) {
1594 res = sscanf(buf, "%x %x", &offset, &value);
1600 offval.offset = offset;
1601 offval.value = value;
1602 res = libertas_prepare_and_send_command(priv,
1603 CMD_RF_REG_ACCESS, 1,
1604 CMD_OPTION_WAITFORRSP, 0, &offval);
1613 #define FOPS(fread, fwrite) { \
1614 .owner = THIS_MODULE, \
1615 .open = open_file_generic, \
1617 .write = (fwrite), \
1620 struct libertas_debugfs_files {
1623 struct file_operations fops;
1626 static struct libertas_debugfs_files debugfs_files[] = {
1627 { "info", 0444, FOPS(libertas_dev_info, write_file_dummy), },
1628 { "getscantable", 0444, FOPS(libertas_getscantable,
1629 write_file_dummy), },
1630 { "sleepparams", 0644, FOPS(libertas_sleepparams_read,
1631 libertas_sleepparams_write), },
1632 { "extscan", 0600, FOPS(NULL, libertas_extscan), },
1633 { "setuserscan", 0600, FOPS(NULL, libertas_setuserscan), },
1636 static struct libertas_debugfs_files debugfs_events_files[] = {
1637 {"low_rssi", 0644, FOPS(libertas_lowrssi_read,
1638 libertas_lowrssi_write), },
1639 {"low_snr", 0644, FOPS(libertas_lowsnr_read,
1640 libertas_lowsnr_write), },
1641 {"failure_count", 0644, FOPS(libertas_failcount_read,
1642 libertas_failcount_write), },
1643 {"beacon_missed", 0644, FOPS(libertas_bcnmiss_read,
1644 libertas_bcnmiss_write), },
1645 {"high_rssi", 0644, FOPS(libertas_highrssi_read,
1646 libertas_highrssi_write), },
1647 {"high_snr", 0644, FOPS(libertas_highsnr_read,
1648 libertas_highsnr_write), },
1651 static struct libertas_debugfs_files debugfs_regs_files[] = {
1652 {"rdmac", 0644, FOPS(libertas_rdmac_read, libertas_rdmac_write), },
1653 {"wrmac", 0600, FOPS(NULL, libertas_wrmac_write), },
1654 {"rdbbp", 0644, FOPS(libertas_rdbbp_read, libertas_rdbbp_write), },
1655 {"wrbbp", 0600, FOPS(NULL, libertas_wrbbp_write), },
1656 {"rdrf", 0644, FOPS(libertas_rdrf_read, libertas_rdrf_write), },
1657 {"wrrf", 0600, FOPS(NULL, libertas_wrrf_write), },
1660 void libertas_debugfs_init(void)
1663 libertas_dir = debugfs_create_dir("libertas_wireless", NULL);
1668 void libertas_debugfs_remove(void)
1671 debugfs_remove(libertas_dir);
1675 void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev)
1678 struct libertas_debugfs_files *files;
1682 priv->debugfs_dir = debugfs_create_dir(dev->name, libertas_dir);
1683 if (!priv->debugfs_dir)
1686 for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
1687 files = &debugfs_files[i];
1688 priv->debugfs_files[i] = debugfs_create_file(files->name,
1695 priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
1696 if (!priv->events_dir)
1699 for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
1700 files = &debugfs_events_files[i];
1701 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
1708 priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
1709 if (!priv->regs_dir)
1712 for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
1713 files = &debugfs_regs_files[i];
1714 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
1722 libertas_debug_init(priv, dev);
1728 void libertas_debugfs_remove_one(wlan_private *priv)
1732 for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
1733 debugfs_remove(priv->debugfs_regs_files[i]);
1735 debugfs_remove(priv->regs_dir);
1737 for(i=0; i<ARRAY_SIZE(debugfs_events_files); i++)
1738 debugfs_remove(priv->debugfs_events_files[i]);
1740 debugfs_remove(priv->events_dir);
1742 debugfs_remove(priv->debugfs_debug);
1744 for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
1745 debugfs_remove(priv->debugfs_files[i]);
1746 debugfs_remove(priv->debugfs_dir);
1755 #define item_size(n) (FIELD_SIZEOF(wlan_adapter, n))
1756 #define item_addr(n) (offsetof(wlan_adapter, n))
1765 /* To debug any member of wlan_adapter, simply add one line here.
1767 static struct debug_data items[] = {
1768 {"intcounter", item_size(intcounter), item_addr(intcounter)},
1769 {"psmode", item_size(psmode), item_addr(psmode)},
1770 {"psstate", item_size(psstate), item_addr(psstate)},
1773 static int num_of_items = ARRAY_SIZE(items);
1776 * @brief proc read function
1778 * @param page pointer to buffer
1779 * @param s read data starting position
1781 * @param cnt counter
1782 * @param eof end of file flag
1783 * @param data data to output
1784 * @return number of output data
1786 static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf,
1787 size_t count, loff_t *ppos)
1794 struct debug_data *d;
1795 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1796 char *buf = (char *)addr;
1800 d = (struct debug_data *)file->private_data;
1802 for (i = 0; i < num_of_items; i++) {
1804 val = *((u8 *) d[i].addr);
1805 else if (d[i].size == 2)
1806 val = *((u16 *) d[i].addr);
1807 else if (d[i].size == 4)
1808 val = *((u32 *) d[i].addr);
1809 else if (d[i].size == 8)
1810 val = *((u64 *) d[i].addr);
1812 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
1815 res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
1822 * @brief proc write function
1824 * @param f file pointer
1825 * @param buf pointer to data buffer
1826 * @param cnt data number to write
1827 * @param data data to write
1828 * @return number of data
1830 static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf,
1831 size_t cnt, loff_t *ppos)
1839 struct debug_data *d = (struct debug_data *)f->private_data;
1841 pdata = kmalloc(cnt, GFP_KERNEL);
1845 if (copy_from_user(pdata, buf, cnt)) {
1846 lbs_deb_debugfs("Copy from user failed\n");
1852 for (i = 0; i < num_of_items; i++) {
1854 p = strstr(p0, d[i].name);
1857 p1 = strchr(p, '\n');
1861 p2 = strchr(p, '=');
1865 r = simple_strtoul(p2, NULL, 0);
1867 *((u8 *) d[i].addr) = (u8) r;
1868 else if (d[i].size == 2)
1869 *((u16 *) d[i].addr) = (u16) r;
1870 else if (d[i].size == 4)
1871 *((u32 *) d[i].addr) = (u32) r;
1872 else if (d[i].size == 8)
1873 *((u64 *) d[i].addr) = (u64) r;
1879 return (ssize_t)cnt;
1882 static struct file_operations libertas_debug_fops = {
1883 .owner = THIS_MODULE,
1884 .open = open_file_generic,
1885 .write = wlan_debugfs_write,
1886 .read = wlan_debugfs_read,
1890 * @brief create debug proc file
1892 * @param priv pointer wlan_private
1893 * @param dev pointer net_device
1896 static void libertas_debug_init(wlan_private * priv, struct net_device *dev)
1900 if (!priv->debugfs_dir)
1903 for (i = 0; i < num_of_items; i++)
1904 items[i].addr += (size_t) priv->adapter;
1906 priv->debugfs_debug = debugfs_create_file("debug", 0644,
1907 priv->debugfs_dir, &items[0],
1908 &libertas_debug_fops);