1#include <linux/module.h>
2#include <linux/dcache.h>
3#include <linux/debugfs.h>
4#include <linux/delay.h>
5#include <linux/mm.h>
6#include <linux/string.h>
7#include <net/iw_handler.h>
8#include <net/lib80211.h>
9
10#include "dev.h"
11#include "decl.h"
12#include "host.h"
13#include "debugfs.h"
14#include "cmd.h"
15
16static struct dentry *lbs_dir;
17static char *szStates[] = {
18 "Connected",
19 "Disconnected"
20};
21
22#ifdef PROC_DEBUG
23static void lbs_debug_init(struct lbs_private *priv);
24#endif
25
26static int open_file_generic(struct inode *inode, struct file *file)
27{
28 file->private_data = inode->i_private;
29 return 0;
30}
31
32static ssize_t write_file_dummy(struct file *file, const char __user *buf,
33 size_t count, loff_t *ppos)
34{
35 return -EINVAL;
36}
37
38static const size_t len = PAGE_SIZE;
39
40static ssize_t lbs_dev_info(struct file *file, char __user *userbuf,
41 size_t count, loff_t *ppos)
42{
43 struct lbs_private *priv = file->private_data;
44 size_t pos = 0;
45 unsigned long addr = get_zeroed_page(GFP_KERNEL);
46 char *buf = (char *)addr;
47 ssize_t res;
48 if (!buf)
49 return -ENOMEM;
50
51 pos += snprintf(buf+pos, len-pos, "state = %s\n",
52 szStates[priv->connect_status]);
53 pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
54 (u32) priv->regioncode);
55
56 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
57
58 free_page(addr);
59 return res;
60}
61
62
63static ssize_t lbs_getscantable(struct file *file, char __user *userbuf,
64 size_t count, loff_t *ppos)
65{
66 struct lbs_private *priv = file->private_data;
67 size_t pos = 0;
68 int numscansdone = 0, res;
69 unsigned long addr = get_zeroed_page(GFP_KERNEL);
70 char *buf = (char *)addr;
71 DECLARE_SSID_BUF(ssid);
72 struct bss_descriptor * iter_bss;
73 if (!buf)
74 return -ENOMEM;
75
76 pos += snprintf(buf+pos, len-pos,
77 "# | ch | rssi | bssid | cap | Qual | SSID \n");
78
79 mutex_lock(&priv->lock);
80 list_for_each_entry (iter_bss, &priv->network_list, list) {
81 u16 ibss = (iter_bss->capability & WLAN_CAPABILITY_IBSS);
82 u16 privacy = (iter_bss->capability & WLAN_CAPABILITY_PRIVACY);
83 u16 spectrum_mgmt = (iter_bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT);
84
85 pos += snprintf(buf+pos, len-pos, "%02u| %03d | %04d | %pM |",
86 numscansdone, iter_bss->channel, iter_bss->rssi,
87 iter_bss->bssid);
88 pos += snprintf(buf+pos, len-pos, " %04x-", iter_bss->capability);
89 pos += snprintf(buf+pos, len-pos, "%c%c%c |",
90 ibss ? 'A' : 'I', privacy ? 'P' : ' ',
91 spectrum_mgmt ? 'S' : ' ');
92 pos += snprintf(buf+pos, len-pos, " %04d |", SCAN_RSSI(iter_bss->rssi));
93 pos += snprintf(buf+pos, len-pos, " %s\n",
94 print_ssid(ssid, iter_bss->ssid,
95 iter_bss->ssid_len));
96
97 numscansdone++;
98 }
99 mutex_unlock(&priv->lock);
100
101 res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
102
103 free_page(addr);
104 return res;
105}
106
107static ssize_t lbs_sleepparams_write(struct file *file,
108 const char __user *user_buf, size_t count,
109 loff_t *ppos)
110{
111 struct lbs_private *priv = file->private_data;
112 ssize_t buf_size, ret;
113 struct sleep_params sp;
114 int p1, p2, p3, p4, p5, p6;
115 unsigned long addr = get_zeroed_page(GFP_KERNEL);
116 char *buf = (char *)addr;
117 if (!buf)
118 return -ENOMEM;
119
120 buf_size = min(count, len - 1);
121 if (copy_from_user(buf, user_buf, buf_size)) {
122 ret = -EFAULT;
123 goto out_unlock;
124 }
125 ret = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6);
126 if (ret != 6) {
127 ret = -EINVAL;
128 goto out_unlock;
129 }
130 sp.sp_error = p1;
131 sp.sp_offset = p2;
132 sp.sp_stabletime = p3;
133 sp.sp_calcontrol = p4;
134 sp.sp_extsleepclk = p5;
135 sp.sp_reserved = p6;
136
137 ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_SET, &sp);
138 if (!ret)
139 ret = count;
140 else if (ret > 0)
141 ret = -EINVAL;
142
143out_unlock:
144 free_page(addr);
145 return ret;
146}
147
148static ssize_t lbs_sleepparams_read(struct file *file, char __user *userbuf,
149 size_t count, loff_t *ppos)
150{
151 struct lbs_private *priv = file->private_data;
152 ssize_t ret;
153 size_t pos = 0;
154 struct sleep_params sp;
155 unsigned long addr = get_zeroed_page(GFP_KERNEL);
156 char *buf = (char *)addr;
157 if (!buf)
158 return -ENOMEM;
159
160 ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_GET, &sp);
161 if (ret)
162 goto out_unlock;
163
164 pos += snprintf(buf, len, "%d %d %d %d %d %d\n", sp.sp_error,
165 sp.sp_offset, sp.sp_stabletime,
166 sp.sp_calcontrol, sp.sp_extsleepclk,
167 sp.sp_reserved);
168
169 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
170
171out_unlock:
172 free_page(addr);
173 return ret;
174}
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192static void *lbs_tlv_find(uint16_t tlv_type, const uint8_t *tlv, uint16_t size)
193{
194 struct mrvl_ie_header *tlv_h;
195 uint16_t length;
196 ssize_t pos = 0;
197
198 while (pos < size) {
199 tlv_h = (struct mrvl_ie_header *) tlv;
200 if (!tlv_h->len)
201 return NULL;
202 if (tlv_h->type == cpu_to_le16(tlv_type))
203 return tlv_h;
204 length = le16_to_cpu(tlv_h->len) + sizeof(*tlv_h);
205 pos += length;
206 tlv += length;
207 }
208 return NULL;
209}
210
211
212static ssize_t lbs_threshold_read(uint16_t tlv_type, uint16_t event_mask,
213 struct file *file, char __user *userbuf,
214 size_t count, loff_t *ppos)
215{
216 struct cmd_ds_802_11_subscribe_event *subscribed;
217 struct mrvl_ie_thresholds *got;
218 struct lbs_private *priv = file->private_data;
219 ssize_t ret = 0;
220 size_t pos = 0;
221 char *buf;
222 u8 value;
223 u8 freq;
224 int events = 0;
225
226 buf = (char *)get_zeroed_page(GFP_KERNEL);
227 if (!buf)
228 return -ENOMEM;
229
230 subscribed = kzalloc(sizeof(*subscribed), GFP_KERNEL);
231 if (!subscribed) {
232 ret = -ENOMEM;
233 goto out_page;
234 }
235
236 subscribed->hdr.size = cpu_to_le16(sizeof(*subscribed));
237 subscribed->action = cpu_to_le16(CMD_ACT_GET);
238
239 ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, subscribed);
240 if (ret)
241 goto out_cmd;
242
243 got = lbs_tlv_find(tlv_type, subscribed->tlv, sizeof(subscribed->tlv));
244 if (got) {
245 value = got->value;
246 freq = got->freq;
247 events = le16_to_cpu(subscribed->events);
248
249 pos += snprintf(buf, len, "%d %d %d\n", value, freq,
250 !!(events & event_mask));
251 }
252
253 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
254
255 out_cmd:
256 kfree(subscribed);
257
258 out_page:
259 free_page((unsigned long)buf);
260 return ret;
261}
262
263
264static ssize_t lbs_threshold_write(uint16_t tlv_type, uint16_t event_mask,
265 struct file *file,
266 const char __user *userbuf, size_t count,
267 loff_t *ppos)
268{
269 struct cmd_ds_802_11_subscribe_event *events;
270 struct mrvl_ie_thresholds *tlv;
271 struct lbs_private *priv = file->private_data;
272 ssize_t buf_size;
273 int value, freq, new_mask;
274 uint16_t curr_mask;
275 char *buf;
276 int ret;
277
278 buf = (char *)get_zeroed_page(GFP_KERNEL);
279 if (!buf)
280 return -ENOMEM;
281
282 buf_size = min(count, len - 1);
283 if (copy_from_user(buf, userbuf, buf_size)) {
284 ret = -EFAULT;
285 goto out_page;
286 }
287 ret = sscanf(buf, "%d %d %d", &value, &freq, &new_mask);
288 if (ret != 3) {
289 ret = -EINVAL;
290 goto out_page;
291 }
292 events = kzalloc(sizeof(*events), GFP_KERNEL);
293 if (!events) {
294 ret = -ENOMEM;
295 goto out_page;
296 }
297
298 events->hdr.size = cpu_to_le16(sizeof(*events));
299 events->action = cpu_to_le16(CMD_ACT_GET);
300
301 ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events);
302 if (ret)
303 goto out_events;
304
305 curr_mask = le16_to_cpu(events->events);
306
307 if (new_mask)
308 new_mask = curr_mask | event_mask;
309 else
310 new_mask = curr_mask & ~event_mask;
311
312
313
314 tlv = (void *)events->tlv;
315
316 events->action = cpu_to_le16(CMD_ACT_SET);
317 events->events = cpu_to_le16(new_mask);
318 tlv->header.type = cpu_to_le16(tlv_type);
319 tlv->header.len = cpu_to_le16(sizeof(*tlv) - sizeof(tlv->header));
320 tlv->value = value;
321 if (tlv_type != TLV_TYPE_BCNMISS)
322 tlv->freq = freq;
323
324
325 events->hdr.size = cpu_to_le16(sizeof(events->hdr) + 4 + sizeof(*tlv));
326
327 ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events);
328
329 if (!ret)
330 ret = count;
331 out_events:
332 kfree(events);
333 out_page:
334 free_page((unsigned long)buf);
335 return ret;
336}
337
338
339static ssize_t lbs_lowrssi_read(struct file *file, char __user *userbuf,
340 size_t count, loff_t *ppos)
341{
342 return lbs_threshold_read(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW,
343 file, userbuf, count, ppos);
344}
345
346
347static ssize_t lbs_lowrssi_write(struct file *file, const char __user *userbuf,
348 size_t count, loff_t *ppos)
349{
350 return lbs_threshold_write(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW,
351 file, userbuf, count, ppos);
352}
353
354
355static ssize_t lbs_lowsnr_read(struct file *file, char __user *userbuf,
356 size_t count, loff_t *ppos)
357{
358 return lbs_threshold_read(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW,
359 file, userbuf, count, ppos);
360}
361
362
363static ssize_t lbs_lowsnr_write(struct file *file, const char __user *userbuf,
364 size_t count, loff_t *ppos)
365{
366 return lbs_threshold_write(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW,
367 file, userbuf, count, ppos);
368}
369
370
371static ssize_t lbs_failcount_read(struct file *file, char __user *userbuf,
372 size_t count, loff_t *ppos)
373{
374 return lbs_threshold_read(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT,
375 file, userbuf, count, ppos);
376}
377
378
379static ssize_t lbs_failcount_write(struct file *file, const char __user *userbuf,
380 size_t count, loff_t *ppos)
381{
382 return lbs_threshold_write(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT,
383 file, userbuf, count, ppos);
384}
385
386
387static ssize_t lbs_highrssi_read(struct file *file, char __user *userbuf,
388 size_t count, loff_t *ppos)
389{
390 return lbs_threshold_read(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH,
391 file, userbuf, count, ppos);
392}
393
394
395static ssize_t lbs_highrssi_write(struct file *file, const char __user *userbuf,
396 size_t count, loff_t *ppos)
397{
398 return lbs_threshold_write(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH,
399 file, userbuf, count, ppos);
400}
401
402
403static ssize_t lbs_highsnr_read(struct file *file, char __user *userbuf,
404 size_t count, loff_t *ppos)
405{
406 return lbs_threshold_read(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH,
407 file, userbuf, count, ppos);
408}
409
410
411static ssize_t lbs_highsnr_write(struct file *file, const char __user *userbuf,
412 size_t count, loff_t *ppos)
413{
414 return lbs_threshold_write(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH,
415 file, userbuf, count, ppos);
416}
417
418static ssize_t lbs_bcnmiss_read(struct file *file, char __user *userbuf,
419 size_t count, loff_t *ppos)
420{
421 return lbs_threshold_read(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS,
422 file, userbuf, count, ppos);
423}
424
425
426static ssize_t lbs_bcnmiss_write(struct file *file, const char __user *userbuf,
427 size_t count, loff_t *ppos)
428{
429 return lbs_threshold_write(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS,
430 file, userbuf, count, ppos);
431}
432
433
434
435static ssize_t lbs_rdmac_read(struct file *file, char __user *userbuf,
436 size_t count, loff_t *ppos)
437{
438 struct lbs_private *priv = file->private_data;
439 struct lbs_offset_value offval;
440 ssize_t pos = 0;
441 int ret;
442 unsigned long addr = get_zeroed_page(GFP_KERNEL);
443 char *buf = (char *)addr;
444 if (!buf)
445 return -ENOMEM;
446
447 offval.offset = priv->mac_offset;
448 offval.value = 0;
449
450 ret = lbs_prepare_and_send_command(priv,
451 CMD_MAC_REG_ACCESS, 0,
452 CMD_OPTION_WAITFORRSP, 0, &offval);
453 mdelay(10);
454 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
455 priv->mac_offset, priv->offsetvalue.value);
456
457 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
458 free_page(addr);
459 return ret;
460}
461
462static ssize_t lbs_rdmac_write(struct file *file,
463 const char __user *userbuf,
464 size_t count, loff_t *ppos)
465{
466 struct lbs_private *priv = file->private_data;
467 ssize_t res, buf_size;
468 unsigned long addr = get_zeroed_page(GFP_KERNEL);
469 char *buf = (char *)addr;
470 if (!buf)
471 return -ENOMEM;
472
473 buf_size = min(count, len - 1);
474 if (copy_from_user(buf, userbuf, buf_size)) {
475 res = -EFAULT;
476 goto out_unlock;
477 }
478 priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
479 res = count;
480out_unlock:
481 free_page(addr);
482 return res;
483}
484
485static ssize_t lbs_wrmac_write(struct file *file,
486 const char __user *userbuf,
487 size_t count, loff_t *ppos)
488{
489
490 struct lbs_private *priv = file->private_data;
491 ssize_t res, buf_size;
492 u32 offset, value;
493 struct lbs_offset_value offval;
494 unsigned long addr = get_zeroed_page(GFP_KERNEL);
495 char *buf = (char *)addr;
496 if (!buf)
497 return -ENOMEM;
498
499 buf_size = min(count, len - 1);
500 if (copy_from_user(buf, userbuf, buf_size)) {
501 res = -EFAULT;
502 goto out_unlock;
503 }
504 res = sscanf(buf, "%x %x", &offset, &value);
505 if (res != 2) {
506 res = -EFAULT;
507 goto out_unlock;
508 }
509
510 offval.offset = offset;
511 offval.value = value;
512 res = lbs_prepare_and_send_command(priv,
513 CMD_MAC_REG_ACCESS, 1,
514 CMD_OPTION_WAITFORRSP, 0, &offval);
515 mdelay(10);
516
517 res = count;
518out_unlock:
519 free_page(addr);
520 return res;
521}
522
523static ssize_t lbs_rdbbp_read(struct file *file, char __user *userbuf,
524 size_t count, loff_t *ppos)
525{
526 struct lbs_private *priv = file->private_data;
527 struct lbs_offset_value offval;
528 ssize_t pos = 0;
529 int ret;
530 unsigned long addr = get_zeroed_page(GFP_KERNEL);
531 char *buf = (char *)addr;
532 if (!buf)
533 return -ENOMEM;
534
535 offval.offset = priv->bbp_offset;
536 offval.value = 0;
537
538 ret = lbs_prepare_and_send_command(priv,
539 CMD_BBP_REG_ACCESS, 0,
540 CMD_OPTION_WAITFORRSP, 0, &offval);
541 mdelay(10);
542 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
543 priv->bbp_offset, priv->offsetvalue.value);
544
545 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
546 free_page(addr);
547
548 return ret;
549}
550
551static ssize_t lbs_rdbbp_write(struct file *file,
552 const char __user *userbuf,
553 size_t count, loff_t *ppos)
554{
555 struct lbs_private *priv = file->private_data;
556 ssize_t res, buf_size;
557 unsigned long addr = get_zeroed_page(GFP_KERNEL);
558 char *buf = (char *)addr;
559 if (!buf)
560 return -ENOMEM;
561
562 buf_size = min(count, len - 1);
563 if (copy_from_user(buf, userbuf, buf_size)) {
564 res = -EFAULT;
565 goto out_unlock;
566 }
567 priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
568 res = count;
569out_unlock:
570 free_page(addr);
571 return res;
572}
573
574static ssize_t lbs_wrbbp_write(struct file *file,
575 const char __user *userbuf,
576 size_t count, loff_t *ppos)
577{
578
579 struct lbs_private *priv = file->private_data;
580 ssize_t res, buf_size;
581 u32 offset, value;
582 struct lbs_offset_value offval;
583 unsigned long addr = get_zeroed_page(GFP_KERNEL);
584 char *buf = (char *)addr;
585 if (!buf)
586 return -ENOMEM;
587
588 buf_size = min(count, len - 1);
589 if (copy_from_user(buf, userbuf, buf_size)) {
590 res = -EFAULT;
591 goto out_unlock;
592 }
593 res = sscanf(buf, "%x %x", &offset, &value);
594 if (res != 2) {
595 res = -EFAULT;
596 goto out_unlock;
597 }
598
599 offval.offset = offset;
600 offval.value = value;
601 res = lbs_prepare_and_send_command(priv,
602 CMD_BBP_REG_ACCESS, 1,
603 CMD_OPTION_WAITFORRSP, 0, &offval);
604 mdelay(10);
605
606 res = count;
607out_unlock:
608 free_page(addr);
609 return res;
610}
611
612static ssize_t lbs_rdrf_read(struct file *file, char __user *userbuf,
613 size_t count, loff_t *ppos)
614{
615 struct lbs_private *priv = file->private_data;
616 struct lbs_offset_value offval;
617 ssize_t pos = 0;
618 int ret;
619 unsigned long addr = get_zeroed_page(GFP_KERNEL);
620 char *buf = (char *)addr;
621 if (!buf)
622 return -ENOMEM;
623
624 offval.offset = priv->rf_offset;
625 offval.value = 0;
626
627 ret = lbs_prepare_and_send_command(priv,
628 CMD_RF_REG_ACCESS, 0,
629 CMD_OPTION_WAITFORRSP, 0, &offval);
630 mdelay(10);
631 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
632 priv->rf_offset, priv->offsetvalue.value);
633
634 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
635 free_page(addr);
636
637 return ret;
638}
639
640static ssize_t lbs_rdrf_write(struct file *file,
641 const char __user *userbuf,
642 size_t count, loff_t *ppos)
643{
644 struct lbs_private *priv = file->private_data;
645 ssize_t res, buf_size;
646 unsigned long addr = get_zeroed_page(GFP_KERNEL);
647 char *buf = (char *)addr;
648 if (!buf)
649 return -ENOMEM;
650
651 buf_size = min(count, len - 1);
652 if (copy_from_user(buf, userbuf, buf_size)) {
653 res = -EFAULT;
654 goto out_unlock;
655 }
656 priv->rf_offset = simple_strtoul(buf, NULL, 16);
657 res = count;
658out_unlock:
659 free_page(addr);
660 return res;
661}
662
663static ssize_t lbs_wrrf_write(struct file *file,
664 const char __user *userbuf,
665 size_t count, loff_t *ppos)
666{
667
668 struct lbs_private *priv = file->private_data;
669 ssize_t res, buf_size;
670 u32 offset, value;
671 struct lbs_offset_value offval;
672 unsigned long addr = get_zeroed_page(GFP_KERNEL);
673 char *buf = (char *)addr;
674 if (!buf)
675 return -ENOMEM;
676
677 buf_size = min(count, len - 1);
678 if (copy_from_user(buf, userbuf, buf_size)) {
679 res = -EFAULT;
680 goto out_unlock;
681 }
682 res = sscanf(buf, "%x %x", &offset, &value);
683 if (res != 2) {
684 res = -EFAULT;
685 goto out_unlock;
686 }
687
688 offval.offset = offset;
689 offval.value = value;
690 res = lbs_prepare_and_send_command(priv,
691 CMD_RF_REG_ACCESS, 1,
692 CMD_OPTION_WAITFORRSP, 0, &offval);
693 mdelay(10);
694
695 res = count;
696out_unlock:
697 free_page(addr);
698 return res;
699}
700
701#define FOPS(fread, fwrite) { \
702 .owner = THIS_MODULE, \
703 .open = open_file_generic, \
704 .read = (fread), \
705 .write = (fwrite), \
706}
707
708struct lbs_debugfs_files {
709 const char *name;
710 int perm;
711 struct file_operations fops;
712};
713
714static const struct lbs_debugfs_files debugfs_files[] = {
715 { "info", 0444, FOPS(lbs_dev_info, write_file_dummy), },
716 { "getscantable", 0444, FOPS(lbs_getscantable,
717 write_file_dummy), },
718 { "sleepparams", 0644, FOPS(lbs_sleepparams_read,
719 lbs_sleepparams_write), },
720};
721
722static const struct lbs_debugfs_files debugfs_events_files[] = {
723 {"low_rssi", 0644, FOPS(lbs_lowrssi_read,
724 lbs_lowrssi_write), },
725 {"low_snr", 0644, FOPS(lbs_lowsnr_read,
726 lbs_lowsnr_write), },
727 {"failure_count", 0644, FOPS(lbs_failcount_read,
728 lbs_failcount_write), },
729 {"beacon_missed", 0644, FOPS(lbs_bcnmiss_read,
730 lbs_bcnmiss_write), },
731 {"high_rssi", 0644, FOPS(lbs_highrssi_read,
732 lbs_highrssi_write), },
733 {"high_snr", 0644, FOPS(lbs_highsnr_read,
734 lbs_highsnr_write), },
735};
736
737static const struct lbs_debugfs_files debugfs_regs_files[] = {
738 {"rdmac", 0644, FOPS(lbs_rdmac_read, lbs_rdmac_write), },
739 {"wrmac", 0600, FOPS(NULL, lbs_wrmac_write), },
740 {"rdbbp", 0644, FOPS(lbs_rdbbp_read, lbs_rdbbp_write), },
741 {"wrbbp", 0600, FOPS(NULL, lbs_wrbbp_write), },
742 {"rdrf", 0644, FOPS(lbs_rdrf_read, lbs_rdrf_write), },
743 {"wrrf", 0600, FOPS(NULL, lbs_wrrf_write), },
744};
745
746void lbs_debugfs_init(void)
747{
748 if (!lbs_dir)
749 lbs_dir = debugfs_create_dir("lbs_wireless", NULL);
750
751 return;
752}
753
754void lbs_debugfs_remove(void)
755{
756 if (lbs_dir)
757 debugfs_remove(lbs_dir);
758 return;
759}
760
761void lbs_debugfs_init_one(struct lbs_private *priv, struct net_device *dev)
762{
763 int i;
764 const struct lbs_debugfs_files *files;
765 if (!lbs_dir)
766 goto exit;
767
768 priv->debugfs_dir = debugfs_create_dir(dev->name, lbs_dir);
769 if (!priv->debugfs_dir)
770 goto exit;
771
772 for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
773 files = &debugfs_files[i];
774 priv->debugfs_files[i] = debugfs_create_file(files->name,
775 files->perm,
776 priv->debugfs_dir,
777 priv,
778 &files->fops);
779 }
780
781 priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
782 if (!priv->events_dir)
783 goto exit;
784
785 for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
786 files = &debugfs_events_files[i];
787 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
788 files->perm,
789 priv->events_dir,
790 priv,
791 &files->fops);
792 }
793
794 priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
795 if (!priv->regs_dir)
796 goto exit;
797
798 for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
799 files = &debugfs_regs_files[i];
800 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
801 files->perm,
802 priv->regs_dir,
803 priv,
804 &files->fops);
805 }
806
807#ifdef PROC_DEBUG
808 lbs_debug_init(priv);
809#endif
810exit:
811 return;
812}
813
814void lbs_debugfs_remove_one(struct lbs_private *priv)
815{
816 int i;
817
818 for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
819 debugfs_remove(priv->debugfs_regs_files[i]);
820
821 debugfs_remove(priv->regs_dir);
822
823 for(i=0; i<ARRAY_SIZE(debugfs_events_files); i++)
824 debugfs_remove(priv->debugfs_events_files[i]);
825
826 debugfs_remove(priv->events_dir);
827#ifdef PROC_DEBUG
828 debugfs_remove(priv->debugfs_debug);
829#endif
830 for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
831 debugfs_remove(priv->debugfs_files[i]);
832 debugfs_remove(priv->debugfs_dir);
833}
834
835
836
837
838
839#ifdef PROC_DEBUG
840
841#define item_size(n) (FIELD_SIZEOF(struct lbs_private, n))
842#define item_addr(n) (offsetof(struct lbs_private, n))
843
844
845struct debug_data {
846 char name[32];
847 u32 size;
848 size_t addr;
849};
850
851
852
853static struct debug_data items[] = {
854 {"psmode", item_size(psmode), item_addr(psmode)},
855 {"psstate", item_size(psstate), item_addr(psstate)},
856};
857
858static int num_of_items = ARRAY_SIZE(items);
859
860
861
862
863
864
865
866
867
868
869
870
871static ssize_t lbs_debugfs_read(struct file *file, char __user *userbuf,
872 size_t count, loff_t *ppos)
873{
874 int val = 0;
875 size_t pos = 0;
876 ssize_t res;
877 char *p;
878 int i;
879 struct debug_data *d;
880 unsigned long addr = get_zeroed_page(GFP_KERNEL);
881 char *buf = (char *)addr;
882 if (!buf)
883 return -ENOMEM;
884
885 p = buf;
886
887 d = (struct debug_data *)file->private_data;
888
889 for (i = 0; i < num_of_items; i++) {
890 if (d[i].size == 1)
891 val = *((u8 *) d[i].addr);
892 else if (d[i].size == 2)
893 val = *((u16 *) d[i].addr);
894 else if (d[i].size == 4)
895 val = *((u32 *) d[i].addr);
896 else if (d[i].size == 8)
897 val = *((u64 *) d[i].addr);
898
899 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
900 }
901
902 res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
903
904 free_page(addr);
905 return res;
906}
907
908
909
910
911
912
913
914
915
916
917static ssize_t lbs_debugfs_write(struct file *f, const char __user *buf,
918 size_t cnt, loff_t *ppos)
919{
920 int r, i;
921 char *pdata;
922 char *p;
923 char *p0;
924 char *p1;
925 char *p2;
926 struct debug_data *d = (struct debug_data *)f->private_data;
927
928 pdata = kmalloc(cnt, GFP_KERNEL);
929 if (pdata == NULL)
930 return 0;
931
932 if (copy_from_user(pdata, buf, cnt)) {
933 lbs_deb_debugfs("Copy from user failed\n");
934 kfree(pdata);
935 return 0;
936 }
937
938 p0 = pdata;
939 for (i = 0; i < num_of_items; i++) {
940 do {
941 p = strstr(p0, d[i].name);
942 if (p == NULL)
943 break;
944 p1 = strchr(p, '\n');
945 if (p1 == NULL)
946 break;
947 p0 = p1++;
948 p2 = strchr(p, '=');
949 if (!p2)
950 break;
951 p2++;
952 r = simple_strtoul(p2, NULL, 0);
953 if (d[i].size == 1)
954 *((u8 *) d[i].addr) = (u8) r;
955 else if (d[i].size == 2)
956 *((u16 *) d[i].addr) = (u16) r;
957 else if (d[i].size == 4)
958 *((u32 *) d[i].addr) = (u32) r;
959 else if (d[i].size == 8)
960 *((u64 *) d[i].addr) = (u64) r;
961 break;
962 } while (1);
963 }
964 kfree(pdata);
965
966 return (ssize_t)cnt;
967}
968
969static const struct file_operations lbs_debug_fops = {
970 .owner = THIS_MODULE,
971 .open = open_file_generic,
972 .write = lbs_debugfs_write,
973 .read = lbs_debugfs_read,
974};
975
976
977
978
979
980
981
982
983static void lbs_debug_init(struct lbs_private *priv)
984{
985 int i;
986
987 if (!priv->debugfs_dir)
988 return;
989
990 for (i = 0; i < num_of_items; i++)
991 items[i].addr += (size_t) priv;
992
993 priv->debugfs_debug = debugfs_create_file("debug", 0644,
994 priv->debugfs_dir, &items[0],
995 &lbs_debug_fops);
996}
997#endif
998
