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