drivers/staging/rtl8192ee/debug.c

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