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 | ss | bssid | cap | TSF | Qual | SSID \n");
71 mutex_lock(&priv->adapter->lock);
72 list_for_each_entry (iter_bss, &priv->adapter->network_list, list) {
75 memcpy(&cap, &iter_bss->cap, sizeof(cap));
76 pos += snprintf(buf+pos, len-pos,
77 "%02u| %03d | %03ld | " MAC_FMT " |",
78 numscansdone, iter_bss->channel, iter_bss->rssi,
79 MAC_ARG(iter_bss->bssid));
80 pos += snprintf(buf+pos, len-pos, " %04x-", cap);
81 pos += snprintf(buf+pos, len-pos, "%c%c%c |",
82 iter_bss->cap.ibss ? 'A' : 'I',
83 iter_bss->cap.privacy ? 'P' : ' ',
84 iter_bss->cap.spectrummgmt ? 'S' : ' ');
85 pos += snprintf(buf+pos, len-pos, " %08llx |", iter_bss->networktsf);
86 pos += snprintf(buf+pos, len-pos, " %d |", SCAN_RSSI(iter_bss->rssi));
87 pos += snprintf(buf+pos, len-pos, " %s\n", iter_bss->ssid.ssid);
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 struct WLAN_802_11_SSID extscan_ssid;
178 union iwreq_data wrqu;
179 unsigned long addr = get_zeroed_page(GFP_KERNEL);
180 char *buf = (char *)addr;
182 buf_size = min(count, len - 1);
183 if (copy_from_user(buf, userbuf, buf_size)) {
188 memcpy(&extscan_ssid.ssid, buf, strlen(buf)-1);
189 extscan_ssid.ssidlength = strlen(buf)-1;
191 libertas_send_specific_SSID_scan(priv, &extscan_ssid, 0);
193 memset(&wrqu, 0, sizeof(union iwreq_data));
194 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
201 static int libertas_parse_chan(char *buf, size_t count,
202 struct wlan_ioctl_user_scan_cfg *scan_cfg, int dur)
204 char *start, *end, *hold, *str;
207 start = strstr(buf, "chan=");
211 end = strstr(start, " ");
214 hold = kzalloc((end - start)+1, GFP_KERNEL);
217 strncpy(hold, start, end - start);
218 hold[(end-start)+1] = '\0';
219 while(hold && (str = strsep(&hold, ","))) {
221 char band, passive = 0;
222 sscanf(str, "%d%c%c", &chan, &band, &passive);
223 scan_cfg->chanlist[i].channumber = chan;
224 scan_cfg->chanlist[i].scantype = passive ? 1 : 0;
225 if (band == 'b' || band == 'g')
226 scan_cfg->chanlist[i].radiotype = 0;
227 else if (band == 'a')
228 scan_cfg->chanlist[i].radiotype = 1;
230 scan_cfg->chanlist[i].scantime = dur;
238 static void libertas_parse_bssid(char *buf, size_t count,
239 struct wlan_ioctl_user_scan_cfg *scan_cfg)
242 unsigned int mac[ETH_ALEN];
244 hold = strstr(buf, "bssid=");
248 sscanf(hold, MAC_FMT, mac, mac+1, mac+2, mac+3, mac+4, mac+5);
249 memcpy(scan_cfg->bssid, mac, ETH_ALEN);
252 static void libertas_parse_ssid(char *buf, size_t count,
253 struct wlan_ioctl_user_scan_cfg *scan_cfg)
258 hold = strstr(buf, "ssid=");
262 end = strstr(hold, " ");
264 end = buf + count - 1;
266 size = min((size_t)IW_ESSID_MAX_SIZE, (size_t) (end - hold));
267 strncpy(scan_cfg->ssid, hold, size);
272 static int libertas_parse_clear(char *buf, size_t count, const char *tag)
277 hold = strstr(buf, tag);
281 sscanf(hold, "%d", &val);
289 static int libertas_parse_dur(char *buf, size_t count,
290 struct wlan_ioctl_user_scan_cfg *scan_cfg)
295 hold = strstr(buf, "dur=");
299 sscanf(hold, "%d", &val);
304 static void libertas_parse_probes(char *buf, size_t count,
305 struct wlan_ioctl_user_scan_cfg *scan_cfg)
310 hold = strstr(buf, "probes=");
314 sscanf(hold, "%d", &val);
316 scan_cfg->numprobes = val;
321 static void libertas_parse_type(char *buf, size_t count,
322 struct wlan_ioctl_user_scan_cfg *scan_cfg)
327 hold = strstr(buf, "type=");
331 sscanf(hold, "%d", &val);
334 if (val < 1 || val > 3)
337 scan_cfg->bsstype = val;
342 static ssize_t libertas_setuserscan(struct file *file,
343 const char __user *userbuf,
344 size_t count, loff_t *ppos)
346 wlan_private *priv = file->private_data;
347 ssize_t res, buf_size;
348 struct wlan_ioctl_user_scan_cfg *scan_cfg;
349 union iwreq_data wrqu;
351 unsigned long addr = get_zeroed_page(GFP_KERNEL);
352 char *buf = (char *)addr;
354 scan_cfg = kzalloc(sizeof(struct wlan_ioctl_user_scan_cfg), GFP_KERNEL);
358 buf_size = min(count, len - 1);
359 if (copy_from_user(buf, userbuf, buf_size)) {
364 scan_cfg->bsstype = WLAN_SCAN_BSS_TYPE_ANY;
366 dur = libertas_parse_dur(buf, count, scan_cfg);
367 libertas_parse_chan(buf, count, scan_cfg, dur);
368 libertas_parse_bssid(buf, count, scan_cfg);
369 scan_cfg->clear_bssid = libertas_parse_clear(buf, count, "clear_bssid=");
370 libertas_parse_ssid(buf, count, scan_cfg);
371 scan_cfg->clear_ssid = libertas_parse_clear(buf, count, "clear_ssid=");
372 libertas_parse_probes(buf, count, scan_cfg);
373 libertas_parse_type(buf, count, scan_cfg);
375 wlan_scan_networks(priv, scan_cfg, 1);
376 wait_event_interruptible(priv->adapter->cmd_pending,
377 !priv->adapter->nr_cmd_pending);
379 memset(&wrqu, 0x00, sizeof(union iwreq_data));
380 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
388 static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
389 struct cmd_ctrl_node **cmdnode,
390 struct cmd_ds_command **cmd)
392 u16 wait_option = cmd_option_waitforrsp;
394 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {
395 lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
398 if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) {
399 lbs_deb_debugfs("failed to allocate response buffer!\n");
402 libertas_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL);
403 init_waitqueue_head(&(*cmdnode)->cmdwait_q);
404 (*cmdnode)->pdata_buf = *response_buf;
405 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
406 (*cmdnode)->cmdwaitqwoken = 0;
407 *cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;
408 (*cmd)->command = cpu_to_le16(cmd_802_11_subscribe_event);
409 (*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);
414 static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
415 size_t count, loff_t *ppos)
417 wlan_private *priv = file->private_data;
418 wlan_adapter *adapter = priv->adapter;
419 struct cmd_ctrl_node *pcmdnode;
420 struct cmd_ds_command *pcmdptr;
421 struct cmd_ds_802_11_subscribe_event *event;
425 unsigned long addr = get_zeroed_page(GFP_KERNEL);
426 char *buf = (char *)addr;
428 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
434 event = &pcmdptr->params.subscribe_event;
435 event->action = cpu_to_le16(cmd_act_get);
436 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
437 libertas_queue_cmd(adapter, pcmdnode, 1);
438 wake_up_interruptible(&priv->mainthread.waitq);
440 /* Sleep until response is generated by FW */
441 wait_event_interruptible(pcmdnode->cmdwait_q,
442 pcmdnode->cmdwaitqwoken);
444 pcmdptr = response_buf;
445 if (pcmdptr->result) {
446 lbs_pr_err("%s: fail, result=%d\n", __func__,
447 le16_to_cpu(pcmdptr->result));
453 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
454 lbs_pr_err("command response incorrect!\n");
460 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
461 event = (void *)(response_buf + S_DS_GEN);
462 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
463 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
464 switch (header->type) {
465 struct mrvlietypes_rssithreshold *Lowrssi;
466 case __constant_cpu_to_le16(TLV_TYPE_RSSI_LOW):
467 Lowrssi = (void *)(response_buf + cmd_len);
468 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
471 (event->events & cpu_to_le16(0x0001))?1:0);
473 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
479 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
484 static u16 libertas_get_events_bitmap(wlan_private *priv)
486 wlan_adapter *adapter = priv->adapter;
487 struct cmd_ctrl_node *pcmdnode;
488 struct cmd_ds_command *pcmdptr;
489 struct cmd_ds_802_11_subscribe_event *event;
494 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
498 event = &pcmdptr->params.subscribe_event;
499 event->action = cpu_to_le16(cmd_act_get);
500 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
501 libertas_queue_cmd(adapter, pcmdnode, 1);
502 wake_up_interruptible(&priv->mainthread.waitq);
504 /* Sleep until response is generated by FW */
505 wait_event_interruptible(pcmdnode->cmdwait_q,
506 pcmdnode->cmdwaitqwoken);
508 pcmdptr = response_buf;
510 if (pcmdptr->result) {
511 lbs_pr_err("%s: fail, result=%d\n", __func__,
512 le16_to_cpu(pcmdptr->result));
517 if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {
518 lbs_pr_err("command response incorrect!\n");
523 event = (struct cmd_ds_802_11_subscribe_event *)(response_buf + S_DS_GEN);
524 event_bitmap = le16_to_cpu(event->events);
529 static ssize_t libertas_lowrssi_write(struct file *file,
530 const char __user *userbuf,
531 size_t count, loff_t *ppos)
533 wlan_private *priv = file->private_data;
534 wlan_adapter *adapter = priv->adapter;
535 ssize_t res, buf_size;
536 int value, freq, subscribed, cmd_len;
537 struct cmd_ctrl_node *pcmdnode;
538 struct cmd_ds_command *pcmdptr;
539 struct cmd_ds_802_11_subscribe_event *event;
540 struct mrvlietypes_rssithreshold *rssi_threshold;
544 unsigned long addr = get_zeroed_page(GFP_KERNEL);
545 char *buf = (char *)addr;
547 buf_size = min(count, len - 1);
548 if (copy_from_user(buf, userbuf, buf_size)) {
552 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
558 event_bitmap = libertas_get_events_bitmap(priv);
560 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
564 event = &pcmdptr->params.subscribe_event;
565 event->action = cpu_to_le16(cmd_act_set);
566 pcmdptr->size = cpu_to_le16(S_DS_GEN +
567 sizeof(struct cmd_ds_802_11_subscribe_event) +
568 sizeof(struct mrvlietypes_rssithreshold));
570 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
571 ptr = (u8*) pcmdptr+cmd_len;
572 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
573 rssi_threshold->header.type = cpu_to_le16(0x0104);
574 rssi_threshold->header.len = cpu_to_le16(2);
575 rssi_threshold->rssivalue = value;
576 rssi_threshold->rssifreq = freq;
577 event_bitmap |= subscribed ? 0x0001 : 0x0;
578 event->events = cpu_to_le16(event_bitmap);
580 libertas_queue_cmd(adapter, pcmdnode, 1);
581 wake_up_interruptible(&priv->mainthread.waitq);
583 /* Sleep until response is generated by FW */
584 wait_event_interruptible(pcmdnode->cmdwait_q,
585 pcmdnode->cmdwaitqwoken);
587 pcmdptr = response_buf;
589 if (pcmdptr->result) {
590 lbs_pr_err("%s: fail, result=%d\n", __func__,
591 le16_to_cpu(pcmdptr->result));
597 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
598 lbs_pr_err("command response incorrect!\n");
610 static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
611 size_t count, loff_t *ppos)
613 wlan_private *priv = file->private_data;
614 wlan_adapter *adapter = priv->adapter;
615 struct cmd_ctrl_node *pcmdnode;
616 struct cmd_ds_command *pcmdptr;
617 struct cmd_ds_802_11_subscribe_event *event;
621 unsigned long addr = get_zeroed_page(GFP_KERNEL);
622 char *buf = (char *)addr;
624 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
630 event = &pcmdptr->params.subscribe_event;
631 event->action = cpu_to_le16(cmd_act_get);
632 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
633 libertas_queue_cmd(adapter, pcmdnode, 1);
634 wake_up_interruptible(&priv->mainthread.waitq);
636 /* Sleep until response is generated by FW */
637 wait_event_interruptible(pcmdnode->cmdwait_q,
638 pcmdnode->cmdwaitqwoken);
640 pcmdptr = response_buf;
642 if (pcmdptr->result) {
643 lbs_pr_err("%s: fail, result=%d\n", __func__,
644 le16_to_cpu(pcmdptr->result));
650 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
651 lbs_pr_err("command response incorrect!\n");
657 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
658 event = (void *)(response_buf + S_DS_GEN);
659 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
660 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
661 switch (header->type) {
662 struct mrvlietypes_snrthreshold *LowSnr;
663 case __constant_cpu_to_le16(TLV_TYPE_SNR_LOW):
664 LowSnr = (void *)(response_buf + cmd_len);
665 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
668 (event->events & cpu_to_le16(0x0002))?1:0);
670 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
677 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
682 static ssize_t libertas_lowsnr_write(struct file *file,
683 const char __user *userbuf,
684 size_t count, loff_t *ppos)
686 wlan_private *priv = file->private_data;
687 wlan_adapter *adapter = priv->adapter;
688 ssize_t res, buf_size;
689 int value, freq, subscribed, cmd_len;
690 struct cmd_ctrl_node *pcmdnode;
691 struct cmd_ds_command *pcmdptr;
692 struct cmd_ds_802_11_subscribe_event *event;
693 struct mrvlietypes_snrthreshold *snr_threshold;
697 unsigned long addr = get_zeroed_page(GFP_KERNEL);
698 char *buf = (char *)addr;
700 buf_size = min(count, len - 1);
701 if (copy_from_user(buf, userbuf, buf_size)) {
705 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
711 event_bitmap = libertas_get_events_bitmap(priv);
713 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
717 event = &pcmdptr->params.subscribe_event;
718 event->action = cpu_to_le16(cmd_act_set);
719 pcmdptr->size = cpu_to_le16(S_DS_GEN +
720 sizeof(struct cmd_ds_802_11_subscribe_event) +
721 sizeof(struct mrvlietypes_snrthreshold));
722 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
723 ptr = (u8*) pcmdptr+cmd_len;
724 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
725 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_LOW);
726 snr_threshold->header.len = cpu_to_le16(2);
727 snr_threshold->snrvalue = value;
728 snr_threshold->snrfreq = freq;
729 event_bitmap |= subscribed ? 0x0002 : 0x0;
730 event->events = cpu_to_le16(event_bitmap);
732 libertas_queue_cmd(adapter, pcmdnode, 1);
733 wake_up_interruptible(&priv->mainthread.waitq);
735 /* Sleep until response is generated by FW */
736 wait_event_interruptible(pcmdnode->cmdwait_q,
737 pcmdnode->cmdwaitqwoken);
739 pcmdptr = response_buf;
741 if (pcmdptr->result) {
742 lbs_pr_err("%s: fail, result=%d\n", __func__,
743 le16_to_cpu(pcmdptr->result));
749 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
750 lbs_pr_err("command response incorrect!\n");
763 static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
764 size_t count, loff_t *ppos)
766 wlan_private *priv = file->private_data;
767 wlan_adapter *adapter = priv->adapter;
768 struct cmd_ctrl_node *pcmdnode;
769 struct cmd_ds_command *pcmdptr;
770 struct cmd_ds_802_11_subscribe_event *event;
774 unsigned long addr = get_zeroed_page(GFP_KERNEL);
775 char *buf = (char *)addr;
777 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
783 event = &pcmdptr->params.subscribe_event;
784 event->action = cpu_to_le16(cmd_act_get);
785 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
786 libertas_queue_cmd(adapter, pcmdnode, 1);
787 wake_up_interruptible(&priv->mainthread.waitq);
789 /* Sleep until response is generated by FW */
790 wait_event_interruptible(pcmdnode->cmdwait_q,
791 pcmdnode->cmdwaitqwoken);
793 pcmdptr = response_buf;
795 if (pcmdptr->result) {
796 lbs_pr_err("%s: fail, result=%d\n", __func__,
797 le16_to_cpu(pcmdptr->result));
803 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
804 lbs_pr_err("command response incorrect!\n");
810 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
811 event = (void *)(response_buf + S_DS_GEN);
812 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
813 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
814 switch (header->type) {
815 struct mrvlietypes_failurecount *failcount;
816 case __constant_cpu_to_le16(TLV_TYPE_FAILCOUNT):
817 failcount = (void *)(response_buf + cmd_len);
818 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
819 failcount->failvalue,
821 (event->events & cpu_to_le16(0x0004))?1:0);
823 cmd_len += sizeof(struct mrvlietypes_failurecount);
829 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
834 static ssize_t libertas_failcount_write(struct file *file,
835 const char __user *userbuf,
836 size_t count, loff_t *ppos)
838 wlan_private *priv = file->private_data;
839 wlan_adapter *adapter = priv->adapter;
840 ssize_t res, buf_size;
841 int value, freq, subscribed, cmd_len;
842 struct cmd_ctrl_node *pcmdnode;
843 struct cmd_ds_command *pcmdptr;
844 struct cmd_ds_802_11_subscribe_event *event;
845 struct mrvlietypes_failurecount *failcount;
849 unsigned long addr = get_zeroed_page(GFP_KERNEL);
850 char *buf = (char *)addr;
852 buf_size = min(count, len - 1);
853 if (copy_from_user(buf, userbuf, buf_size)) {
857 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
863 event_bitmap = libertas_get_events_bitmap(priv);
865 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
869 event = &pcmdptr->params.subscribe_event;
870 event->action = cpu_to_le16(cmd_act_set);
871 pcmdptr->size = cpu_to_le16(S_DS_GEN +
872 sizeof(struct cmd_ds_802_11_subscribe_event) +
873 sizeof(struct mrvlietypes_failurecount));
874 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
875 ptr = (u8*) pcmdptr+cmd_len;
876 failcount = (struct mrvlietypes_failurecount *)(ptr);
877 failcount->header.type = cpu_to_le16(TLV_TYPE_FAILCOUNT);
878 failcount->header.len = cpu_to_le16(2);
879 failcount->failvalue = value;
880 failcount->Failfreq = freq;
881 event_bitmap |= subscribed ? 0x0004 : 0x0;
882 event->events = cpu_to_le16(event_bitmap);
884 libertas_queue_cmd(adapter, pcmdnode, 1);
885 wake_up_interruptible(&priv->mainthread.waitq);
887 /* Sleep until response is generated by FW */
888 wait_event_interruptible(pcmdnode->cmdwait_q,
889 pcmdnode->cmdwaitqwoken);
891 pcmdptr = (struct cmd_ds_command *)response_buf;
893 if (pcmdptr->result) {
894 lbs_pr_err("%s: fail, result=%d\n", __func__,
895 le16_to_cpu(pcmdptr->result));
901 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
902 lbs_pr_err("command response incorrect!\n");
914 static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
915 size_t count, loff_t *ppos)
917 wlan_private *priv = file->private_data;
918 wlan_adapter *adapter = priv->adapter;
919 struct cmd_ctrl_node *pcmdnode;
920 struct cmd_ds_command *pcmdptr;
921 struct cmd_ds_802_11_subscribe_event *event;
925 unsigned long addr = get_zeroed_page(GFP_KERNEL);
926 char *buf = (char *)addr;
928 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
934 event = &pcmdptr->params.subscribe_event;
935 event->action = cpu_to_le16(cmd_act_get);
936 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
937 libertas_queue_cmd(adapter, pcmdnode, 1);
938 wake_up_interruptible(&priv->mainthread.waitq);
940 /* Sleep until response is generated by FW */
941 wait_event_interruptible(pcmdnode->cmdwait_q,
942 pcmdnode->cmdwaitqwoken);
944 pcmdptr = response_buf;
946 if (pcmdptr->result) {
947 lbs_pr_err("%s: fail, result=%d\n", __func__,
948 le16_to_cpu(pcmdptr->result));
954 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
955 lbs_pr_err("command response incorrect!\n");
961 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
962 event = (void *)(response_buf + S_DS_GEN);
963 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
964 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
965 switch (header->type) {
966 struct mrvlietypes_beaconsmissed *bcnmiss;
967 case __constant_cpu_to_le16(TLV_TYPE_BCNMISS):
968 bcnmiss = (void *)(response_buf + cmd_len);
969 pos += snprintf(buf+pos, len-pos, "%d N/A %d\n",
970 bcnmiss->beaconmissed,
971 (event->events & cpu_to_le16(0x0008))?1:0);
973 cmd_len += sizeof(struct mrvlietypes_beaconsmissed);
980 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
985 static ssize_t libertas_bcnmiss_write(struct file *file,
986 const char __user *userbuf,
987 size_t count, loff_t *ppos)
989 wlan_private *priv = file->private_data;
990 wlan_adapter *adapter = priv->adapter;
991 ssize_t res, buf_size;
992 int value, freq, subscribed, cmd_len;
993 struct cmd_ctrl_node *pcmdnode;
994 struct cmd_ds_command *pcmdptr;
995 struct cmd_ds_802_11_subscribe_event *event;
996 struct mrvlietypes_beaconsmissed *bcnmiss;
1000 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1001 char *buf = (char *)addr;
1003 buf_size = min(count, len - 1);
1004 if (copy_from_user(buf, userbuf, buf_size)) {
1008 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1014 event_bitmap = libertas_get_events_bitmap(priv);
1016 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1020 event = &pcmdptr->params.subscribe_event;
1021 event->action = cpu_to_le16(cmd_act_set);
1022 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1023 sizeof(struct cmd_ds_802_11_subscribe_event) +
1024 sizeof(struct mrvlietypes_beaconsmissed));
1025 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1026 ptr = (u8*) pcmdptr+cmd_len;
1027 bcnmiss = (struct mrvlietypes_beaconsmissed *)(ptr);
1028 bcnmiss->header.type = cpu_to_le16(TLV_TYPE_BCNMISS);
1029 bcnmiss->header.len = cpu_to_le16(2);
1030 bcnmiss->beaconmissed = value;
1031 event_bitmap |= subscribed ? 0x0008 : 0x0;
1032 event->events = cpu_to_le16(event_bitmap);
1034 libertas_queue_cmd(adapter, pcmdnode, 1);
1035 wake_up_interruptible(&priv->mainthread.waitq);
1037 /* Sleep until response is generated by FW */
1038 wait_event_interruptible(pcmdnode->cmdwait_q,
1039 pcmdnode->cmdwaitqwoken);
1041 pcmdptr = response_buf;
1043 if (pcmdptr->result) {
1044 lbs_pr_err("%s: fail, result=%d\n", __func__,
1045 le16_to_cpu(pcmdptr->result));
1046 kfree(response_buf);
1051 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
1052 lbs_pr_err("command response incorrect!\n");
1054 kfree(response_buf);
1064 static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1065 size_t count, loff_t *ppos)
1067 wlan_private *priv = file->private_data;
1068 wlan_adapter *adapter = priv->adapter;
1069 struct cmd_ctrl_node *pcmdnode;
1070 struct cmd_ds_command *pcmdptr;
1071 struct cmd_ds_802_11_subscribe_event *event;
1075 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1076 char *buf = (char *)addr;
1078 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1084 event = &pcmdptr->params.subscribe_event;
1085 event->action = cpu_to_le16(cmd_act_get);
1086 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1087 libertas_queue_cmd(adapter, pcmdnode, 1);
1088 wake_up_interruptible(&priv->mainthread.waitq);
1090 /* Sleep until response is generated by FW */
1091 wait_event_interruptible(pcmdnode->cmdwait_q,
1092 pcmdnode->cmdwaitqwoken);
1094 pcmdptr = response_buf;
1096 if (pcmdptr->result) {
1097 lbs_pr_err("%s: fail, result=%d\n", __func__,
1098 le16_to_cpu(pcmdptr->result));
1099 kfree(response_buf);
1104 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
1105 lbs_pr_err("command response incorrect!\n");
1106 kfree(response_buf);
1111 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1112 event = (void *)(response_buf + S_DS_GEN);
1113 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1114 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1115 switch (header->type) {
1116 struct mrvlietypes_rssithreshold *Highrssi;
1117 case __constant_cpu_to_le16(TLV_TYPE_RSSI_HIGH):
1118 Highrssi = (void *)(response_buf + cmd_len);
1119 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1120 Highrssi->rssivalue,
1122 (event->events & cpu_to_le16(0x0010))?1:0);
1124 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1129 kfree(response_buf);
1131 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1136 static ssize_t libertas_highrssi_write(struct file *file,
1137 const char __user *userbuf,
1138 size_t count, loff_t *ppos)
1140 wlan_private *priv = file->private_data;
1141 wlan_adapter *adapter = priv->adapter;
1142 ssize_t res, buf_size;
1143 int value, freq, subscribed, cmd_len;
1144 struct cmd_ctrl_node *pcmdnode;
1145 struct cmd_ds_command *pcmdptr;
1146 struct cmd_ds_802_11_subscribe_event *event;
1147 struct mrvlietypes_rssithreshold *rssi_threshold;
1151 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1152 char *buf = (char *)addr;
1154 buf_size = min(count, len - 1);
1155 if (copy_from_user(buf, userbuf, buf_size)) {
1159 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1165 event_bitmap = libertas_get_events_bitmap(priv);
1167 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1171 event = &pcmdptr->params.subscribe_event;
1172 event->action = cpu_to_le16(cmd_act_set);
1173 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1174 sizeof(struct cmd_ds_802_11_subscribe_event) +
1175 sizeof(struct mrvlietypes_rssithreshold));
1176 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1177 ptr = (u8*) pcmdptr+cmd_len;
1178 rssi_threshold = (struct mrvlietypes_rssithreshold *)(ptr);
1179 rssi_threshold->header.type = cpu_to_le16(TLV_TYPE_RSSI_HIGH);
1180 rssi_threshold->header.len = cpu_to_le16(2);
1181 rssi_threshold->rssivalue = value;
1182 rssi_threshold->rssifreq = freq;
1183 event_bitmap |= subscribed ? 0x0010 : 0x0;
1184 event->events = cpu_to_le16(event_bitmap);
1186 libertas_queue_cmd(adapter, pcmdnode, 1);
1187 wake_up_interruptible(&priv->mainthread.waitq);
1189 /* Sleep until response is generated by FW */
1190 wait_event_interruptible(pcmdnode->cmdwait_q,
1191 pcmdnode->cmdwaitqwoken);
1193 pcmdptr = response_buf;
1195 if (pcmdptr->result) {
1196 lbs_pr_err("%s: fail, result=%d\n", __func__,
1197 le16_to_cpu(pcmdptr->result));
1198 kfree(response_buf);
1202 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
1203 lbs_pr_err("command response incorrect!\n");
1204 kfree(response_buf);
1214 static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1215 size_t count, loff_t *ppos)
1217 wlan_private *priv = file->private_data;
1218 wlan_adapter *adapter = priv->adapter;
1219 struct cmd_ctrl_node *pcmdnode;
1220 struct cmd_ds_command *pcmdptr;
1221 struct cmd_ds_802_11_subscribe_event *event;
1225 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1226 char *buf = (char *)addr;
1228 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1234 event = &pcmdptr->params.subscribe_event;
1235 event->action = cpu_to_le16(cmd_act_get);
1236 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1237 libertas_queue_cmd(adapter, pcmdnode, 1);
1238 wake_up_interruptible(&priv->mainthread.waitq);
1240 /* Sleep until response is generated by FW */
1241 wait_event_interruptible(pcmdnode->cmdwait_q,
1242 pcmdnode->cmdwaitqwoken);
1244 pcmdptr = response_buf;
1246 if (pcmdptr->result) {
1247 lbs_pr_err("%s: fail, result=%d\n", __func__,
1248 le16_to_cpu(pcmdptr->result));
1249 kfree(response_buf);
1254 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
1255 lbs_pr_err("command response incorrect!\n");
1256 kfree(response_buf);
1261 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1262 event = (void *)(response_buf + S_DS_GEN);
1263 while (cmd_len < le16_to_cpu(pcmdptr->size)) {
1264 struct mrvlietypesheader *header = (void *)(response_buf + cmd_len);
1265 switch (header->type) {
1266 struct mrvlietypes_snrthreshold *HighSnr;
1267 case __constant_cpu_to_le16(TLV_TYPE_SNR_HIGH):
1268 HighSnr = (void *)(response_buf + cmd_len);
1269 pos += snprintf(buf+pos, len-pos, "%d %d %d\n",
1272 (event->events & cpu_to_le16(0x0020))?1:0);
1274 cmd_len += sizeof(struct mrvlietypes_snrthreshold);
1279 kfree(response_buf);
1281 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1286 static ssize_t libertas_highsnr_write(struct file *file,
1287 const char __user *userbuf,
1288 size_t count, loff_t *ppos)
1290 wlan_private *priv = file->private_data;
1291 wlan_adapter *adapter = priv->adapter;
1292 ssize_t res, buf_size;
1293 int value, freq, subscribed, cmd_len;
1294 struct cmd_ctrl_node *pcmdnode;
1295 struct cmd_ds_command *pcmdptr;
1296 struct cmd_ds_802_11_subscribe_event *event;
1297 struct mrvlietypes_snrthreshold *snr_threshold;
1301 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1302 char *buf = (char *)addr;
1304 buf_size = min(count, len - 1);
1305 if (copy_from_user(buf, userbuf, buf_size)) {
1309 res = sscanf(buf, "%d %d %d", &value, &freq, &subscribed);
1315 event_bitmap = libertas_get_events_bitmap(priv);
1317 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1321 event = &pcmdptr->params.subscribe_event;
1322 event->action = cpu_to_le16(cmd_act_set);
1323 pcmdptr->size = cpu_to_le16(S_DS_GEN +
1324 sizeof(struct cmd_ds_802_11_subscribe_event) +
1325 sizeof(struct mrvlietypes_snrthreshold));
1326 cmd_len = S_DS_GEN + sizeof(struct cmd_ds_802_11_subscribe_event);
1327 ptr = (u8*) pcmdptr+cmd_len;
1328 snr_threshold = (struct mrvlietypes_snrthreshold *)(ptr);
1329 snr_threshold->header.type = cpu_to_le16(TLV_TYPE_SNR_HIGH);
1330 snr_threshold->header.len = cpu_to_le16(2);
1331 snr_threshold->snrvalue = value;
1332 snr_threshold->snrfreq = freq;
1333 event_bitmap |= subscribed ? 0x0020 : 0x0;
1334 event->events = cpu_to_le16(event_bitmap);
1336 libertas_queue_cmd(adapter, pcmdnode, 1);
1337 wake_up_interruptible(&priv->mainthread.waitq);
1339 /* Sleep until response is generated by FW */
1340 wait_event_interruptible(pcmdnode->cmdwait_q,
1341 pcmdnode->cmdwaitqwoken);
1343 pcmdptr = response_buf;
1345 if (pcmdptr->result) {
1346 lbs_pr_err("%s: fail, result=%d\n", __func__,
1347 le16_to_cpu(pcmdptr->result));
1348 kfree(response_buf);
1353 if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {
1354 lbs_pr_err("command response incorrect!\n");
1355 kfree(response_buf);
1366 static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1367 size_t count, loff_t *ppos)
1369 wlan_private *priv = file->private_data;
1370 wlan_adapter *adapter = priv->adapter;
1371 struct wlan_offset_value offval;
1374 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1375 char *buf = (char *)addr;
1377 offval.offset = priv->mac_offset;
1380 ret = libertas_prepare_and_send_command(priv,
1381 cmd_mac_reg_access, 0,
1382 cmd_option_waitforrsp, 0, &offval);
1384 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
1385 priv->mac_offset, adapter->offsetvalue.value);
1387 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1392 static ssize_t libertas_rdmac_write(struct file *file,
1393 const char __user *userbuf,
1394 size_t count, loff_t *ppos)
1396 wlan_private *priv = file->private_data;
1397 ssize_t res, buf_size;
1398 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1399 char *buf = (char *)addr;
1401 buf_size = min(count, len - 1);
1402 if (copy_from_user(buf, userbuf, buf_size)) {
1406 priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
1413 static ssize_t libertas_wrmac_write(struct file *file,
1414 const char __user *userbuf,
1415 size_t count, loff_t *ppos)
1418 wlan_private *priv = file->private_data;
1419 ssize_t res, buf_size;
1421 struct wlan_offset_value offval;
1422 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1423 char *buf = (char *)addr;
1425 buf_size = min(count, len - 1);
1426 if (copy_from_user(buf, userbuf, buf_size)) {
1430 res = sscanf(buf, "%x %x", &offset, &value);
1436 offval.offset = offset;
1437 offval.value = value;
1438 res = libertas_prepare_and_send_command(priv,
1439 cmd_mac_reg_access, 1,
1440 cmd_option_waitforrsp, 0, &offval);
1449 static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1450 size_t count, loff_t *ppos)
1452 wlan_private *priv = file->private_data;
1453 wlan_adapter *adapter = priv->adapter;
1454 struct wlan_offset_value offval;
1457 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1458 char *buf = (char *)addr;
1460 offval.offset = priv->bbp_offset;
1463 ret = libertas_prepare_and_send_command(priv,
1464 cmd_bbp_reg_access, 0,
1465 cmd_option_waitforrsp, 0, &offval);
1467 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
1468 priv->bbp_offset, adapter->offsetvalue.value);
1470 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1476 static ssize_t libertas_rdbbp_write(struct file *file,
1477 const char __user *userbuf,
1478 size_t count, loff_t *ppos)
1480 wlan_private *priv = file->private_data;
1481 ssize_t res, buf_size;
1482 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1483 char *buf = (char *)addr;
1485 buf_size = min(count, len - 1);
1486 if (copy_from_user(buf, userbuf, buf_size)) {
1490 priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
1497 static ssize_t libertas_wrbbp_write(struct file *file,
1498 const char __user *userbuf,
1499 size_t count, loff_t *ppos)
1502 wlan_private *priv = file->private_data;
1503 ssize_t res, buf_size;
1505 struct wlan_offset_value offval;
1506 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1507 char *buf = (char *)addr;
1509 buf_size = min(count, len - 1);
1510 if (copy_from_user(buf, userbuf, buf_size)) {
1514 res = sscanf(buf, "%x %x", &offset, &value);
1520 offval.offset = offset;
1521 offval.value = value;
1522 res = libertas_prepare_and_send_command(priv,
1523 cmd_bbp_reg_access, 1,
1524 cmd_option_waitforrsp, 0, &offval);
1533 static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1534 size_t count, loff_t *ppos)
1536 wlan_private *priv = file->private_data;
1537 wlan_adapter *adapter = priv->adapter;
1538 struct wlan_offset_value offval;
1541 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1542 char *buf = (char *)addr;
1544 offval.offset = priv->rf_offset;
1547 ret = libertas_prepare_and_send_command(priv,
1548 cmd_rf_reg_access, 0,
1549 cmd_option_waitforrsp, 0, &offval);
1551 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
1552 priv->rf_offset, adapter->offsetvalue.value);
1554 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
1560 static ssize_t libertas_rdrf_write(struct file *file,
1561 const char __user *userbuf,
1562 size_t count, loff_t *ppos)
1564 wlan_private *priv = file->private_data;
1565 ssize_t res, buf_size;
1566 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1567 char *buf = (char *)addr;
1569 buf_size = min(count, len - 1);
1570 if (copy_from_user(buf, userbuf, buf_size)) {
1574 priv->rf_offset = simple_strtoul((char *)buf, NULL, 16);
1581 static ssize_t libertas_wrrf_write(struct file *file,
1582 const char __user *userbuf,
1583 size_t count, loff_t *ppos)
1586 wlan_private *priv = file->private_data;
1587 ssize_t res, buf_size;
1589 struct wlan_offset_value offval;
1590 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1591 char *buf = (char *)addr;
1593 buf_size = min(count, len - 1);
1594 if (copy_from_user(buf, userbuf, buf_size)) {
1598 res = sscanf(buf, "%x %x", &offset, &value);
1604 offval.offset = offset;
1605 offval.value = value;
1606 res = libertas_prepare_and_send_command(priv,
1607 cmd_rf_reg_access, 1,
1608 cmd_option_waitforrsp, 0, &offval);
1617 #define FOPS(fread, fwrite) { \
1618 .owner = THIS_MODULE, \
1619 .open = open_file_generic, \
1621 .write = (fwrite), \
1624 struct libertas_debugfs_files {
1627 struct file_operations fops;
1630 static struct libertas_debugfs_files debugfs_files[] = {
1631 { "info", 0444, FOPS(libertas_dev_info, write_file_dummy), },
1632 { "getscantable", 0444, FOPS(libertas_getscantable,
1633 write_file_dummy), },
1634 { "sleepparams", 0644, FOPS(libertas_sleepparams_read,
1635 libertas_sleepparams_write), },
1636 { "extscan", 0600, FOPS(NULL, libertas_extscan), },
1637 { "setuserscan", 0600, FOPS(NULL, libertas_setuserscan), },
1640 static struct libertas_debugfs_files debugfs_events_files[] = {
1641 {"low_rssi", 0644, FOPS(libertas_lowrssi_read,
1642 libertas_lowrssi_write), },
1643 {"low_snr", 0644, FOPS(libertas_lowsnr_read,
1644 libertas_lowsnr_write), },
1645 {"failure_count", 0644, FOPS(libertas_failcount_read,
1646 libertas_failcount_write), },
1647 {"beacon_missed", 0644, FOPS(libertas_bcnmiss_read,
1648 libertas_bcnmiss_write), },
1649 {"high_rssi", 0644, FOPS(libertas_highrssi_read,
1650 libertas_highrssi_write), },
1651 {"high_snr", 0644, FOPS(libertas_highsnr_read,
1652 libertas_highsnr_write), },
1655 static struct libertas_debugfs_files debugfs_regs_files[] = {
1656 {"rdmac", 0644, FOPS(libertas_rdmac_read, libertas_rdmac_write), },
1657 {"wrmac", 0600, FOPS(NULL, libertas_wrmac_write), },
1658 {"rdbbp", 0644, FOPS(libertas_rdbbp_read, libertas_rdbbp_write), },
1659 {"wrbbp", 0600, FOPS(NULL, libertas_wrbbp_write), },
1660 {"rdrf", 0644, FOPS(libertas_rdrf_read, libertas_rdrf_write), },
1661 {"wrrf", 0600, FOPS(NULL, libertas_wrrf_write), },
1664 void libertas_debugfs_init(void)
1667 libertas_dir = debugfs_create_dir("libertas_wireless", NULL);
1672 void libertas_debugfs_remove(void)
1675 debugfs_remove(libertas_dir);
1679 void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev)
1682 struct libertas_debugfs_files *files;
1686 priv->debugfs_dir = debugfs_create_dir(dev->name, libertas_dir);
1687 if (!priv->debugfs_dir)
1690 for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
1691 files = &debugfs_files[i];
1692 priv->debugfs_files[i] = debugfs_create_file(files->name,
1699 priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
1700 if (!priv->events_dir)
1703 for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
1704 files = &debugfs_events_files[i];
1705 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
1712 priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
1713 if (!priv->regs_dir)
1716 for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
1717 files = &debugfs_regs_files[i];
1718 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
1726 libertas_debug_init(priv, dev);
1732 void libertas_debugfs_remove_one(wlan_private *priv)
1736 for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
1737 debugfs_remove(priv->debugfs_regs_files[i]);
1739 debugfs_remove(priv->regs_dir);
1741 for(i=0; i<ARRAY_SIZE(debugfs_events_files); i++)
1742 debugfs_remove(priv->debugfs_events_files[i]);
1744 debugfs_remove(priv->events_dir);
1746 debugfs_remove(priv->debugfs_debug);
1748 for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
1749 debugfs_remove(priv->debugfs_files[i]);
1750 debugfs_remove(priv->debugfs_dir);
1759 #define item_size(n) (FIELD_SIZEOF(wlan_adapter, n))
1760 #define item_addr(n) (offsetof(wlan_adapter, n))
1769 /* To debug any member of wlan_adapter, simply add one line here.
1771 static struct debug_data items[] = {
1772 {"intcounter", item_size(intcounter), item_addr(intcounter)},
1773 {"psmode", item_size(psmode), item_addr(psmode)},
1774 {"psstate", item_size(psstate), item_addr(psstate)},
1777 static int num_of_items = ARRAY_SIZE(items);
1780 * @brief proc read function
1782 * @param page pointer to buffer
1783 * @param s read data starting position
1785 * @param cnt counter
1786 * @param eof end of file flag
1787 * @param data data to output
1788 * @return number of output data
1790 static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf,
1791 size_t count, loff_t *ppos)
1798 struct debug_data *d;
1799 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1800 char *buf = (char *)addr;
1804 d = (struct debug_data *)file->private_data;
1806 for (i = 0; i < num_of_items; i++) {
1808 val = *((u8 *) d[i].addr);
1809 else if (d[i].size == 2)
1810 val = *((u16 *) d[i].addr);
1811 else if (d[i].size == 4)
1812 val = *((u32 *) d[i].addr);
1813 else if (d[i].size == 8)
1814 val = *((u64 *) d[i].addr);
1816 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
1819 res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
1826 * @brief proc write function
1828 * @param f file pointer
1829 * @param buf pointer to data buffer
1830 * @param cnt data number to write
1831 * @param data data to write
1832 * @return number of data
1834 static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf,
1835 size_t cnt, loff_t *ppos)
1843 struct debug_data *d = (struct debug_data *)f->private_data;
1845 pdata = (char *)kmalloc(cnt, GFP_KERNEL);
1849 if (copy_from_user(pdata, buf, cnt)) {
1850 lbs_deb_debugfs("Copy from user failed\n");
1856 for (i = 0; i < num_of_items; i++) {
1858 p = strstr(p0, d[i].name);
1861 p1 = strchr(p, '\n');
1865 p2 = strchr(p, '=');
1869 r = simple_strtoul(p2, NULL, 0);
1871 *((u8 *) d[i].addr) = (u8) r;
1872 else if (d[i].size == 2)
1873 *((u16 *) d[i].addr) = (u16) r;
1874 else if (d[i].size == 4)
1875 *((u32 *) d[i].addr) = (u32) r;
1876 else if (d[i].size == 8)
1877 *((u64 *) d[i].addr) = (u64) r;
1883 return (ssize_t)cnt;
1886 static struct file_operations libertas_debug_fops = {
1887 .owner = THIS_MODULE,
1888 .open = open_file_generic,
1889 .write = wlan_debugfs_write,
1890 .read = wlan_debugfs_read,
1894 * @brief create debug proc file
1896 * @param priv pointer wlan_private
1897 * @param dev pointer net_device
1900 static void libertas_debug_init(wlan_private * priv, struct net_device *dev)
1904 if (!priv->debugfs_dir)
1907 for (i = 0; i < num_of_items; i++)
1908 items[i].addr += (size_t) priv->adapter;
1910 priv->debugfs_debug = debugfs_create_file("debug", 0644,
1911 priv->debugfs_dir, &items[0],
1912 &libertas_debug_fops);