Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/******************************************************************************
2 *
3 * Copyright(c) 2009-2010 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
20 *
21 * Contact Information:
22 * wlanfae <wlanfae@realtek.com>
23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
24 * Hsinchu 300, Taiwan.
25 *
26 * Larry Finger <Larry.Finger@lwfinger.net>
27 *
28 *****************************************************************************/
29
30#include "wifi.h"
31#include "cam.h"
32
33#define GET_INODE_DATA(__node) PDE_DATA(__node)
34
35void rtl_dbgp_flag_init(struct ieee80211_hw *hw)
36{
37 struct rtl_priv *rtlpriv = rtl_priv(hw);
38 u8 i;
39
40 rtlpriv->dbg.global_debuglevel = DBG_DMESG;
41
42 rtlpriv->dbg.global_debugcomponents =
43 COMP_ERR |
44 COMP_FW |
45 COMP_INIT |
46 COMP_RECV |
47 COMP_SEND |
48 COMP_MLME |
49 COMP_SCAN |
50 COMP_INTR |
51 COMP_LED |
52 COMP_SEC |
53 COMP_BEACON |
54 COMP_RATE |
55 COMP_RXDESC |
56 COMP_DIG |
57 COMP_TXAGC |
58 COMP_POWER |
59 COMP_POWER_TRACKING |
60 COMP_BB_POWERSAVING |
61 COMP_SWAS |
62 COMP_RF |
63 COMP_TURBO |
64 COMP_RATR |
65 COMP_CMD |
66 COMP_EASY_CONCURRENT |
67 COMP_EFUSE |
68 COMP_QOS | COMP_MAC80211 | COMP_REGD |
69 COMP_CHAN |
70 COMP_BT_COEXIST |
71 COMP_IQK |
72 0;
73
74 for (i = 0; i < DBGP_TYPE_MAX; i++)
75 rtlpriv->dbg.dbgp_type[i] = 0;
76
77 /*Init Debug flag enable condition */
78}
79
80struct proc_dir_entry *proc_topdir;
81static int rtl_proc_get_mac_0(struct seq_file *m, void *v)
82{
83 struct ieee80211_hw *hw = m->private;
84 struct rtl_priv *rtlpriv = rtl_priv(hw);
85 int i, n, page;
86 int max = 0xff;
87 page = 0x000;
88
89 for (n = 0; n <= max; ) {
90 seq_printf(m, "\n%8.8x ", n + page);
91 for (i = 0; i < 4 && n <= max; i++, n += 4)
92 seq_printf(m, "%8.8x ",
93 rtl_read_dword(rtlpriv, (page | n)));
94 }
95 seq_puts(m, "\n");
96 return 0;
97}
98
99static int dl_proc_open_mac_0(struct inode *inode, struct file *file)
100{
101 return single_open(file, rtl_proc_get_mac_0, GET_INODE_DATA(inode));
102}
103
104static const struct file_operations file_ops_mac_0 = {
105 .open = dl_proc_open_mac_0,
106 .read = seq_read,
107 .llseek = seq_lseek,
108 .release = seq_release,
109};
110
111static int rtl_proc_get_mac_1(struct seq_file *m, void *v)
112{
113 struct ieee80211_hw *hw = m->private;
114 struct rtl_priv *rtlpriv = rtl_priv(hw);
115 int i, n, page;
116 int max = 0xff;
117 page = 0x100;
118
119 for (n = 0; n <= max; ) {
120 seq_printf(m, "\n%8.8x ", n + page);
121 for (i = 0; i < 4 && n <= max; i++, n += 4)
122 seq_printf(m, "%8.8x ",
123 rtl_read_dword(rtlpriv, (page | n)));
124 }
125 seq_puts(m, "\n");
126 return 0;
127}
128
129static int dl_proc_open_mac_1(struct inode *inode, struct file *file)
130{
131 return single_open(file, rtl_proc_get_mac_1, GET_INODE_DATA(inode));
132}
133
134static const struct file_operations file_ops_mac_1 = {
135 .open = dl_proc_open_mac_1,
136 .read = seq_read,
137 .llseek = seq_lseek,
138 .release = seq_release,
139};
140
141static int rtl_proc_get_mac_2(struct seq_file *m, void *v)
142{
143 struct ieee80211_hw *hw = m->private;
144 struct rtl_priv *rtlpriv = rtl_priv(hw);
145 int i, n, page;
146 int max = 0xff;
147 page = 0x200;
148
149 for (n = 0; n <= max; ) {
150 seq_printf(m, "\n%8.8x ", n + page);
151 for (i = 0; i < 4 && n <= max; i++, n += 4)
152 seq_printf(m, "%8.8x ",
153 rtl_read_dword(rtlpriv, (page | n)));
154 }
155 seq_puts(m, "\n");
156 return 0;
157}
158
159static int dl_proc_open_mac_2(struct inode *inode, struct file *file)
160{
161 return single_open(file, rtl_proc_get_mac_2, GET_INODE_DATA(inode));
162}
163
164static const struct file_operations file_ops_mac_2 = {
165 .open = dl_proc_open_mac_2,
166 .read = seq_read,
167 .llseek = seq_lseek,
168 .release = seq_release,
169};
170
171static int rtl_proc_get_mac_3(struct seq_file *m, void *v)
172{
173 struct ieee80211_hw *hw = m->private;
174 struct rtl_priv *rtlpriv = rtl_priv(hw);
175 int i, n, page;
176 int max = 0xff;
177 page = 0x300;
178
179 for (n = 0; n <= max; ) {
180 seq_printf(m, "\n%8.8x ", n + page);
181 for (i = 0; i < 4 && n <= max; i++, n += 4)
182 seq_printf(m, "%8.8x ",
183 rtl_read_dword(rtlpriv, (page | n)));
184 }
185 seq_puts(m, "\n");
186 return 0;
187}
188
189static int dl_proc_open_mac_3(struct inode *inode, struct file *file)
190{
191 return single_open(file, rtl_proc_get_mac_3, GET_INODE_DATA(inode));
192}
193
194static const struct file_operations file_ops_mac_3 = {
195 .open = dl_proc_open_mac_3,
196 .read = seq_read,
197 .llseek = seq_lseek,
198 .release = seq_release,
199};
200
201static int rtl_proc_get_mac_4(struct seq_file *m, void *v)
202{
203 struct ieee80211_hw *hw = m->private;
204 struct rtl_priv *rtlpriv = rtl_priv(hw);
205 int i, n, page;
206 int max = 0xff;
207 page = 0x400;
208
209 for (n = 0; n <= max; ) {
210 seq_printf(m, "\n%8.8x ", n + page);
211 for (i = 0; i < 4 && n <= max; i++, n += 4)
212 seq_printf(m, "%8.8x ",
213 rtl_read_dword(rtlpriv, (page | n)));
214 }
215 seq_puts(m, "\n");
216 return 0;
217}
218
219static int dl_proc_open_mac_4(struct inode *inode, struct file *file)
220{
221 return single_open(file, rtl_proc_get_mac_4, GET_INODE_DATA(inode));
222}
223
224static const struct file_operations file_ops_mac_4 = {
225 .open = dl_proc_open_mac_4,
226 .read = seq_read,
227 .llseek = seq_lseek,
228 .release = seq_release,
229};
230
231static int rtl_proc_get_mac_5(struct seq_file *m, void *v)
232{
233 struct ieee80211_hw *hw = m->private;
234 struct rtl_priv *rtlpriv = rtl_priv(hw);
235 int i, n, page;
236 int max = 0xff;
237 page = 0x500;
238
239 for (n = 0; n <= max; ) {
240 seq_printf(m, "\n%8.8x ", n + page);
241 for (i = 0; i < 4 && n <= max; i++, n += 4)
242 seq_printf(m, "%8.8x ",
243 rtl_read_dword(rtlpriv, (page | n)));
244 }
245 seq_puts(m, "\n");
246 return 0;
247}
248
249static int dl_proc_open_mac_5(struct inode *inode, struct file *file)
250{
251 return single_open(file, rtl_proc_get_mac_5, GET_INODE_DATA(inode));
252}
253
254static const struct file_operations file_ops_mac_5 = {
255 .open = dl_proc_open_mac_5,
256 .read = seq_read,
257 .llseek = seq_lseek,
258 .release = seq_release,
259};
260
261static int rtl_proc_get_mac_6(struct seq_file *m, void *v)
262{
263 struct ieee80211_hw *hw = m->private;
264 struct rtl_priv *rtlpriv = rtl_priv(hw);
265 int i, n, page;
266 int max = 0xff;
267 page = 0x600;
268
269 for (n = 0; n <= max; ) {
270 seq_printf(m, "\n%8.8x ", n + page);
271 for (i = 0; i < 4 && n <= max; i++, n += 4)
272 seq_printf(m, "%8.8x ",
273 rtl_read_dword(rtlpriv, (page | n)));
274 }
275 seq_puts(m, "\n");
276 return 0;
277}
278
279static int dl_proc_open_mac_6(struct inode *inode, struct file *file)
280{
281 return single_open(file, rtl_proc_get_mac_6, GET_INODE_DATA(inode));
282}
283
284static const struct file_operations file_ops_mac_6 = {
285 .open = dl_proc_open_mac_6,
286 .read = seq_read,
287 .llseek = seq_lseek,
288 .release = seq_release,
289};
290
291static int rtl_proc_get_mac_7(struct seq_file *m, void *v)
292{
293 struct ieee80211_hw *hw = m->private;
294 struct rtl_priv *rtlpriv = rtl_priv(hw);
295 int i, n, page;
296 int max = 0xff;
297 page = 0x700;
298
299 for (n = 0; n <= max; ) {
300 seq_printf(m, "\n%8.8x ", n + page);
301 for (i = 0; i < 4 && n <= max; i++, n += 4)
302 seq_printf(m, "%8.8x ",
303 rtl_read_dword(rtlpriv, (page | n)));
304 }
305 seq_puts(m, "\n");
306 return 0;
307}
308
309static int dl_proc_open_mac_7(struct inode *inode, struct file *file)
310{
311 return single_open(file, rtl_proc_get_mac_7, GET_INODE_DATA(inode));
312}
313
314static const struct file_operations file_ops_mac_7 = {
315 .open = dl_proc_open_mac_7,
316 .read = seq_read,
317 .llseek = seq_lseek,
318 .release = seq_release,
319};
320
321static int rtl_proc_get_bb_8(struct seq_file *m, void *v)
322{
323 struct ieee80211_hw *hw = m->private;
324 int i, n, page;
325 int max = 0xff;
326 page = 0x800;
327
328 for (n = 0; n <= max; ) {
329 seq_printf(m, "\n%8.8x ", n + page);
330 for (i = 0; i < 4 && n <= max; i++, n += 4)
331 seq_printf(m, "%8.8x ",
332 rtl_get_bbreg(hw, (page | n), 0xffffffff));
333 }
334 seq_puts(m, "\n");
335 return 0;
336}
337
338static int dl_proc_open_bb_8(struct inode *inode, struct file *file)
339{
340 return single_open(file, rtl_proc_get_bb_8, GET_INODE_DATA(inode));
341}
342
343static const struct file_operations file_ops_bb_8 = {
344 .open = dl_proc_open_bb_8,
345 .read = seq_read,
346 .llseek = seq_lseek,
347 .release = seq_release,
348};
349
350static int rtl_proc_get_bb_9(struct seq_file *m, void *v)
351{
352 struct ieee80211_hw *hw = m->private;
353 int i, n, page;
354 int max = 0xff;
355 page = 0x900;
356
357 for (n = 0; n <= max; ) {
358 seq_printf(m, "\n%8.8x ", n + page);
359 for (i = 0; i < 4 && n <= max; i++, n += 4)
360 seq_printf(m, "%8.8x ",
361 rtl_get_bbreg(hw, (page | n), 0xffffffff));
362 }
363 seq_puts(m, "\n");
364 return 0;
365}
366
367static int dl_proc_open_bb_9(struct inode *inode, struct file *file)
368{
369 return single_open(file, rtl_proc_get_bb_9, GET_INODE_DATA(inode));
370}
371
372static const struct file_operations file_ops_bb_9 = {
373 .open = dl_proc_open_bb_9,
374 .read = seq_read,
375 .llseek = seq_lseek,
376 .release = seq_release,
377};
378
379static int rtl_proc_get_bb_a(struct seq_file *m, void *v)
380{
381 struct ieee80211_hw *hw = m->private;
382 int i, n, page;
383 int max = 0xff;
384 page = 0xa00;
385
386 for (n = 0; n <= max; ) {
387 seq_printf(m, "\n%8.8x ", n + page);
388 for (i = 0; i < 4 && n <= max; i++, n += 4)
389 seq_printf(m, "%8.8x ",
390 rtl_get_bbreg(hw, (page | n), 0xffffffff));
391 }
392 seq_puts(m, "\n");
393 return 0;
394}
395
396static int dl_proc_open_bb_a(struct inode *inode, struct file *file)
397{
398 return single_open(file, rtl_proc_get_bb_a, GET_INODE_DATA(inode));
399}
400
401static const struct file_operations file_ops_bb_a = {
402 .open = dl_proc_open_bb_a,
403 .read = seq_read,
404 .llseek = seq_lseek,
405 .release = seq_release,
406};
407
408static int rtl_proc_get_bb_b(struct seq_file *m, void *v)
409{
410 struct ieee80211_hw *hw = m->private;
411 int i, n, page;
412 int max = 0xff;
413 page = 0xb00;
414
415 for (n = 0; n <= max; ) {
416 seq_printf(m, "\n%8.8x ", n + page);
417 for (i = 0; i < 4 && n <= max; i++, n += 4)
418 seq_printf(m, "%8.8x ",
419 rtl_get_bbreg(hw, (page | n), 0xffffffff));
420 }
421 seq_puts(m, "\n");
422 return 0;
423}
424
425static int dl_proc_open_bb_b(struct inode *inode, struct file *file)
426{
427 return single_open(file, rtl_proc_get_bb_b, GET_INODE_DATA(inode));
428}
429
430static const struct file_operations file_ops_bb_b = {
431 .open = dl_proc_open_bb_b,
432 .read = seq_read,
433 .llseek = seq_lseek,
434 .release = seq_release,
435};
436
437static int rtl_proc_get_bb_c(struct seq_file *m, void *v)
438{
439 struct ieee80211_hw *hw = m->private;
440 int i, n, page;
441 int max = 0xff;
442 page = 0xc00;
443
444 for (n = 0; n <= max; ) {
445 seq_printf(m, "\n%8.8x ", n + page);
446 for (i = 0; i < 4 && n <= max; i++, n += 4)
447 seq_printf(m, "%8.8x ",
448 rtl_get_bbreg(hw, (page | n), 0xffffffff));
449 }
450 seq_puts(m, "\n");
451 return 0;
452}
453
454static int dl_proc_open_bb_c(struct inode *inode, struct file *file)
455{
456 return single_open(file, rtl_proc_get_bb_c, GET_INODE_DATA(inode));
457}
458
459static const struct file_operations file_ops_bb_c = {
460 .open = dl_proc_open_bb_c,
461 .read = seq_read,
462 .llseek = seq_lseek,
463 .release = seq_release,
464};
465
466static int rtl_proc_get_bb_d(struct seq_file *m, void *v)
467{
468 struct ieee80211_hw *hw = m->private;
469 int i, n, page;
470 int max = 0xff;
471 page = 0xd00;
472
473 for (n = 0; n <= max; ) {
474 seq_printf(m, "\n%8.8x ", n + page);
475 for (i = 0; i < 4 && n <= max; i++, n += 4)
476 seq_printf(m, "%8.8x ",
477 rtl_get_bbreg(hw, (page | n), 0xffffffff));
478 }
479 seq_puts(m, "\n");
480 return 0;
481}
482
483static int dl_proc_open_bb_d(struct inode *inode, struct file *file)
484{
485 return single_open(file, rtl_proc_get_bb_d, GET_INODE_DATA(inode));
486}
487
488static const struct file_operations file_ops_bb_d = {
489 .open = dl_proc_open_bb_d,
490 .read = seq_read,
491 .llseek = seq_lseek,
492 .release = seq_release,
493};
494
495static int rtl_proc_get_bb_e(struct seq_file *m, void *v)
496{
497 struct ieee80211_hw *hw = m->private;
498 int i, n, page;
499 int max = 0xff;
500 page = 0xe00;
501
502 for (n = 0; n <= max; ) {
503 seq_printf(m, "\n%8.8x ", n + page);
504 for (i = 0; i < 4 && n <= max; i++, n += 4)
505 seq_printf(m, "%8.8x ",
506 rtl_get_bbreg(hw, (page | n), 0xffffffff));
507 }
508 seq_puts(m, "\n");
509 return 0;
510}
511
512static int dl_proc_open_bb_e(struct inode *inode, struct file *file)
513{
514 return single_open(file, rtl_proc_get_bb_e, GET_INODE_DATA(inode));
515}
516
517static const struct file_operations file_ops_bb_e = {
518 .open = dl_proc_open_bb_e,
519 .read = seq_read,
520 .llseek = seq_lseek,
521 .release = seq_release,
522};
523
524static int rtl_proc_get_bb_f(struct seq_file *m, void *v)
525{
526 struct ieee80211_hw *hw = m->private;
527 int i, n, page;
528 int max = 0xff;
529 page = 0xf00;
530
531 for (n = 0; n <= max; ) {
532 seq_printf(m, "\n%8.8x ", n + page);
533 for (i = 0; i < 4 && n <= max; i++, n += 4)
534 seq_printf(m, "%8.8x ",
535 rtl_get_bbreg(hw, (page | n), 0xffffffff));
536 }
537 seq_puts(m, "\n");
538 return 0;
539}
540
541static int dl_proc_open_bb_f(struct inode *inode, struct file *file)
542{
543 return single_open(file, rtl_proc_get_bb_f, GET_INODE_DATA(inode));
544}
545
546static const struct file_operations file_ops_bb_f = {
547 .open = dl_proc_open_bb_f,
548 .read = seq_read,
549 .llseek = seq_lseek,
550 .release = seq_release,
551};
552
553static int rtl_proc_get_reg_rf_a(struct seq_file *m, void *v)
554{
555 struct ieee80211_hw *hw = m->private;
556 int i, n;
557 int max = 0x40;
558
559 for (n = 0; n <= max; ) {
560 seq_printf(m, "\n%8.8x ", n);
561 for (i = 0; i < 4 && n <= max; n += 1, i++)
562 seq_printf(m, "%8.8x ",
563 rtl_get_rfreg(hw, RF90_PATH_A, n, 0xffffffff));
564 }
565 seq_puts(m, "\n");
566 return 0;
567}
568
569static int dl_proc_open_rf_a(struct inode *inode, struct file *file)
570{
571 return single_open(file, rtl_proc_get_reg_rf_a, GET_INODE_DATA(inode));
572}
573
574static const struct file_operations file_ops_rf_a = {
575 .open = dl_proc_open_rf_a,
576 .read = seq_read,
577 .llseek = seq_lseek,
578 .release = seq_release,
579};
580
581static int rtl_proc_get_reg_rf_b(struct seq_file *m, void *v)
582{
583 struct ieee80211_hw *hw = m->private;
584 int i, n;
585 int max = 0x40;
586
587 for (n = 0; n <= max; ) {
588 seq_printf(m, "\n%8.8x ", n);
589 for (i = 0; i < 4 && n <= max; n += 1, i++)
590 seq_printf(m, "%8.8x ",
591 rtl_get_rfreg(hw, RF90_PATH_B, n,
592 0xffffffff));
593 }
594 seq_puts(m, "\n");
595 return 0;
596}
597
598static int dl_proc_open_rf_b(struct inode *inode, struct file *file)
599{
600 return single_open(file, rtl_proc_get_reg_rf_b, GET_INODE_DATA(inode));
601}
602
603static const struct file_operations file_ops_rf_b = {
604 .open = dl_proc_open_rf_b,
605 .read = seq_read,
606 .llseek = seq_lseek,
607 .release = seq_release,
608};
609
610static int rtl_proc_get_cam_register_1(struct seq_file *m, void *v)
611{
612 struct ieee80211_hw *hw = m->private;
613 struct rtl_priv *rtlpriv = rtl_priv(hw);
614 u32 target_cmd = 0;
615 u32 target_val=0;
616 u8 entry_i=0;
617 u32 ulstatus;
618 int i = 100, j = 0;
619
620 /* This dump the current register page */
621 seq_puts(m,
622 "\n#################### SECURITY CAM (0-10) ##################\n ");
623
624 for (j = 0; j < 11; j++) {
625 seq_printf(m, "\nD: %2x > ", j);
626 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
627 /* polling bit, and No Write enable, and address */
628 target_cmd = entry_i + CAM_CONTENT_COUNT * j;
629 target_cmd = target_cmd | BIT(31);
630
631 /* Check polling bit is clear */
632 while ((i--) >= 0) {
633 ulstatus = rtl_read_dword(rtlpriv,
634 rtlpriv->cfg->maps[RWCAM]);
635 if (ulstatus & BIT(31)) {
636 continue;
637 } else {
638 break;
639 }
640 }
641
642 rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
643 target_cmd);
644 target_val = rtl_read_dword(rtlpriv,
645 rtlpriv->cfg->maps[RCAMO]);
646 seq_printf(m, "%8.8x ", target_val);
647 }
648 }
649 seq_puts(m, "\n");
650 return 0;
651}
652
653static int dl_proc_open_cam_1(struct inode *inode, struct file *file)
654{
655 return single_open(file, rtl_proc_get_cam_register_1,
656 GET_INODE_DATA(inode));
657}
658
659static const struct file_operations file_ops_cam_1 = {
660 .open = dl_proc_open_cam_1,
661 .read = seq_read,
662 .llseek = seq_lseek,
663 .release = seq_release,
664};
665
666static int rtl_proc_get_cam_register_2(struct seq_file *m, void *v)
667{
668 struct ieee80211_hw *hw = m->private;
669 struct rtl_priv *rtlpriv = rtl_priv(hw);
670 u32 target_cmd = 0;
671 u32 target_val = 0;
672 u8 entry_i = 0;
673 u32 ulstatus;
674 int i = 100, j = 0;
675
676 /* This dump the current register page */
677 seq_puts(m,
678 "\n################### SECURITY CAM (11-21) ##################\n ");
679
680 for (j = 11; j < 22; j++) {
681 seq_printf(m, "\nD: %2x > ", j);
682 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
683 target_cmd = entry_i + CAM_CONTENT_COUNT * j;
684 target_cmd = target_cmd | BIT(31);
685
686 while ((i--) >= 0) {
687 ulstatus = rtl_read_dword(rtlpriv,
688 rtlpriv->cfg->maps[RWCAM]);
689 if (ulstatus & BIT(31)) {
690 continue;
691 } else {
692 break;
693 }
694 }
695
696 rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
697 target_cmd);
698 target_val = rtl_read_dword(rtlpriv,
699 rtlpriv->cfg->maps[RCAMO]);
700 seq_printf(m, "%8.8x ", target_val);
701 }
702 }
703 seq_puts(m, "\n");
704 return 0;
705}
706
707static int dl_proc_open_cam_2(struct inode *inode, struct file *file)
708{
709 return single_open(file, rtl_proc_get_cam_register_2,
710 GET_INODE_DATA(inode));
711}
712
713static const struct file_operations file_ops_cam_2 = {
714 .open = dl_proc_open_cam_2,
715 .read = seq_read,
716 .llseek = seq_lseek,
717 .release = seq_release,
718};
719
720static int rtl_proc_get_cam_register_3(struct seq_file *m, void *v)
721{
722 struct ieee80211_hw *hw = m->private;
723 struct rtl_priv *rtlpriv = rtl_priv(hw);
724 u32 target_cmd = 0;
725 u32 target_val = 0;
726 u8 entry_i = 0;
727 u32 ulstatus;
728 int i = 100, j = 0;
729
730 /* This dump the current register page */
731 seq_puts(m,
732 "\n################### SECURITY CAM (22-31) ##################\n ");
733
734 for (j = 22; j < TOTAL_CAM_ENTRY; j++) {
735 seq_printf(m, "\nD: %2x > ", j);
736 for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
737 target_cmd = entry_i+CAM_CONTENT_COUNT*j;
738 target_cmd = target_cmd | BIT(31);
739
740 while ((i--) >= 0) {
741 ulstatus = rtl_read_dword(rtlpriv,
742 rtlpriv->cfg->maps[RWCAM]);
743 if (ulstatus & BIT(31)) {
744 continue;
745 } else {
746 break;
747 }
748 }
749
750 rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
751 target_cmd);
752 target_val = rtl_read_dword(rtlpriv,
753 rtlpriv->cfg->maps[RCAMO]);
754 seq_printf(m, "%8.8x ", target_val);
755 }
756 }
757 seq_puts(m, "\n");
758 return 0;
759}
760
761static int dl_proc_open_cam_3(struct inode *inode, struct file *file)
762{
763 return single_open(file, rtl_proc_get_cam_register_3,
764 GET_INODE_DATA(inode));
765}
766
767static const struct file_operations file_ops_cam_3 = {
768 .open = dl_proc_open_cam_3,
769 .read = seq_read,
770 .llseek = seq_lseek,
771 .release = seq_release,
772};
773
774void rtl_proc_add_one(struct ieee80211_hw *hw)
775{
776 struct rtl_priv *rtlpriv = rtl_priv(hw);
777 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
778 struct proc_dir_entry *entry;
779
780 snprintf(rtlpriv->dbg.proc_name, 18, "%x-%x-%x-%x-%x-%x",
781 rtlefuse->dev_addr[0], rtlefuse->dev_addr[1],
782 rtlefuse->dev_addr[2], rtlefuse->dev_addr[3],
783 rtlefuse->dev_addr[4], rtlefuse->dev_addr[5]);
784
785 rtlpriv->dbg.proc_dir = proc_mkdir(rtlpriv->dbg.proc_name, proc_topdir);
786 if (!rtlpriv->dbg.proc_dir) {
787 RT_TRACE(COMP_INIT, DBG_EMERG, ("Unable to init "
788 "/proc/net/%s/%s\n", rtlpriv->cfg->name,
789 rtlpriv->dbg.proc_name));
790 return;
791 }
792
793 entry = proc_create_data("mac-0", S_IFREG | S_IRUGO,
794 rtlpriv->dbg.proc_dir, &file_ops_mac_0, hw);
795 if (!entry)
796 RT_TRACE(COMP_INIT, DBG_EMERG,
797 ("Unable to initialize /proc/net/%s/%s/mac-0\n",
798 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
799
800 entry = proc_create_data("mac-1", S_IFREG | S_IRUGO,
801 rtlpriv->dbg.proc_dir, &file_ops_mac_1, hw);
802 if (!entry)
803 RT_TRACE(COMP_INIT, COMP_ERR,
804 ("Unable to initialize /proc/net/%s/%s/mac-1\n",
805 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
806
807 entry = proc_create_data("mac-2", S_IFREG | S_IRUGO,
808 rtlpriv->dbg.proc_dir, &file_ops_mac_2, hw);
809 if (!entry)
810 RT_TRACE(COMP_INIT, COMP_ERR,
811 ("Unable to initialize /proc/net/%s/%s/mac-2\n",
812 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
813
814 entry = proc_create_data("mac-3", S_IFREG | S_IRUGO,
815 rtlpriv->dbg.proc_dir, &file_ops_mac_3, hw);
816 if (!entry)
817 RT_TRACE(COMP_INIT, COMP_ERR,
818 ("Unable to initialize /proc/net/%s/%s/mac-3\n",
819 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
820
821 entry = proc_create_data("mac-4", S_IFREG | S_IRUGO,
822 rtlpriv->dbg.proc_dir, &file_ops_mac_4, hw);
823 if (!entry)
824 RT_TRACE(COMP_INIT, COMP_ERR,
825 ("Unable to initialize /proc/net/%s/%s/mac-4\n",
826 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
827
828 entry = proc_create_data("mac-5", S_IFREG | S_IRUGO,
829 rtlpriv->dbg.proc_dir, &file_ops_mac_5, hw);
830 if (!entry)
831 RT_TRACE(COMP_INIT, COMP_ERR,
832 ("Unable to initialize /proc/net/%s/%s/mac-5\n",
833 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
834
835 entry = proc_create_data("mac-6", S_IFREG | S_IRUGO,
836 rtlpriv->dbg.proc_dir, &file_ops_mac_6, hw);
837 if (!entry)
838 RT_TRACE(COMP_INIT, COMP_ERR,
839 ("Unable to initialize /proc/net/%s/%s/mac-6\n",
840 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
841
842 entry = proc_create_data("mac-7", S_IFREG | S_IRUGO,
843 rtlpriv->dbg.proc_dir, &file_ops_mac_7, hw);
844 if (!entry)
845 RT_TRACE(COMP_INIT, COMP_ERR,
846 ("Unable to initialize /proc/net/%s/%s/mac-7\n",
847 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
848
849 entry = proc_create_data("bb-8", S_IFREG | S_IRUGO,
850 rtlpriv->dbg.proc_dir, &file_ops_bb_8, hw);
851 if (!entry)
852 RT_TRACE(COMP_INIT, COMP_ERR,
853 ("Unable to initialize /proc/net/%s/%s/bb-8\n",
854 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
855
856 entry = proc_create_data("bb-9", S_IFREG | S_IRUGO,
857 rtlpriv->dbg.proc_dir, &file_ops_bb_9, hw);
858 if (!entry)
859 RT_TRACE(COMP_INIT, COMP_ERR,
860 ("Unable to initialize /proc/net/%s/%s/bb-9\n",
861 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
862
863 entry = proc_create_data("bb-a", S_IFREG | S_IRUGO,
864 rtlpriv->dbg.proc_dir, &file_ops_bb_a, hw);
865 if (!entry)
866 RT_TRACE(COMP_INIT, COMP_ERR,
867 ("Unable to initialize /proc/net/%s/%s/bb-a\n",
868 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
869
870 entry = proc_create_data("bb-b", S_IFREG | S_IRUGO,
871 rtlpriv->dbg.proc_dir, &file_ops_bb_b, hw);
872 if (!entry)
873 RT_TRACE(COMP_INIT, COMP_ERR,
874 ("Unable to initialize /proc/net/%s/%s/bb-b\n",
875 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
876
877 entry = proc_create_data("bb-c", S_IFREG | S_IRUGO,
878 rtlpriv->dbg.proc_dir, &file_ops_bb_c, hw);
879 if (!entry)
880 RT_TRACE(COMP_INIT, COMP_ERR,
881 ("Unable to initialize /proc/net/%s/%s/bb-c\n",
882 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
883
884 entry = proc_create_data("bb-d", S_IFREG | S_IRUGO,
885 rtlpriv->dbg.proc_dir, &file_ops_bb_d, hw);
886 if (!entry)
887 RT_TRACE(COMP_INIT, COMP_ERR,
888 ("Unable to initialize /proc/net/%s/%s/bb-d\n",
889 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
890
891 entry = proc_create_data("bb-e", S_IFREG | S_IRUGO,
892 rtlpriv->dbg.proc_dir, &file_ops_bb_e, hw);
893 if (!entry)
894 RT_TRACE(COMP_INIT, COMP_ERR,
895 ("Unable to initialize /proc/net/%s/%s/bb-e\n",
896 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
897
898 entry = proc_create_data("bb-f", S_IFREG | S_IRUGO,
899 rtlpriv->dbg.proc_dir, &file_ops_bb_f, hw);
900 if (!entry)
901 RT_TRACE(COMP_INIT, COMP_ERR,
902 ("Unable to initialize /proc/net/%s/%s/bb-f\n",
903 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
904
905 entry = proc_create_data("rf-a", S_IFREG | S_IRUGO,
906 rtlpriv->dbg.proc_dir, &file_ops_rf_a, hw);
907 if (!entry)
908 RT_TRACE(COMP_INIT, COMP_ERR,
909 ("Unable to initialize /proc/net/%s/%s/rf-a\n",
910 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
911
912 entry = proc_create_data("rf-b", S_IFREG | S_IRUGO,
913 rtlpriv->dbg.proc_dir, &file_ops_rf_b, hw);
914 if (!entry)
915 RT_TRACE(COMP_INIT, COMP_ERR,
916 ("Unable to initialize /proc/net/%s/%s/rf-b\n",
917 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
918
919 entry = proc_create_data("cam-1", S_IFREG | S_IRUGO,
920 rtlpriv->dbg.proc_dir, &file_ops_cam_1, hw);
921 if (!entry)
922 RT_TRACE(COMP_INIT, COMP_ERR,
923 ("Unable to initialize /proc/net/%s/%s/cam-1\n",
924 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
925
926 entry = proc_create_data("cam-2", S_IFREG | S_IRUGO,
927 rtlpriv->dbg.proc_dir, &file_ops_cam_2, hw);
928 if (!entry)
929 RT_TRACE(COMP_INIT, COMP_ERR,
930 ("Unable to initialize /proc/net/%s/%s/cam-2\n",
931 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
932
933 entry = proc_create_data("cam-3", S_IFREG | S_IRUGO,
934 rtlpriv->dbg.proc_dir, &file_ops_cam_3, hw);
935 if (!entry)
936 RT_TRACE(COMP_INIT, COMP_ERR,
937 ("Unable to initialize /proc/net/%s/%s/cam-3\n",
938 rtlpriv->cfg->name, rtlpriv->dbg.proc_name));
939}
940
941void rtl_proc_remove_one(struct ieee80211_hw *hw)
942{
943 struct rtl_priv *rtlpriv = rtl_priv(hw);
944
945 if (rtlpriv->dbg.proc_dir) {
946 remove_proc_entry("mac-0", rtlpriv->dbg.proc_dir);
947 remove_proc_entry("mac-1", rtlpriv->dbg.proc_dir);
948 remove_proc_entry("mac-2", rtlpriv->dbg.proc_dir);
949 remove_proc_entry("mac-3", rtlpriv->dbg.proc_dir);
950 remove_proc_entry("mac-4", rtlpriv->dbg.proc_dir);
951 remove_proc_entry("mac-5", rtlpriv->dbg.proc_dir);
952 remove_proc_entry("mac-6", rtlpriv->dbg.proc_dir);
953 remove_proc_entry("mac-7", rtlpriv->dbg.proc_dir);
954 remove_proc_entry("bb-8", rtlpriv->dbg.proc_dir);
955 remove_proc_entry("bb-9", rtlpriv->dbg.proc_dir);
956 remove_proc_entry("bb-a", rtlpriv->dbg.proc_dir);
957 remove_proc_entry("bb-b", rtlpriv->dbg.proc_dir);
958 remove_proc_entry("bb-c", rtlpriv->dbg.proc_dir);
959 remove_proc_entry("bb-d", rtlpriv->dbg.proc_dir);
960 remove_proc_entry("bb-e", rtlpriv->dbg.proc_dir);
961 remove_proc_entry("bb-f", rtlpriv->dbg.proc_dir);
962 remove_proc_entry("rf-a", rtlpriv->dbg.proc_dir);
963 remove_proc_entry("rf-b", rtlpriv->dbg.proc_dir);
964 remove_proc_entry("cam-1", rtlpriv->dbg.proc_dir);
965 remove_proc_entry("cam-2", rtlpriv->dbg.proc_dir);
966 remove_proc_entry("cam-3", rtlpriv->dbg.proc_dir);
967
968 remove_proc_entry(rtlpriv->dbg.proc_name, proc_topdir);
969
970 rtlpriv->dbg.proc_dir = NULL;
971 }
972}
973
974void rtl_proc_add_topdir(void)
975{
976 proc_topdir = proc_mkdir("rtlwifi", init_net.proc_net);
977}
978
979void rtl_proc_remove_topdir(void)
980{
981 if (proc_topdir)
982 remove_proc_entry("rtlwifi", init_net.proc_net);
983}