?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / staging / rtl8192e / rtl_debug.c
blob22bc2dd6e4387aa95650931fc9fc73d5987218aa
1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 *
4 * Based on the r8180 driver, which is:
5 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 *
19 * The full GNU General Public License is included in this distribution in the
20 * file called LICENSE.
21 *
22 * Contact Information:
23 * wlanfae <wlanfae@realtek.com>
24 ******************************************************************************/
25 #include "rtl_debug.h"
26 #include "rtl_core.h"
27 #include "r8192E_phy.h"
28 #include "r8192E_phyreg.h"
29 #include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
30 #include "r8192E_cmdpkt.h"
31
32 u32 rt_global_debug_component = \
33 COMP_ERR ;
34
35 /*------------------Declare variable-----------------------*/
36 u32 DBGP_Type[DBGP_TYPE_MAX];
37
38 /*-----------------------------------------------------------------------------
39 * Function: DBGP_Flag_Init
40 *
41 * Overview: Refresh all debug print control flag content to zero.
42 *
43 * Input: NONE
44 *
45 * Output: NONE
46 *
47 * Return: NONE
48 *
49 * Revised History:
50 * When Who Remark
51 * 10/20/2006 MHC Create Version 0.
52 *
53 *---------------------------------------------------------------------------*/
54 void rtl8192_dbgp_flag_init(struct net_device *dev)
55 {
56 u8 i;
57
58 for (i = 0; i < DBGP_TYPE_MAX; i++)
59 DBGP_Type[i] = 0;
60
61
62 } /* DBGP_Flag_Init */
63
64 /* this is only for debugging */
65 void print_buffer(u32 *buffer, int len)
66 {
67 int i;
68 u8 *buf = (u8 *)buffer;
69
70 printk(KERN_INFO "ASCII BUFFER DUMP (len: %x):\n", len);
71
72 for (i = 0; i < len; i++)
73 printk(KERN_INFO "%c", buf[i]);
74
75 printk(KERN_INFO "\nBINARY BUFFER DUMP (len: %x):\n", len);
76
77 for (i = 0; i < len; i++)
78 printk(KERN_INFO "%x", buf[i]);
79
80 printk(KERN_INFO "\n");
81 }
82
83 /* this is only for debug */
84 void dump_eprom(struct net_device *dev)
85 {
86 int i;
87
88 for (i = 0; i < 0xff; i++)
89 RT_TRACE(COMP_INIT, "EEPROM addr %x : %x", i,
90 eprom_read(dev, i));
91 }
92
93 /* this is only for debug */
94 void rtl8192_dump_reg(struct net_device *dev)
95 {
96 int i;
97 int n;
98 int max = 0x5ff;
99
100 RT_TRACE(COMP_INIT, "Dumping NIC register map");
101
102 for (n = 0; n <= max; ) {
103 printk(KERN_INFO "\nD: %2x> ", n);
104 for (i = 0; i < 16 && n <= max; i++, n++)
105 printk(KERN_INFO "%2x ", read_nic_byte(dev, n));
106 }
107 printk(KERN_INFO "\n");
108 }
109
110 /****************************************************************************
111 -----------------------------PROCFS STUFF-------------------------
112 *****************************************************************************/
113 /*This part is related to PROC, which will record some statistics. */
114 static struct proc_dir_entry *rtl8192_proc;
115
116 static int proc_get_stats_ap(char *page, char **start,
117 off_t offset, int count,
118 int *eof, void *data)
119 {
120 struct net_device *dev = data;
121 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
122 struct rtllib_device *ieee = priv->rtllib;
123 struct rtllib_network *target;
124 int len = 0;
125
126 list_for_each_entry(target, &ieee->network_list, list) {
127
128 len += snprintf(page + len, count - len,
129 "%s ", target->ssid);
130
131 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
132 len += snprintf(page + len, count - len,
133 "WPA\n");
134 else
135 len += snprintf(page + len, count - len,
136 "non_WPA\n");
137
138 }
139
140 *eof = 1;
141 return len;
142 }
143
144 static int proc_get_registers_0(char *page, char **start,
145 off_t offset, int count,
146 int *eof, void *data)
147 {
148 struct net_device *dev = data;
149
150 int len = 0;
151 int i, n, page0;
152
153 int max = 0xff;
154 page0 = 0x000;
155
156 len += snprintf(page + len, count - len,
157 "\n####################page %x##################\n ",
158 (page0>>8));
159 len += snprintf(page + len, count - len,
160 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
161 "0C 0D 0E 0F");
162 for (n = 0; n <= max;) {
163 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
164 for (i = 0; i < 16 && n <= max; n++, i++)
165 len += snprintf(page + len, count - len,
166 "%2.2x ", read_nic_byte(dev,
167 (page0 | n)));
168 }
169 len += snprintf(page + len, count - len, "\n");
170 *eof = 1;
171 return len;
172
173 }
174 static int proc_get_registers_1(char *page, char **start,
175 off_t offset, int count,
176 int *eof, void *data)
177 {
178 struct net_device *dev = data;
179
180 int len = 0;
181 int i, n, page0;
182
183 int max = 0xff;
184 page0 = 0x100;
185
186 /* This dump the current register page */
187 len += snprintf(page + len, count - len,
188 "\n####################page %x##################\n ",
189 (page0>>8));
190 len += snprintf(page + len, count - len,
191 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
192 "0C 0D 0E 0F");
193 for (n = 0; n <= max;) {
194 len += snprintf(page + len, count - len,
195 "\nD: %2x > ", n);
196 for (i = 0; i < 16 && n <= max; i++, n++)
197 len += snprintf(page + len, count - len,
198 "%2.2x ", read_nic_byte(dev,
199 (page0 | n)));
200 }
201 len += snprintf(page + len, count - len, "\n");
202 *eof = 1;
203 return len;
204
205 }
206 static int proc_get_registers_2(char *page, char **start,
207 off_t offset, int count,
208 int *eof, void *data)
209 {
210 struct net_device *dev = data;
211
212 int len = 0;
213 int i, n, page0;
214
215 int max = 0xff;
216 page0 = 0x200;
217
218 /* This dump the current register page */
219 len += snprintf(page + len, count - len,
220 "\n####################page %x##################\n ",
221 (page0 >> 8));
222 len += snprintf(page + len, count - len,
223 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B 0C "
224 "0D 0E 0F");
225 for (n = 0; n <= max;) {
226 len += snprintf(page + len, count - len,
227 "\nD: %2x > ", n);
228 for (i = 0; i < 16 && n <= max; i++, n++)
229 len += snprintf(page + len, count - len,
230 "%2.2x ", read_nic_byte(dev,
231 (page0 | n)));
232 }
233 len += snprintf(page + len, count - len, "\n");
234 *eof = 1;
235 return len;
236
237 }
238 static int proc_get_registers_3(char *page, char **start,
239 off_t offset, int count,
240 int *eof, void *data)
241 {
242 struct net_device *dev = data;
243
244 int len = 0;
245 int i, n, page0;
246
247 int max = 0xff;
248 page0 = 0x300;
249
250 /* This dump the current register page */
251 len += snprintf(page + len, count - len,
252 "\n####################page %x##################\n ",
253 (page0>>8));
254 len += snprintf(page + len, count - len,
255 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
256 "0C 0D 0E 0F");
257 for (n = 0; n <= max;) {
258 len += snprintf(page + len, count - len,
259 "\nD: %2x > ", n);
260 for (i = 0; i < 16 && n <= max; i++, n++)
261 len += snprintf(page + len, count - len,
262 "%2.2x ", read_nic_byte(dev,
263 (page0 | n)));
264 }
265 len += snprintf(page + len, count - len, "\n");
266 *eof = 1;
267 return len;
268
269 }
270 static int proc_get_registers_4(char *page, char **start,
271 off_t offset, int count,
272 int *eof, void *data)
273 {
274 struct net_device *dev = data;
275
276 int len = 0;
277 int i, n, page0;
278
279 int max = 0xff;
280 page0 = 0x400;
281
282 /* This dump the current register page */
283 len += snprintf(page + len, count - len,
284 "\n####################page %x##################\n ",
285 (page0>>8));
286 len += snprintf(page + len, count - len,
287 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
288 "0C 0D 0E 0F");
289 for (n = 0; n <= max;) {
290 len += snprintf(page + len, count - len,
291 "\nD: %2x > ", n);
292 for (i = 0; i < 16 && n <= max; i++, n++)
293 len += snprintf(page + len, count - len,
294 "%2.2x ", read_nic_byte(dev,
295 (page0 | n)));
296 }
297 len += snprintf(page + len, count - len, "\n");
298 *eof = 1;
299 return len;
300
301 }
302 static int proc_get_registers_5(char *page, char **start,
303 off_t offset, int count,
304 int *eof, void *data)
305 {
306 struct net_device *dev = data;
307
308 int len = 0;
309 int i, n, page0;
310
311 int max = 0xff;
312 page0 = 0x500;
313
314 /* This dump the current register page */
315 len += snprintf(page + len, count - len,
316 "\n####################page %x##################\n ",
317 (page0 >> 8));
318 len += snprintf(page + len, count - len,
319 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
320 "0C 0D 0E 0F");
321 for (n = 0; n <= max;) {
322 len += snprintf(page + len, count - len,
323 "\nD: %2x > ", n);
324 for (i = 0; i < 16 && n <= max; i++, n++)
325 len += snprintf(page + len, count - len,
326 "%2.2x ", read_nic_byte(dev,
327 (page0 | n)));
328 }
329 len += snprintf(page + len, count - len, "\n");
330 *eof = 1;
331 return len;
332
333 }
334 static int proc_get_registers_6(char *page, char **start,
335 off_t offset, int count,
336 int *eof, void *data)
337 {
338 struct net_device *dev = data;
339
340 int len = 0;
341 int i, n, page0;
342
343 int max = 0xff;
344 page0 = 0x600;
345
346 /* This dump the current register page */
347 len += snprintf(page + len, count - len,
348 "\n####################page %x##################\n ",
349 (page0>>8));
350 len += snprintf(page + len, count - len,
351 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B "
352 "0C 0D 0E 0F");
353 for (n = 0; n <= max;) {
354 len += snprintf(page + len, count - len,
355 "\nD: %2x > ", n);
356 for (i = 0; i < 16 && n <= max; i++, n++)
357 len += snprintf(page + len, count - len,
358 "%2.2x ", read_nic_byte(dev,
359 (page0 | n)));
360 }
361 len += snprintf(page + len, count - len, "\n");
362 *eof = 1;
363 return len;
364
365 }
366 static int proc_get_registers_7(char *page, char **start,
367 off_t offset, int count,
368 int *eof, void *data)
369 {
370 struct net_device *dev = data;
371
372 int len = 0;
373 int i, n, page0;
374
375 int max = 0xff;
376 page0 = 0x700;
377
378 /* This dump the current register page */
379 len += snprintf(page + len, count - len,
380 "\n####################page %x##################\n ",
381 (page0 >> 8));
382 len += snprintf(page + len, count - len,
383 "\nD: OF > 00 01 02 03 04 05 06 07 08 09 0A 0B 0C "
384 "0D 0E 0F");
385 for (n = 0; n <= max;) {
386 len += snprintf(page + len, count - len,
387 "\nD: %2x > ", n);
388 for (i = 0; i < 16 && n <= max; i++, n++)
389 len += snprintf(page + len, count - len,
390 "%2.2x ", read_nic_byte(dev,
391 (page0 | n)));
392 }
393 len += snprintf(page + len, count - len, "\n");
394 *eof = 1;
395 return len;
396
397 }
398 static int proc_get_registers_8(char *page, char **start,
399 off_t offset, int count,
400 int *eof, void *data)
401 {
402 struct net_device *dev = data;
403
404 int len = 0;
405 int i, n, page0;
406
407 int max = 0xff;
408 page0 = 0x800;
409
410 /* This dump the current register page */
411 len += snprintf(page + len, count - len,
412 "\n####################page %x##################\n",
413 (page0 >> 8));
414 for (n = 0; n <= max;) {
415 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
416 for (i = 0; i < 4 && n <= max; n += 4, i++)
417 len += snprintf(page + len, count - len,
418 "%8.8x ", rtl8192_QueryBBReg(dev,
419 (page0 | n), bMaskDWord));
420 }
421 len += snprintf(page + len, count - len, "\n");
422 *eof = 1;
423 return len;
424
425 }
426 static int proc_get_registers_9(char *page, char **start,
427 off_t offset, int count,
428 int *eof, void *data)
429 {
430 struct net_device *dev = data;
431
432 int len = 0;
433 int i, n, page0;
434
435 int max = 0xff;
436 page0 = 0x900;
437
438 /* This dump the current register page */
439 len += snprintf(page + len, count - len,
440 "\n####################page %x##################\n",
441 (page0>>8));
442 for (n = 0; n <= max;) {
443 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
444 for (i = 0; i < 4 && n <= max; n += 4, i++)
445 len += snprintf(page + len, count - len,
446 "%8.8x ", rtl8192_QueryBBReg(dev,
447 (page0 | n), bMaskDWord));
448 }
449 len += snprintf(page + len, count - len, "\n");
450 *eof = 1;
451 return len;
452 }
453 static int proc_get_registers_a(char *page, char **start,
454 off_t offset, int count,
455 int *eof, void *data)
456 {
457 struct net_device *dev = data;
458
459 int len = 0;
460 int i, n, page0;
461
462 int max = 0xff;
463 page0 = 0xa00;
464
465 /* This dump the current register page */
466 len += snprintf(page + len, count - len,
467 "\n####################page %x##################\n",
468 (page0>>8));
469 for (n = 0; n <= max;) {
470 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
471 for (i = 0; i < 4 && n <= max; n += 4, i++)
472 len += snprintf(page + len, count - len,
473 "%8.8x ", rtl8192_QueryBBReg(dev,
474 (page0 | n), bMaskDWord));
475 }
476 len += snprintf(page + len, count - len, "\n");
477 *eof = 1;
478 return len;
479 }
480 static int proc_get_registers_b(char *page, char **start,
481 off_t offset, int count,
482 int *eof, void *data)
483 {
484 struct net_device *dev = data;
485
486 int len = 0;
487 int i, n, page0;
488
489 int max = 0xff;
490 page0 = 0xb00;
491
492 /* This dump the current register page */
493 len += snprintf(page + len, count - len,
494 "\n####################page %x##################\n",
495 (page0 >> 8));
496 for (n = 0; n <= max;) {
497 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
498 for (i = 0; i < 4 && n <= max; n += 4, i++)
499 len += snprintf(page + len, count - len,
500 "%8.8x ", rtl8192_QueryBBReg(dev,
501 (page0 | n), bMaskDWord));
502 }
503 len += snprintf(page + len, count - len, "\n");
504 *eof = 1;
505 return len;
506 }
507 static int proc_get_registers_c(char *page, char **start,
508 off_t offset, int count,
509 int *eof, void *data)
510 {
511 struct net_device *dev = data;
512
513 int len = 0;
514 int i, n, page0;
515
516 int max = 0xff;
517 page0 = 0xc00;
518
519 /* This dump the current register page */
520 len += snprintf(page + len, count - len,
521 "\n####################page %x##################\n",
522 (page0>>8));
523 for (n = 0; n <= max;) {
524 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
525 for (i = 0; i < 4 && n <= max; n += 4, i++)
526 len += snprintf(page + len, count - len,
527 "%8.8x ", rtl8192_QueryBBReg(dev,
528 (page0 | n), bMaskDWord));
529 }
530 len += snprintf(page + len, count - len, "\n");
531 *eof = 1;
532 return len;
533 }
534 static int proc_get_registers_d(char *page, char **start,
535 off_t offset, int count,
536 int *eof, void *data)
537 {
538 struct net_device *dev = data;
539
540 int len = 0;
541 int i, n, page0;
542
543 int max = 0xff;
544 page0 = 0xd00;
545
546 /* This dump the current register page */
547 len += snprintf(page + len, count - len,
548 "\n####################page %x##################\n",
549 (page0>>8));
550 for (n = 0; n <= max;) {
551 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
552 for (i = 0; i < 4 && n <= max; n += 4, i++)
553 len += snprintf(page + len, count - len,
554 "%8.8x ", rtl8192_QueryBBReg(dev,
555 (page0 | n), bMaskDWord));
556 }
557 len += snprintf(page + len, count - len, "\n");
558 *eof = 1;
559 return len;
560 }
561 static int proc_get_registers_e(char *page, char **start,
562 off_t offset, int count,
563 int *eof, void *data)
564 {
565 struct net_device *dev = data;
566
567 int len = 0;
568 int i, n, page0;
569
570 int max = 0xff;
571 page0 = 0xe00;
572
573 /* This dump the current register page */
574 len += snprintf(page + len, count - len,
575 "\n####################page %x##################\n",
576 (page0>>8));
577 for (n = 0; n <= max;) {
578 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
579 for (i = 0; i < 4 && n <= max; n += 4, i++)
580 len += snprintf(page + len, count - len,
581 "%8.8x ", rtl8192_QueryBBReg(dev,
582 (page0 | n), bMaskDWord));
583 }
584 len += snprintf(page + len, count - len, "\n");
585 *eof = 1;
586 return len;
587 }
588
589 static int proc_get_reg_rf_a(char *page, char **start,
590 off_t offset, int count,
591 int *eof, void *data)
592 {
593 struct net_device *dev = data;
594
595 int len = 0;
596 int i, n;
597
598 int max = 0xff;
599
600 /* This dump the current register page */
601 len += snprintf(page + len, count - len,
602 "\n#################### RF-A ##################\n ");
603 for (n = 0; n <= max;) {
604 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
605 for (i = 0; i < 4 && n <= max; n += 4, i++)
606 len += snprintf(page + len, count - len,
607 "%8.8x ", rtl8192_phy_QueryRFReg(dev,
608 (enum rf90_radio_path)RF90_PATH_A, n,
609 bMaskDWord));
610 }
611 len += snprintf(page + len, count - len, "\n");
612 *eof = 1;
613 return len;
614 }
615
616 static int proc_get_reg_rf_b(char *page, char **start,
617 off_t offset, int count,
618 int *eof, void *data)
619 {
620 struct net_device *dev = data;
621
622 int len = 0;
623 int i, n;
624
625 int max = 0xff;
626
627 /* This dump the current register page */
628 len += snprintf(page + len, count - len,
629 "\n#################### RF-B ##################\n ");
630 for (n = 0; n <= max;) {
631 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
632 for (i = 0; i < 4 && n <= max; n += 4, i++)
633 len += snprintf(page + len, count - len,
634 "%8.8x ", rtl8192_phy_QueryRFReg(dev,
635 (enum rf90_radio_path)RF90_PATH_B, n,
636 bMaskDWord));
637 }
638 len += snprintf(page + len, count - len, "\n");
639 *eof = 1;
640 return len;
641 }
642
643 static int proc_get_reg_rf_c(char *page, char **start,
644 off_t offset, int count,
645 int *eof, void *data)
646 {
647 struct net_device *dev = data;
648
649 int len = 0;
650 int i, n;
651
652 int max = 0xff;
653
654 /* This dump the current register page */
655 len += snprintf(page + len, count - len,
656 "\n#################### RF-C ##################\n");
657 for (n = 0; n <= max;) {
658 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
659 for (i = 0; i < 4 && n <= max; n += 4, i++)
660 len += snprintf(page + len, count - len,
661 "%8.8x ", rtl8192_phy_QueryRFReg(dev,
662 (enum rf90_radio_path)RF90_PATH_C, n,
663 bMaskDWord));
664 }
665 len += snprintf(page + len, count - len, "\n");
666 *eof = 1;
667 return len;
668 }
669
670 static int proc_get_reg_rf_d(char *page, char **start,
671 off_t offset, int count,
672 int *eof, void *data)
673 {
674 struct net_device *dev = data;
675
676 int len = 0;
677 int i, n;
678
679 int max = 0xff;
680
681 /* This dump the current register page */
682 len += snprintf(page + len, count - len,
683 "\n#################### RF-D ##################\n ");
684 for (n = 0; n <= max;) {
685 len += snprintf(page + len, count - len, "\nD: %2x > ", n);
686 for (i = 0; i < 4 && n <= max; n += 4, i++)
687 len += snprintf(page + len, count - len,
688 "%8.8x ", rtl8192_phy_QueryRFReg(dev,
689 (enum rf90_radio_path)RF90_PATH_D, n,
690 bMaskDWord));
691 }
692 len += snprintf(page + len, count - len, "\n");
693 *eof = 1;
694 return len;
695 }
696
697 static int proc_get_cam_register_1(char *page, char **start,
698 off_t offset, int count,
699 int *eof, void *data)
700 {
701 struct net_device *dev = data;
702 u32 target_command = 0;
703 u32 target_content = 0;
704 u8 entry_i = 0;
705 u32 ulStatus;
706 int len = 0;
707 int i = 100, j = 0;
708
709 /* This dump the current register page */
710 len += snprintf(page + len, count - len,
711 "\n#################### SECURITY CAM (0-10) ######"
712 "############\n ");
713 for (j = 0; j < 11; j++) {
714 len += snprintf(page + len, count - len, "\nD: %2x > ", j);
715 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
716 target_command = entry_i+CAM_CONTENT_COUNT*j;
717 target_command = target_command | BIT31;
718
719 while ((i--) >= 0) {
720 ulStatus = read_nic_dword(dev, RWCAM);
721 if (ulStatus & BIT31)
722 continue;
723 else
724 break;
725 }
726 write_nic_dword(dev, RWCAM, target_command);
727 target_content = read_nic_dword(dev, RCAMO);
728 len += snprintf(page + len, count - len, "%8.8x ",
729 target_content);
730 }
731 }
732
733 len += snprintf(page + len, count - len, "\n");
734 *eof = 1;
735 return len;
736 }
737
738 static int proc_get_cam_register_2(char *page, char **start,
739 off_t offset, int count,
740 int *eof, void *data)
741 {
742 struct net_device *dev = data;
743 u32 target_command = 0;
744 u32 target_content = 0;
745 u8 entry_i = 0;
746 u32 ulStatus;
747 int len = 0;
748 int i = 100, j = 0;
749
750 /* This dump the current register page */
751 len += snprintf(page + len, count - len,
752 "\n#################### SECURITY CAM (11-21) "
753 "##################\n ");
754 for (j = 11; j < 22; j++) {
755 len += snprintf(page + len, count - len, "\nD: %2x > ", j);
756 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
757 target_command = entry_i + CAM_CONTENT_COUNT * j;
758 target_command = target_command | BIT31;
759
760 while ((i--) >= 0) {
761 ulStatus = read_nic_dword(dev, RWCAM);
762 if (ulStatus & BIT31)
763 continue;
764 else
765 break;
766 }
767 write_nic_dword(dev, RWCAM, target_command);
768 target_content = read_nic_dword(dev, RCAMO);
769 len += snprintf(page + len, count - len, "%8.8x ",
770 target_content);
771 }
772 }
773
774 len += snprintf(page + len, count - len, "\n");
775 *eof = 1;
776 return len;
777 }
778
779 static int proc_get_cam_register_3(char *page, char **start,
780 off_t offset, int count,
781 int *eof, void *data)
782 {
783 struct net_device *dev = data;
784 u32 target_command = 0;
785 u32 target_content = 0;
786 u8 entry_i = 0;
787 u32 ulStatus;
788 int len = 0;
789 int i = 100, j = 0;
790
791 /* This dump the current register page */
792 len += snprintf(page + len, count - len,
793 "\n#################### SECURITY CAM (22-31) ######"
794 "############\n ");
795 for (j = 22; j < TOTAL_CAM_ENTRY; j++) {
796 len += snprintf(page + len, count - len, "\nD: %2x > ", j);
797 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
798 target_command = entry_i + CAM_CONTENT_COUNT * j;
799 target_command = target_command | BIT31;
800
801 while ((i--) >= 0) {
802 ulStatus = read_nic_dword(dev, RWCAM);
803 if (ulStatus & BIT31)
804 continue;
805 else
806 break;
807 }
808 write_nic_dword(dev, RWCAM, target_command);
809 target_content = read_nic_dword(dev, RCAMO);
810 len += snprintf(page + len, count - len, "%8.8x ",
811 target_content);
812 }
813 }
814
815 len += snprintf(page + len, count - len, "\n");
816 *eof = 1;
817 return len;
818 }
819 static int proc_get_stats_tx(char *page, char **start,
820 off_t offset, int count,
821 int *eof, void *data)
822 {
823 struct net_device *dev = data;
824 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
825
826 int len = 0;
827
828 len += snprintf(page + len, count - len,
829 "TX VI priority ok int: %lu\n"
830 "TX VO priority ok int: %lu\n"
831 "TX BE priority ok int: %lu\n"
832 "TX BK priority ok int: %lu\n"
833 "TX MANAGE priority ok int: %lu\n"
834 "TX BEACON priority ok int: %lu\n"
835 "TX BEACON priority error int: %lu\n"
836 "TX CMDPKT priority ok int: %lu\n"
837 "TX queue stopped?: %d\n"
838 "TX fifo overflow: %lu\n"
839 "TX total data packets %lu\n"
840 "TX total data bytes :%lu\n",
841 priv->stats.txviokint,
842 priv->stats.txvookint,
843 priv->stats.txbeokint,
844 priv->stats.txbkokint,
845 priv->stats.txmanageokint,
846 priv->stats.txbeaconokint,
847 priv->stats.txbeaconerr,
848 priv->stats.txcmdpktokint,
849 netif_queue_stopped(dev),
850 priv->stats.txoverflow,
851 priv->rtllib->stats.tx_packets,
852 priv->rtllib->stats.tx_bytes
853
854
855 );
856
857 *eof = 1;
858 return len;
859 }
860
861
862
863 static int proc_get_stats_rx(char *page, char **start,
864 off_t offset, int count,
865 int *eof, void *data)
866 {
867 struct net_device *dev = data;
868 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
869
870 int len = 0;
871
872 len += snprintf(page + len, count - len,
873 "RX packets: %lu\n"
874 "RX data crc err: %lu\n"
875 "RX mgmt crc err: %lu\n"
876 "RX desc err: %lu\n"
877 "RX rx overflow error: %lu\n",
878 priv->stats.rxint,
879 priv->stats.rxdatacrcerr,
880 priv->stats.rxmgmtcrcerr,
881 priv->stats.rxrdu,
882 priv->stats.rxoverflow);
883
884 *eof = 1;
885 return len;
886 }
887
888 void rtl8192_proc_module_init(void)
889 {
890 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
891 rtl8192_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
892 }
893
894
895 void rtl8192_proc_module_remove(void)
896 {
897 remove_proc_entry(DRV_NAME, init_net.proc_net);
898 }
899
900
901 void rtl8192_proc_remove_one(struct net_device *dev)
902 {
903 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
904
905 printk(KERN_INFO "dev name %s\n", dev->name);
906
907 if (priv->dir_dev) {
908 remove_proc_entry("stats-tx", priv->dir_dev);
909 remove_proc_entry("stats-rx", priv->dir_dev);
910 remove_proc_entry("stats-ap", priv->dir_dev);
911 remove_proc_entry("registers-0", priv->dir_dev);
912 remove_proc_entry("registers-1", priv->dir_dev);
913 remove_proc_entry("registers-2", priv->dir_dev);
914 remove_proc_entry("registers-3", priv->dir_dev);
915 remove_proc_entry("registers-4", priv->dir_dev);
916 remove_proc_entry("registers-5", priv->dir_dev);
917 remove_proc_entry("registers-6", priv->dir_dev);
918 remove_proc_entry("registers-7", priv->dir_dev);
919 remove_proc_entry("registers-8", priv->dir_dev);
920 remove_proc_entry("registers-9", priv->dir_dev);
921 remove_proc_entry("registers-a", priv->dir_dev);
922 remove_proc_entry("registers-b", priv->dir_dev);
923 remove_proc_entry("registers-c", priv->dir_dev);
924 remove_proc_entry("registers-d", priv->dir_dev);
925 remove_proc_entry("registers-e", priv->dir_dev);
926 remove_proc_entry("RF-A", priv->dir_dev);
927 remove_proc_entry("RF-B", priv->dir_dev);
928 remove_proc_entry("RF-C", priv->dir_dev);
929 remove_proc_entry("RF-D", priv->dir_dev);
930 remove_proc_entry("SEC-CAM-1", priv->dir_dev);
931 remove_proc_entry("SEC-CAM-2", priv->dir_dev);
932 remove_proc_entry("SEC-CAM-3", priv->dir_dev);
933 remove_proc_entry("wlan0", rtl8192_proc);
934 priv->dir_dev = NULL;
935 }
936 }
937
938
939 void rtl8192_proc_init_one(struct net_device *dev)
940 {
941 struct proc_dir_entry *e;
942 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
943
944 priv->dir_dev = create_proc_entry(dev->name,
945 S_IFDIR | S_IRUGO | S_IXUGO,
946 rtl8192_proc);
947 if (!priv->dir_dev) {
948 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192"
949 "/%s\n", dev->name);
950 return;
951 }
952 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
953 priv->dir_dev, proc_get_stats_rx, dev);
954
955 if (!e)
956 RT_TRACE(COMP_ERR, "Unable to initialize "
957 "/proc/net/rtl8192/%s/stats-rx\n",
958 dev->name);
959
960 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
961 priv->dir_dev, proc_get_stats_tx, dev);
962
963 if (!e)
964 RT_TRACE(COMP_ERR, "Unable to initialize "
965 "/proc/net/rtl8192/%s/stats-tx\n",
966 dev->name);
967
968 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
969 priv->dir_dev, proc_get_stats_ap, dev);
970
971 if (!e)
972 RT_TRACE(COMP_ERR, "Unable to initialize "
973 "/proc/net/rtl8192/%s/stats-ap\n",
974 dev->name);
975
976 e = create_proc_read_entry("registers-0", S_IFREG | S_IRUGO,
977 priv->dir_dev, proc_get_registers_0, dev);
978 if (!e)
979 RT_TRACE(COMP_ERR, "Unable to initialize "
980 "/proc/net/rtl8192/%s/registers-0\n",
981 dev->name);
982 e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
983 priv->dir_dev, proc_get_registers_1, dev);
984 if (!e)
985 RT_TRACE(COMP_ERR, "Unable to initialize "
986 "/proc/net/rtl8192/%s/registers-1\n",
987 dev->name);
988 e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
989 priv->dir_dev, proc_get_registers_2, dev);
990 if (!e)
991 RT_TRACE(COMP_ERR, "Unable to initialize "
992 "/proc/net/rtl8192/%s/registers-2\n",
993 dev->name);
994 e = create_proc_read_entry("registers-3", S_IFREG | S_IRUGO,
995 priv->dir_dev, proc_get_registers_3, dev);
996 if (!e)
997 RT_TRACE(COMP_ERR, "Unable to initialize "
998 "/proc/net/rtl8192/%s/registers-3\n",
999 dev->name);
1000 e = create_proc_read_entry("registers-4", S_IFREG | S_IRUGO,
1001 priv->dir_dev, proc_get_registers_4, dev);
1002 if (!e)
1003 RT_TRACE(COMP_ERR, "Unable to initialize "
1004 "/proc/net/rtl8192/%s/registers-4\n",
1005 dev->name);
1006 e = create_proc_read_entry("registers-5", S_IFREG | S_IRUGO,
1007 priv->dir_dev, proc_get_registers_5, dev);
1008 if (!e)
1009 RT_TRACE(COMP_ERR, "Unable to initialize "
1010 "/proc/net/rtl8192/%s/registers-5\n",
1011 dev->name);
1012 e = create_proc_read_entry("registers-6", S_IFREG | S_IRUGO,
1013 priv->dir_dev, proc_get_registers_6, dev);
1014 if (!e)
1015 RT_TRACE(COMP_ERR, "Unable to initialize "
1016 "/proc/net/rtl8192/%s/registers-6\n",
1017 dev->name);
1018 e = create_proc_read_entry("registers-7", S_IFREG | S_IRUGO,
1019 priv->dir_dev, proc_get_registers_7, dev);
1020 if (!e)
1021 RT_TRACE(COMP_ERR, "Unable to initialize "
1022 "/proc/net/rtl8192/%s/registers-7\n",
1023 dev->name);
1024 e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
1025 priv->dir_dev, proc_get_registers_8, dev);
1026 if (!e)
1027 RT_TRACE(COMP_ERR, "Unable to initialize "
1028 "/proc/net/rtl8192/%s/registers-8\n",
1029 dev->name);
1030 e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
1031 priv->dir_dev, proc_get_registers_9, dev);
1032 if (!e)
1033 RT_TRACE(COMP_ERR, "Unable to initialize "
1034 "/proc/net/rtl8192/%s/registers-9\n",
1035 dev->name);
1036 e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
1037 priv->dir_dev, proc_get_registers_a, dev);
1038 if (!e)
1039 RT_TRACE(COMP_ERR, "Unable to initialize "
1040 "/proc/net/rtl8192/%s/registers-a\n",
1041 dev->name);
1042 e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
1043 priv->dir_dev, proc_get_registers_b, dev);
1044 if (!e)
1045 RT_TRACE(COMP_ERR, "Unable to initialize "
1046 "/proc/net/rtl8192/%s/registers-b\n",
1047 dev->name);
1048 e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
1049 priv->dir_dev, proc_get_registers_c, dev);
1050 if (!e)
1051 RT_TRACE(COMP_ERR, "Unable to initialize "
1052 "/proc/net/rtl8192/%s/registers-c\n",
1053 dev->name);
1054 e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
1055 priv->dir_dev, proc_get_registers_d, dev);
1056 if (!e)
1057 RT_TRACE(COMP_ERR, "Unable to initialize "
1058 "/proc/net/rtl8192/%s/registers-d\n",
1059 dev->name);
1060 e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
1061 priv->dir_dev, proc_get_registers_e, dev);
1062 if (!e)
1063 RT_TRACE(COMP_ERR, "Unable to initialize "
1064 "/proc/net/rtl8192/%s/registers-e\n",
1065 dev->name);
1066 e = create_proc_read_entry("RF-A", S_IFREG | S_IRUGO,
1067 priv->dir_dev, proc_get_reg_rf_a, dev);
1068 if (!e)
1069 RT_TRACE(COMP_ERR, "Unable to initialize "
1070 "/proc/net/rtl8192/%s/RF-A\n",
1071 dev->name);
1072 e = create_proc_read_entry("RF-B", S_IFREG | S_IRUGO,
1073 priv->dir_dev, proc_get_reg_rf_b, dev);
1074 if (!e)
1075 RT_TRACE(COMP_ERR, "Unable to initialize "
1076 "/proc/net/rtl8192/%s/RF-B\n",
1077 dev->name);
1078 e = create_proc_read_entry("RF-C", S_IFREG | S_IRUGO,
1079 priv->dir_dev, proc_get_reg_rf_c, dev);
1080 if (!e)
1081 RT_TRACE(COMP_ERR, "Unable to initialize "
1082 "/proc/net/rtl8192/%s/RF-C\n",
1083 dev->name);
1084 e = create_proc_read_entry("RF-D", S_IFREG | S_IRUGO,
1085 priv->dir_dev, proc_get_reg_rf_d, dev);
1086 if (!e)
1087 RT_TRACE(COMP_ERR, "Unable to initialize "
1088 "/proc/net/rtl8192/%s/RF-D\n",
1089 dev->name);
1090 e = create_proc_read_entry("SEC-CAM-1", S_IFREG | S_IRUGO,
1091 priv->dir_dev, proc_get_cam_register_1, dev);
1092 if (!e)
1093 RT_TRACE(COMP_ERR, "Unable to initialize "
1094 "/proc/net/rtl8192/%s/SEC-CAM-1\n",
1095 dev->name);
1096 e = create_proc_read_entry("SEC-CAM-2", S_IFREG | S_IRUGO,
1097 priv->dir_dev, proc_get_cam_register_2, dev);
1098 if (!e)
1099 RT_TRACE(COMP_ERR, "Unable to initialize "
1100 "/proc/net/rtl8192/%s/SEC-CAM-2\n",
1101 dev->name);
1102 e = create_proc_read_entry("SEC-CAM-3", S_IFREG | S_IRUGO,
1103 priv->dir_dev, proc_get_cam_register_3, dev);
1104 if (!e)
1105 RT_TRACE(COMP_ERR, "Unable to initialize "
1106 "/proc/net/rtl8192/%s/SEC-CAM-3\n",
1107 dev->name);
1108 }
Linux Btrfs Development