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