drivers/staging/rtl8192e/rtl8192e/rtl_debug.c

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