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