ubuntu/rtl8192se/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 #ifdef RTL8192CE
  28 #include "rtl8192c/r8192C_phy.h"
  29 #include "rtl8192c/r8192C_phyreg.h"
  30 #include "rtl8192c/r8192C_rtl6052.h"
  31 #include "rtl8192c/r8192C_Efuse.h"
  32 #elif defined RTL8192SE
  33 #include "rtl8192s/r8192S_phy.h"
  34 #include "rtl8192s/r8192S_phyreg.h"
  35 #include "rtl8192s/r8192S_rtl6052.h"
  36 #include "rtl8192s/r8192S_Efuse.h"
  37 #else
  38 #include "rtl8192e/r8192E_phy.h"
  39 #include "rtl8192e/r8192E_phyreg.h"
  40 #include "rtl8192e/r8190P_rtl8256.h" /* RTL8225 Radio frontend */
  41 #include "rtl8192e/r8192E_cmdpkt.h"
  42 #endif
  43
  44 #ifdef _RTL8192_EXT_PATCH_
  45 #include "../../mshclass/msh_class.h"
  46 #endif
  47 /* this is only for debugging */
  48 void print_buffer(u32 *buffer, int len)
  49 {
  50         int i;
  51         u8 *buf =(u8*)buffer;
  52
  53         printk("ASCII BUFFER DUMP (len: %x):\n",len);
  54
  55         for(i=0;i<len;i++)
  56                 printk("%c",buf[i]);
  57
  58         printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
  59
  60         for(i=0;i<len;i++)
  61                 printk("%x",buf[i]);
  62
  63         printk("\n");
  64 }
  65
  66 /* this is only for debug */
  67 void dump_eprom(struct net_device *dev)
  68 {
  69         int i;
  70
  71         for (i = 0; i < 0xff; i++) {
  72                 RT_TRACE(COMP_INIT, "EEPROM addr %x : %x", i, eprom_read(dev,i));
  73         }
  74 }
  75
  76 /* this is only for debug */
  77 void rtl8192_dump_reg(struct net_device *dev)
  78 {
  79         int i;
  80         int n;
  81         int max = 0x5ff;
  82
  83         RT_TRACE(COMP_INIT, "Dumping NIC register map");
  84
  85         for (n = 0; n <= max; ) {
  86                 printk( "\nD: %2x> ", n);
  87                 for (i = 0; i < 16 && n <= max; i++, n++)
  88                         printk("%2x ", read_nic_byte(dev, n));
  89         }
  90         printk("\n");
  91 }
  92
  93 #ifdef RTL8192CE
  94 void rtl8192ce_dump_tx_desc(tx_desc *pDesc)
  95 {
  96 #if 0
  97         RTPRINT(FTX, TX_DESC, ("DW 0 =========\r\n"));
  98         RTPRINT(FTX, TX_DESC, ("Own = %d\n", pDesc->OWN));
  99         RTPRINT(FTX, TX_DESC, ("GF = %d\n", pDesc->GF));
 100         RTPRINT(FTX, TX_DESC, ("LINIP = %d\n", pDesc->LINIP));
 101         RTPRINT(FTX, TX_DESC, ("FS = %d\n", pDesc->FirstSeg));
 102         RTPRINT(FTX, TX_DESC, ("LS = %d\n", pDesc->LastSeg));
 103         RTPRINT(FTX, TX_DESC, ("Offset = %d\n", pDesc->Offset));
 104         RTPRINT(FTX, TX_DESC, ("PktSize = %d\r\n", pDesc->PktSize));
 105
 106         RTPRINT(FTX, TX_DESC, ("DW 1 ==========\r\n"));
 107         RTPRINT(FTX, TX_DESC, ("PKTOFFSET = %d\n", pDesc->PktOffset));
 108         RTPRINT(FTX, TX_DESC, ("HTC = %d\n", pDesc->HTC));
 109         RTPRINT(FTX, TX_DESC, ("SecType = %d\n", pDesc->SecType));
 110         RTPRINT(FTX, TX_DESC, ("EnDescID = %d\n", pDesc->EnDescID));
 111         RTPRINT(FTX, TX_DESC, ("NoACM = %d\n", pDesc->NOACM));
 112         RTPRINT(FTX, TX_DESC, ("QueueSelect = %d\n", pDesc->QueueSel));
 113         RTPRINT(FTX, TX_DESC, ("PIFS = %d\n", pDesc->PIFS));
 114         RTPRINT(FTX, TX_DESC, ("MoreFrag = %d\n", pDesc->MoreFrag));
 115         RTPRINT(FTX, TX_DESC, ("MacID = %d\r\n", pDesc->MacID));
 116
 117         RTPRINT(FTX, TX_DESC, ("DW 2 ==========\r\n"));
 118         RTPRINT(FTX, TX_DESC, ("BK = %d\n", pDesc->Bk));
 119         RTPRINT(FTX, TX_DESC, ("AGG_EN = %d\n", pDesc->AggEn));
 120         RTPRINT(FTX, TX_DESC, ("Data Retry CNT = %d\n", pDesc->DATARC));
 121         RTPRINT(FTX, TX_DESC, ("RTS Retry CNT = %d\n", pDesc->RTSRC));
 122         RTPRINT(FTX, TX_DESC, ("TSFL = %d\n", pDesc->TSFL));
 123         RTPRINT(FTX, TX_DESC, ("RetryLmtEn = %d\n", pDesc->RetryLmtEn));
 124         RTPRINT(FTX, TX_DESC, ("DataRetryLmt = %d\r\n", pDesc->TxRetryLmt));
 125
 126         RTPRINT(FTX, TX_DESC, ("DW 3 ==========\r\n"));
 127         RTPRINT(FTX, TX_DESC, ("Seq = %d\n", pDesc->Seq));
 128         RTPRINT(FTX, TX_DESC, ("TailPage = %d\n", pDesc->TailPage));
 129         RTPRINT(FTX, TX_DESC, ("NextHeadPage = %d\r\n", pDesc->NextHeadPage));
 130
 131         RTPRINT(FTX, TX_DESC, ("DW 4 ==========\r\n"));
 132         RTPRINT(FTX, TX_DESC, ("UserRate = %d\n", pDesc->UserRate));
 133         RTPRINT(FTX, TX_DESC, ("RTS STBC = %d\n", pDesc->RTSSTBC));
 134         RTPRINT(FTX, TX_DESC, ("RTSSC = %d\n", pDesc->RTSSC));
 135         RTPRINT(FTX, TX_DESC, ("STBC = %d\n", pDesc->STBC));
 136         RTPRINT(FTX, TX_DESC, ("TXSC = %d\n", pDesc->TxSc));
 137         RTPRINT(FTX, TX_DESC, ("TxBw = %d\n", pDesc->TxBW));
 138         RTPRINT(FTX, TX_DESC, ("TxShort = %d\n", pDesc->TxShort));
 139         RTPRINT(FTX, TX_DESC, ("RTSEn = %d\n", pDesc->RTSEn));
 140         RTPRINT(FTX, TX_DESC, ("CTS2Self = %d\n", pDesc->CTS2Self));
 141         RTPRINT(FTX, TX_DESC, ("RTSRateFBLmt = %d\n", pDesc->RTSRateFBLmt));
 142         RTPRINT(FTX, TX_DESC, ("DisRTSFB = %d\n", pDesc->DisRTSFB));
 143         RTPRINT(FTX, TX_DESC, ("RTSRate = %d\r\n", pDesc->RTSRate));
 144
 145         RTPRINT(FTX, TX_DESC, ("DW 5 ==========\r\n"));
 146         RTPRINT(FTX, TX_DESC, ("TxAGC = %d\n", pDesc->TXAGCA));
 147         RTPRINT(FTX, TX_DESC, ("TxAGC = %d\n", pDesc->TXAGCB));
 148         RTPRINT(FTX, TX_DESC, ("DataRateFBLmt = %d\n", pDesc->TxRateFBLmt));
 149         RTPRINT(FTX, TX_DESC, ("Disable Feedback = %d\n", pDesc->DisDataFB));
 150         RTPRINT(FTX, TX_DESC, ("TX_Rate = %d\n", pDesc->TxRate));
 151         RTPRINT(FTX, TX_DESC, ("PktID = %d\r\n", pDesc->PktID));
 152
 153         RTPRINT(FTX, TX_DESC, ("DW 6 ==========\r\n"));
 154
 155         RTPRINT(FTX, TX_DESC, ("DW 7-9 ==========\r\n"));
 156         RTPRINT(FTX, TX_DESC, ("TxBufferSize = %d\r\n", pDesc->TxBufferSize));
 157
 158         RTPRINT(FTX, TX_DESC, ("PhyAddressLow = %08x\n", pDesc->TxBuffAddr));
 159
 160         RTPRINT(FTX, TX_DESC, ("NextDescAddress= %08X\n", pDesc->NextDescAddress));
 161 #else
 162         u32* desc = (u32*)pDesc;
 163         u8 i=0;
 164         printk("#########################\n");
 165         for(i=0;i<=9;i++){
 166                 printk("#########>%x\n", desc[i]);
 167         }
 168         printk("#########################\n\n");
 169 #endif
 170 }
 171 #endif
 172
 173 #ifdef RTL8192SE
 174 void rtl8192se_dump_tx_desc(tx_desc* pDesc)
 175 {
 176     printk("DW 0 =========\r\n");
 177     printk("Own = %d\n", pDesc->OWN);
 178     printk("GF = %d\n", pDesc->GF);
 179     printk("LINIP = %d\n", pDesc->LINIP);
 180     printk("FS = %d\n", pDesc->FirstSeg);
 181     printk("LS = %d\n", pDesc->LastSeg);
 182     printk("Offset = %d\n", pDesc->Offset);
 183     printk("PktSize = %d\r\n", pDesc->PktSize);
 184
 185     printk("DW 1 ==========\r\n");
 186     printk("HWPC = %d\n", pDesc->HWPC);
 187     printk("PKTOFFSET = %d\n", pDesc->PktOffset);
 188     printk("WDS = %d\n", pDesc->WDS);
 189     printk("HTC = %d\n", pDesc->HTC);
 190     printk("SecType = %d\n", pDesc->SecType);
 191     printk("EnDescID = %d\n", pDesc->EnDescID);
 192     printk("PktType = %d\n", pDesc->PktType);
 193     printk("OUI = %d\n", pDesc->OUI);
 194     printk("SecKeyId = %d\n", pDesc->KeyID);
 195     printk("NonQos = %d\n", pDesc->NonQos);
 196     printk("NoACM = %d\n", pDesc->NoACM);
 197     printk("AckPolicy = %d\n", pDesc->AckPolicy);
 198     printk("QueueSelect = %d\n", pDesc->QueueSel);
 199     printk("PIFS = %d\n", pDesc->PIFS);
 200     printk("MoreFrag = %d\n", pDesc->MoreFrag);
 201     printk("MoreData = %d\n", pDesc->MoreData);
 202     printk("MacID = %d\r\n", pDesc->MacID);
 203
 204     printk("DW 2 ==========\r\n");
 205     printk("OwnMAC = %d\n", pDesc->OwnMAC);
 206     printk("BK = %d\n", pDesc->BK);
 207     printk("AGG_EN = %d\n", pDesc->AggEn);
 208     printk("Data Retry CNT = %d\n", pDesc->DATARC);
 209     printk("RTS Retry CNT = %d\n", pDesc->RTSRC);
 210     printk("TSFL = %d\n", pDesc->TSFL);
 211     printk("RetryLmtEn = %d\n", pDesc->RetryLmtEn);
 212     printk("DataRetryLmt = %d\r\n", pDesc->DataRetryLmt);
 213
 214     printk("DW 3 ==========\r\n");
 215     printk("Frag = %d\n", pDesc->Frag);
 216     printk("Seq = %d\n", pDesc->Seq);
 217     printk("TailPage = %d\n", pDesc->TailPage);
 218     printk("NextHeadPage = %d\r\n", pDesc->NextHeadPage);
 219
 220     printk("DW 4 ==========\r\n");
 221     printk("UserRate = %d\n", pDesc->UserRate);
 222     printk("RTS STBC = %d\n", pDesc->RTSSTBC);
 223     printk("RTSSC = %d\n", pDesc->RTSSC);
 224     printk("RTSBW = %d\n", pDesc->RTSBW);
 225     printk("RTSShort = %d\n", pDesc->RTSShort);
 226     printk("RTSHT = %d\n", pDesc->RTSHT);
 227     printk("RD = %d\n", pDesc->RD);
 228     printk("STBC = %d\n", pDesc->STBC);
 229     printk("TXSC = %d\n", pDesc->TXSC);
 230     printk("TxBw = %d\n", pDesc->TxBw);
 231     printk("TxShort = %d\n", pDesc->TxShort);
 232     printk("TXHT = %d\n", pDesc->TXHT);
 233     printk("RaBRSRID = %d\n", pDesc->RaBRSRID);
 234     printk("RTSEn = %d\n", pDesc->RTSEn);
 235     printk("CTS2Self = %d\n", pDesc->CTS2Self);
 236     printk("RTSRateFBLmt = %d\n", pDesc->RTSRateFBLmt);
 237     printk("DisRTSFB = %d\n", pDesc->DisRTSFB);
 238     printk("RTSRate = %d\r\n", pDesc->RTSRate);
 239
 240     printk("DW 5 ==========\r\n");
 241     printk("TxAGC = %d\n", pDesc->TxAGC);
 242     printk("DataRateFBLmt = %d\n", pDesc->DataRateFBLmt);
 243     printk("Disable Feedback = %d\n", pDesc->DISFB);
 244     printk("TX_Rate = %d\n", pDesc->TxRate);
 245     printk("PktID = %d\r\n", pDesc->PktID);
 246
 247     printk("DW 6 ==========\r\n");
 248     printk("TCPChkSum = %d\n", pDesc->TCPChkSum);
 249     printk("IPChkSum = %d\r\n", pDesc->IPChkSum);
 250
 251     printk("DW 7-9 ==========\r\n");
 252     printk("TCPEn = %d\n", pDesc->TCPEn);
 253     printk("IPHdrOffset = %d\n", pDesc->IPHdrOffset);
 254     printk("TxBufferSize = %d\r\n", pDesc->TxBufferSize);
 255
 256     printk("PhyAddressLow = %08x\n", pDesc->TxBuffAddr);
 257
 258     printk("NextDescAddress= %08X\n", pDesc->NextDescAddress);
 259 }
 260 #endif
 261
 262 #ifdef CONFIG_RTLWIFI_DEBUGFS
 263 /* debugfs related stuff */
 264 static struct dentry *rtl_debugfs_root;
 265 static int rtl_dbgfs_open(struct inode *inode, struct file *file)
 266 {
 267         file->private_data = inode->i_private;
 268         return 0;
 269 }
 270
 271 static ssize_t rtl_dbgfs_register_write(struct file *file,
 272                 const char __user *user_buf,
 273                 size_t count,
 274                 loff_t *ppos)
 275 {
 276         struct r8192_priv *priv = (struct r8192_priv *)file->private_data;
 277         char buf[32];
 278         int buf_size;
 279         u32 type, offset;
 280
 281         memset(buf, 0, sizeof(buf));
 282         buf_size = min(count, sizeof(buf) -  1);
 283         if (copy_from_user(buf, user_buf, buf_size))
 284                 return -EFAULT;
 285
 286         if (sscanf(buf, "%x,%x", &type, &offset ) == 2) {
 287                 priv->debug->hw_type = type;
 288                 priv->debug->hw_offset = offset;
 289         } else {
 290                 priv->debug->hw_type = 0;
 291                 priv->debug->hw_offset = 0;
 292         }
 293
 294         return count;
 295 }
 296
 297 void  rtl_hardware_grab(struct net_device *dev)
 298 {
 299         struct r8192_priv *priv = rtllib_priv(dev);
 300         int t = 0;
 301         int timeout = 20;
 302         u32 mask = RF_CHANGE_BY_HW|RF_CHANGE_BY_PS|RF_CHANGE_BY_IPS;
 303
 304         priv->debug->hw_holding = true;
 305 #ifdef ENABLE_IPS
 306         rtllib_ips_leave_wq(dev);
 307 #endif
 308         do {
 309                 if ((priv->rtllib->RfOffReason & mask)) {
 310                         msleep(100);
 311                         t++;
 312                 } else {
 313                         return;
 314                 }
 315         } while (t < timeout);
 316
 317         return;
 318 }
 319
 320 static ssize_t rtl_dbgfs_register_read(struct file *file,
 321                 char __user *user_buf,
 322                 size_t count,
 323                 loff_t *ppos)
 324 {
 325         struct r8192_priv *priv = (struct r8192_priv *)file->private_data;
 326         struct net_device *dev = priv->rtllib->dev;
 327         ssize_t ret = 0;
 328         char buf[2048];
 329         int n,i;
 330         u32 len = 0;
 331         u32 max = 0xff;
 332         u32 page_no, path;
 333
 334         rtl_hardware_grab(dev);
 335
 336         if(!priv->debug->hw_type) {
 337                 page_no = (priv->debug->hw_offset > 0x0f)? 0x0f: priv->debug->hw_offset;
 338 #ifdef RTL8192SE
 339                 if(page_no >= 0x08 ) {
 340                         len += snprintf(buf + len, count - len,
 341                                         "\n#################### BB page- %x##################\n ", page_no);
 342                         for(n=0;n<=max;)
 343                         {
 344                                 len += snprintf(buf + len, count - len, "\nD:  %2x > ",n);
 345                                 for(i=0;i<4 && n<=max;n+=4,i++)
 346                                         len += snprintf(buf + len, count - len,
 347                                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page_no << 8|n),
 348                                                                 bMaskDWord));
 349                         }
 350
 351                 } else
 352 #endif
 353                 {
 354                         len += snprintf(buf + len,count - len,
 355                                         "\n#################### MAC page- %x##################\n ", page_no);
 356                         for(n=0;n<=max;) {
 357                                 len += snprintf(buf + len, count - len, "\nD:  %2x > ",n);
 358                                 for(i=0;i<16 && n<=max;i++,n++)
 359                                         len += snprintf(buf + len, count - len,
 360                                                         "%2.2x ",read_nic_byte(dev,((page_no<<8)|n)));
 361                         }
 362                 }
 363         } else {
 364                 path = (priv->debug->hw_offset < RF90_PATH_MAX)? priv->debug->hw_offset:(RF90_PATH_MAX - 1);
 365                 len += snprintf(buf + len, count - len,
 366                                 "\n#################### RF-PATH-%x ##################\n ", 0x0a+path);
 367                 for(n=0;n<=max;) {
 368                         len += snprintf(buf+ len, count - len, "\nD:  %2x > ",n);
 369                         for(i=0;i<4 && n<=max;n+=4,i++)
 370                                 len += snprintf(buf + len, count - len,
 371                                         "%8.8x ",rtl8192_phy_QueryRFReg(dev, (RF90_RADIO_PATH_E)path,\
 372                                                 n, bMaskDWord));
 373                 }
 374         }
 375
 376         priv->debug->hw_holding = false;
 377
 378         len += snprintf(buf + len, count - len, "\n");
 379         ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 380         return ret;
 381 }
 382
 383 static const struct file_operations rtl_register_debug = {
 384         .read   = rtl_dbgfs_register_read,
 385         .write  = rtl_dbgfs_register_write,
 386         .open   = rtl_dbgfs_open,
 387         .owner  = THIS_MODULE
 388 };
 389
 390 int rtl_debug_module_init(struct r8192_priv *priv, const char *name)
 391 {
 392         rtl_fs_debug *debug;
 393         int ret = 0;
 394
 395         if (!rtl_debugfs_root)
 396                 return -ENOENT;
 397
 398 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 399         debug = kzalloc(sizeof(rtl_fs_debug), GFP_KERNEL);
 400 #else
 401         rtl_fs_debug = kmalloc(sizeof(*rtl_fs_debug), GFP_KERNEL);
 402         memset(rtl_fs_debug,0,sizeof(*rtl_fs_debug));
 403 #endif
 404         if (!debug) {
 405                 ret = -ENOMEM;
 406                 goto err;
 407         }
 408         priv->debug = debug;
 409
 410         debug->name = name;
 411         debug->dir_drv = debugfs_create_dir(name, rtl_debugfs_root);
 412         if (!debug->dir_drv ) {
 413                 ret = -ENOENT;
 414                 goto err;
 415         }
 416
 417         debug->debug_register = debugfs_create_file("debug_register", S_IRUGO,
 418                          debug->dir_drv, priv, &rtl_register_debug);
 419         if(!debug->debug_register) {
 420                 ret = -ENOENT;
 421                 goto err;
 422         }
 423
 424         return 0;
 425 err:
 426         RT_TRACE(COMP_DBG, "Can't open the debugfs directory\n");
 427         rtl_debug_module_remove(priv);
 428         return ret;
 429
 430 }
 431
 432 void rtl_debug_module_remove(struct r8192_priv *priv)
 433 {
 434         if (!priv->debug)
 435                 return;
 436         debugfs_remove(priv->debug->debug_register);
 437         debugfs_remove(priv->debug->dir_drv);
 438         kfree(priv->debug);
 439         priv->debug = NULL;
 440 }
 441
 442 int rtl_create_debugfs_root(void)
 443 {
 444         rtl_debugfs_root = debugfs_create_dir(DRV_NAME, NULL);
 445         if (!rtl_debugfs_root)
 446                 return -ENOENT;
 447
 448         return 0;
 449 }
 450
 451 void rtl_remove_debugfs_root(void)
 452 {
 453         debugfs_remove(rtl_debugfs_root);
 454         rtl_debugfs_root = NULL;
 455 }
 456 #endif
 457
 458 /****************************************************************************
 459    -----------------------------PROCFS STUFF-------------------------
 460 *****************************************************************************/
 461 /*This part is related to PROC, which will record some statistics. */
 462 static struct proc_dir_entry *rtl8192_proc = NULL;
 463
 464 static int proc_get_stats_ap(char *page, char **start,
 465                           off_t offset, int count,
 466                           int *eof, void *data)
 467 {
 468         struct net_device *dev = data;
 469         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 470         struct rtllib_device *ieee = priv->rtllib;
 471         struct rtllib_network *target;
 472
 473         int len = 0;
 474
 475         list_for_each_entry(target, &ieee->network_list, list) {
 476
 477                 len += snprintf(page + len, count - len,
 478                 "%s ", target->ssid);
 479
 480                 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
 481                         len += snprintf(page + len, count - len,
 482                         "WPA\n");
 483                 }
 484                 else{
 485                         len += snprintf(page + len, count - len,
 486                         "non_WPA\n");
 487                 }
 488
 489         }
 490
 491         *eof = 1;
 492         return len;
 493 }
 494
 495 static int proc_get_registers_0(char *page, char **start,
 496                           off_t offset, int count,
 497                           int *eof, void *data)
 498 {
 499         struct net_device *dev = data;
 500
 501         int len = 0;
 502         int i,n,page0;
 503
 504         int max=0xff;
 505         page0 = 0x000;
 506
 507 #ifdef RTL8192SE
 508         /* This dump the current register page */
 509         if(!IS_BB_REG_OFFSET_92S(page0)){
 510                 len += snprintf(page + len, count - len,
 511                                 "\n####################page %x##################\n ", (page0>>8));
 512                 for(n=0;n<=max;)
 513                 {
 514                         len += snprintf(page + len, count - len,
 515                                         "\nD:  %2x > ",n);
 516                         for(i=0;i<16 && n<=max;i++,n++)
 517                                 len += snprintf(page + len, count - len,
 518                                                 "%2.2x ",read_nic_byte(dev,(page0|n)));
 519                 }
 520         }else
 521 #endif
 522         {
 523                 len += snprintf(page + len, count - len,
 524                                 "\n####################page %x##################\n ", (page0>>8));
 525                 for(n=0;n<=max;)
 526                 {
 527                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 528                         for(i=0;i<16 && n<=max;n++,i++)
 529                                 len += snprintf(page + len, count - len,
 530                                                 "%2.2x ",read_nic_byte(dev,(page0|n)));
 531                 }
 532         }
 533         len += snprintf(page + len, count - len,"\n");
 534         *eof = 1;
 535         return len;
 536
 537 }
 538 static int proc_get_registers_1(char *page, char **start,
 539                           off_t offset, int count,
 540                           int *eof, void *data)
 541 {
 542         struct net_device *dev = data;
 543
 544         int len = 0;
 545         int i,n,page0;
 546
 547         int max=0xff;
 548         page0 = 0x100;
 549
 550         /* This dump the current register page */
 551         len += snprintf(page + len, count - len,
 552                         "\n####################page %x##################\n ", (page0>>8));
 553         for(n=0;n<=max;)
 554         {
 555                 len += snprintf(page + len, count - len,
 556                                 "\nD:  %2x > ",n);
 557                 for(i=0;i<16 && n<=max;i++,n++)
 558                         len += snprintf(page + len, count - len,
 559                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 560         }
 561         len += snprintf(page + len, count - len,"\n");
 562         *eof = 1;
 563         return len;
 564
 565 }
 566 static int proc_get_registers_2(char *page, char **start,
 567                           off_t offset, int count,
 568                           int *eof, void *data)
 569 {
 570         struct net_device *dev = data;
 571
 572         int len = 0;
 573         int i,n,page0;
 574
 575         int max=0xff;
 576         page0 = 0x200;
 577
 578         /* This dump the current register page */
 579         len += snprintf(page + len, count - len,
 580                         "\n####################page %x##################\n ", (page0>>8));
 581         for(n=0;n<=max;)
 582         {
 583                 len += snprintf(page + len, count - len,
 584                                 "\nD:  %2x > ",n);
 585                 for(i=0;i<16 && n<=max;i++,n++)
 586                         len += snprintf(page + len, count - len,
 587                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 588         }
 589         len += snprintf(page + len, count - len,"\n");
 590         *eof = 1;
 591         return len;
 592
 593 }
 594 static int proc_get_registers_3(char *page, char **start,
 595                           off_t offset, int count,
 596                           int *eof, void *data)
 597 {
 598         struct net_device *dev = data;
 599
 600         int len = 0;
 601         int i,n,page0;
 602
 603         int max=0xff;
 604         page0 = 0x300;
 605
 606         /* This dump the current register page */
 607         len += snprintf(page + len, count - len,
 608                         "\n####################page %x##################\n ", (page0>>8));
 609         for(n=0;n<=max;)
 610         {
 611                 len += snprintf(page + len, count - len,
 612                                 "\nD:  %2x > ",n);
 613                 for(i=0;i<16 && n<=max;i++,n++)
 614                         len += snprintf(page + len, count - len,
 615                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 616         }
 617         len += snprintf(page + len, count - len,"\n");
 618         *eof = 1;
 619         return len;
 620
 621 }
 622 static int proc_get_registers_4(char *page, char **start,
 623                           off_t offset, int count,
 624                           int *eof, void *data)
 625 {
 626         struct net_device *dev = data;
 627
 628         int len = 0;
 629         int i,n,page0;
 630
 631         int max=0xff;
 632         page0 = 0x400;
 633
 634         /* This dump the current register page */
 635         len += snprintf(page + len, count - len,
 636                         "\n####################page %x##################\n ", (page0>>8));
 637         for(n=0;n<=max;)
 638         {
 639                 len += snprintf(page + len, count - len,
 640                                 "\nD:  %2x > ",n);
 641                 for(i=0;i<16 && n<=max;i++,n++)
 642                         len += snprintf(page + len, count - len,
 643                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 644         }
 645         len += snprintf(page + len, count - len,"\n");
 646         *eof = 1;
 647         return len;
 648
 649 }
 650 static int proc_get_registers_5(char *page, char **start,
 651                           off_t offset, int count,
 652                           int *eof, void *data)
 653 {
 654         struct net_device *dev = data;
 655
 656         int len = 0;
 657         int i,n,page0;
 658
 659         int max=0xff;
 660         page0 = 0x500;
 661
 662         /* This dump the current register page */
 663         len += snprintf(page + len, count - len,
 664                         "\n####################page %x##################\n ", (page0>>8));
 665         for(n=0;n<=max;)
 666         {
 667                 len += snprintf(page + len, count - len,
 668                                 "\nD:  %2x > ",n);
 669                 for(i=0;i<16 && n<=max;i++,n++)
 670                         len += snprintf(page + len, count - len,
 671                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 672         }
 673         len += snprintf(page + len, count - len,"\n");
 674         *eof = 1;
 675         return len;
 676
 677 }
 678 static int proc_get_registers_6(char *page, char **start,
 679                           off_t offset, int count,
 680                           int *eof, void *data)
 681 {
 682         struct net_device *dev = data;
 683
 684         int len = 0;
 685         int i,n,page0;
 686
 687         int max=0xff;
 688         page0 = 0x600;
 689
 690         /* This dump the current register page */
 691         len += snprintf(page + len, count - len,
 692                         "\n####################page %x##################\n ", (page0>>8));
 693         for(n=0;n<=max;)
 694         {
 695                 len += snprintf(page + len, count - len,
 696                                 "\nD:  %2x > ",n);
 697                 for(i=0;i<16 && n<=max;i++,n++)
 698                         len += snprintf(page + len, count - len,
 699                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 700         }
 701         len += snprintf(page + len, count - len,"\n");
 702         *eof = 1;
 703         return len;
 704
 705 }
 706 static int proc_get_registers_7(char *page, char **start,
 707                           off_t offset, int count,
 708                           int *eof, void *data)
 709 {
 710         struct net_device *dev = data;
 711
 712         int len = 0;
 713         int i,n,page0;
 714
 715         int max=0xff;
 716         page0 = 0x700;
 717
 718         /* This dump the current register page */
 719         len += snprintf(page + len, count - len,
 720                         "\n####################page %x##################\n ", (page0>>8));
 721         for(n=0;n<=max;)
 722         {
 723                 len += snprintf(page + len, count - len,
 724                                 "\nD:  %2x > ",n);
 725                 for(i=0;i<16 && n<=max;i++,n++)
 726                         len += snprintf(page + len, count - len,
 727                                         "%2.2x ",read_nic_byte(dev,(page0|n)));
 728         }
 729         len += snprintf(page + len, count - len,"\n");
 730         *eof = 1;
 731         return len;
 732
 733 }
 734 static int proc_get_registers_8(char *page, char **start,
 735                           off_t offset, int count,
 736                           int *eof, void *data)
 737 {
 738         struct net_device *dev = data;
 739
 740         int len = 0;
 741         int i,n,page0;
 742
 743         int max=0xff;
 744         page0 = 0x800;
 745
 746         /* This dump the current register page */
 747         len += snprintf(page + len, count - len,
 748                         "\n####################page %x##################\n ", (page0>>8));
 749         for(n=0;n<=max;)
 750         {
 751                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 752                 for(i=0;i<4 && n<=max;n+=4,i++)
 753                         len += snprintf(page + len, count - len,
 754                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 755         }
 756         len += snprintf(page + len, count - len,"\n");
 757         *eof = 1;
 758         return len;
 759
 760 }
 761 static int proc_get_registers_9(char *page, char **start,
 762                           off_t offset, int count,
 763                           int *eof, void *data)
 764 {
 765         struct net_device *dev = data;
 766
 767         int len = 0;
 768         int i,n,page0;
 769
 770         int max=0xff;
 771         page0 = 0x900;
 772
 773         /* This dump the current register page */
 774         len += snprintf(page + len, count - len,
 775                         "\n####################page %x##################\n ", (page0>>8));
 776         for(n=0;n<=max;)
 777         {
 778                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 779                 for(i=0;i<4 && n<=max;n+=4,i++)
 780                         len += snprintf(page + len, count - len,
 781                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 782         }
 783         len += snprintf(page + len, count - len,"\n");
 784         *eof = 1;
 785         return len;
 786 }
 787 static int proc_get_registers_a(char *page, char **start,
 788                           off_t offset, int count,
 789                           int *eof, void *data)
 790 {
 791         struct net_device *dev = data;
 792
 793         int len = 0;
 794         int i,n,page0;
 795
 796         int max=0xff;
 797         page0 = 0xa00;
 798
 799         /* This dump the current register page */
 800         len += snprintf(page + len, count - len,
 801                         "\n####################page %x##################\n ", (page0>>8));
 802         for(n=0;n<=max;)
 803         {
 804                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 805                 for(i=0;i<4 && n<=max;n+=4,i++)
 806                         len += snprintf(page + len, count - len,
 807                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 808         }
 809         len += snprintf(page + len, count - len,"\n");
 810         *eof = 1;
 811         return len;
 812 }
 813 static int proc_get_registers_b(char *page, char **start,
 814                           off_t offset, int count,
 815                           int *eof, void *data)
 816 {
 817         struct net_device *dev = data;
 818
 819         int len = 0;
 820         int i,n,page0;
 821
 822         int max=0xff;
 823         page0 = 0xb00;
 824
 825         /* This dump the current register page */
 826         len += snprintf(page + len, count - len,
 827                         "\n####################page %x##################\n ", (page0>>8));
 828         for(n=0;n<=max;)
 829         {
 830                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 831                 for(i=0;i<4 && n<=max;n+=4,i++)
 832                         len += snprintf(page + len, count - len,
 833                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 834         }
 835         len += snprintf(page + len, count - len,"\n");
 836         *eof = 1;
 837         return len;
 838 }
 839 static int proc_get_registers_c(char *page, char **start,
 840                           off_t offset, int count,
 841                           int *eof, void *data)
 842 {
 843         struct net_device *dev = data;
 844
 845         int len = 0;
 846         int i,n,page0;
 847
 848         int max=0xff;
 849         page0 = 0xc00;
 850
 851         /* This dump the current register page */
 852         len += snprintf(page + len, count - len,
 853                         "\n####################page %x##################\n ", (page0>>8));
 854         for(n=0;n<=max;)
 855         {
 856                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 857                 for(i=0;i<4 && n<=max;n+=4,i++)
 858                         len += snprintf(page + len, count - len,
 859                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 860         }
 861         len += snprintf(page + len, count - len,"\n");
 862         *eof = 1;
 863         return len;
 864 }
 865 static int proc_get_registers_d(char *page, char **start,
 866                           off_t offset, int count,
 867                           int *eof, void *data)
 868 {
 869         struct net_device *dev = data;
 870
 871         int len = 0;
 872         int i,n,page0;
 873
 874         int max=0xff;
 875         page0 = 0xd00;
 876
 877         /* This dump the current register page */
 878         len += snprintf(page + len, count - len,
 879                         "\n####################page %x##################\n ", (page0>>8));
 880         for(n=0;n<=max;)
 881         {
 882                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 883                 for(i=0;i<4 && n<=max;n+=4,i++)
 884                         len += snprintf(page + len, count - len,
 885                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 886         }
 887         len += snprintf(page + len, count - len,"\n");
 888         *eof = 1;
 889         return len;
 890 }
 891 static int proc_get_registers_e(char *page, char **start,
 892                           off_t offset, int count,
 893                           int *eof, void *data)
 894 {
 895         struct net_device *dev = data;
 896
 897         int len = 0;
 898         int i,n,page0;
 899
 900         int max=0xff;
 901         page0 = 0xe00;
 902
 903         /* This dump the current register page */
 904         len += snprintf(page + len, count - len,
 905                         "\n####################page %x##################\n ", (page0>>8));
 906         for(n=0;n<=max;)
 907         {
 908                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 909                 for(i=0;i<4 && n<=max;n+=4,i++)
 910                         len += snprintf(page + len, count - len,
 911                                         "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
 912         }
 913         len += snprintf(page + len, count - len,"\n");
 914         *eof = 1;
 915         return len;
 916 }
 917
 918 static int proc_get_reg_rf_a(char *page, char **start,
 919                           off_t offset, int count,
 920                           int *eof, void *data)
 921 {
 922         struct net_device *dev = data;
 923
 924         int len = 0;
 925         int i,n;
 926
 927         int max=0xff;
 928
 929         /* This dump the current register page */
 930         len += snprintf(page + len, count - len,
 931                         "\n#################### RF-A ##################\n ");
 932         for(n=0;n<=max;)
 933         {
 934                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 935                 for(i=0;i<4 && n<=max;n+=4,i++)
 936                         len += snprintf(page + len, count - len,
 937                                         "%8.8x ",rtl8192_phy_QueryRFReg(dev, (RF90_RADIO_PATH_E)RF90_PATH_A,n, bMaskDWord));
 938         }
 939         len += snprintf(page + len, count - len,"\n");
 940         *eof = 1;
 941         return len;
 942 }
 943
 944 static int proc_get_reg_rf_b(char *page, char **start,
 945                           off_t offset, int count,
 946                           int *eof, void *data)
 947 {
 948         struct net_device *dev = data;
 949
 950         int len = 0;
 951         int i,n;
 952
 953         int max=0xff;
 954
 955         /* This dump the current register page */
 956         len += snprintf(page + len, count - len,
 957                         "\n#################### RF-B ##################\n ");
 958         for(n=0;n<=max;)
 959         {
 960                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 961                 for(i=0;i<4 && n<=max;n+=4,i++)
 962                         len += snprintf(page + len, count - len,
 963                                         "%8.8x ",rtl8192_phy_QueryRFReg(dev, (RF90_RADIO_PATH_E)RF90_PATH_B, n, bMaskDWord));
 964         }
 965         len += snprintf(page + len, count - len,"\n");
 966         *eof = 1;
 967         return len;
 968 }
 969
 970 static int proc_get_reg_rf_c(char *page, char **start,
 971                           off_t offset, int count,
 972                           int *eof, void *data)
 973 {
 974         struct net_device *dev = data;
 975
 976         int len = 0;
 977         int i,n;
 978
 979         int max=0xff;
 980
 981         /* This dump the current register page */
 982         len += snprintf(page + len, count - len,
 983                         "\n#################### RF-C ##################\n ");
 984         for(n=0;n<=max;)
 985         {
 986                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
 987                 for(i=0;i<4 && n<=max;n+=4,i++)
 988                         len += snprintf(page + len, count - len,
 989                                         "%8.8x ",rtl8192_phy_QueryRFReg(dev, (RF90_RADIO_PATH_E)RF90_PATH_C, n, bMaskDWord));
 990         }
 991         len += snprintf(page + len, count - len,"\n");
 992         *eof = 1;
 993         return len;
 994 }
 995
 996 static int proc_get_reg_rf_d(char *page, char **start,
 997                           off_t offset, int count,
 998                           int *eof, void *data)
 999 {
1000         struct net_device *dev = data;
1001
1002         int len = 0;
1003         int i,n;
1004
1005         int max=0xff;
1006
1007         /* This dump the current register page */
1008         len += snprintf(page + len, count - len,
1009                         "\n#################### RF-D ##################\n ");
1010         for(n=0;n<=max;)
1011         {
1012                 len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
1013                 for(i=0;i<4 && n<=max;n+=4,i++)
1014                         len += snprintf(page + len, count - len,
1015                                         "%8.8x ",rtl8192_phy_QueryRFReg(dev, (RF90_RADIO_PATH_E)RF90_PATH_D, n, bMaskDWord));
1016         }
1017         len += snprintf(page + len, count - len,"\n");
1018         *eof = 1;
1019         return len;
1020 }
1021
1022 static int proc_get_cam_register(char *page, char **start,
1023                           off_t offset, int count,
1024                           int *eof, void *data)
1025 {
1026         struct net_device *dev = data;
1027         u32 target_command=0;
1028         u32 target_content=0;
1029         u8 entry_i=0;
1030         u32 ulStatus;
1031         int len = 0;
1032         int i=100, j = 0;
1033
1034         /* This dump the current register page */
1035         len += snprintf(page + len, count - len,
1036                                 "\n#################### SECURITY CAM ##################\n ");
1037         for(j=0; j<TOTAL_CAM_ENTRY; j++)
1038         {
1039                 if((j>6) && (j<31))
1040                         continue;
1041                 len += snprintf(page + len, count - len, "\nD:  %2x > ",j);
1042                 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
1043                 {
1044                         target_command= entry_i+CAM_CONTENT_COUNT*j;
1045                         target_command= target_command | BIT31;
1046
1047                         while((i--)>=0)
1048                         {
1049                                 ulStatus = read_nic_dword(dev, RWCAM);
1050                                 if(ulStatus & BIT31){
1051                                         continue;
1052                                 }
1053                                 else{
1054                                         break;
1055                                 }
1056                         }
1057                         write_nic_dword(dev, RWCAM, target_command);
1058                         target_content = read_nic_dword(dev, RCAMO);
1059                         len += snprintf(page + len, count - len,"%8.8x ",target_content);
1060                 }
1061         }
1062
1063         len += snprintf(page + len, count - len,"\n");
1064         *eof = 1;
1065         return len;
1066 }
1067
1068 static int proc_get_stats_tx(char *page, char **start,
1069                           off_t offset, int count,
1070                           int *eof, void *data)
1071 {
1072         struct net_device *dev = data;
1073         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1074
1075         int len = 0;
1076
1077         len += snprintf(page + len, count - len,
1078                 "TX VI priority ok int: %lu\n"
1079                 "TX VO priority ok int: %lu\n"
1080                 "TX BE priority ok int: %lu\n"
1081                 "TX BK priority ok int: %lu\n"
1082                 "TX MANAGE priority ok int: %lu\n"
1083                 "TX BEACON priority ok int: %lu\n"
1084                 "TX BEACON priority error int: %lu\n"
1085                 "TX CMDPKT priority ok int: %lu\n"
1086                 "TX queue stopped?: %d\n"
1087                 "TX fifo overflow: %lu\n"
1088                 "TX total data packets %lu\n"
1089                 "TX total data bytes :%lu\n",
1090                 priv->stats.txviokint,
1091                 priv->stats.txvookint,
1092                 priv->stats.txbeokint,
1093                 priv->stats.txbkokint,
1094                 priv->stats.txmanageokint,
1095                 priv->stats.txbeaconokint,
1096                 priv->stats.txbeaconerr,
1097                 priv->stats.txcmdpktokint,
1098                 netif_queue_stopped(dev),
1099                 priv->stats.txoverflow,
1100                 priv->rtllib->stats.tx_packets,
1101                 priv->rtllib->stats.tx_bytes
1102
1103
1104                 );
1105
1106         *eof = 1;
1107         return len;
1108 }
1109
1110
1111
1112 static int proc_get_stats_rx(char *page, char **start,
1113                           off_t offset, int count,
1114                           int *eof, void *data)
1115 {
1116         struct net_device *dev = data;
1117         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1118
1119         int len = 0;
1120
1121         len += snprintf(page + len, count - len,
1122                 "RX packets: %lu\n"
1123                 "RX data crc err: %lu\n"
1124                 "RX mgmt crc err: %lu\n"
1125                 "RX desc err: %lu\n"
1126                 "RX rx overflow error: %lu\n",
1127                 priv->stats.rxint,
1128                 priv->stats.rxdatacrcerr,
1129                 priv->stats.rxmgmtcrcerr,
1130                 priv->stats.rxrdu,
1131                 priv->stats.rxoverflow);
1132
1133         *eof = 1;
1134         return len;
1135 }
1136
1137 void rtl8192_proc_module_init(void)
1138 {
1139         RT_TRACE(COMP_INIT, "Initializing proc filesystem");
1140 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1141         rtl8192_proc=create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
1142 #else
1143         rtl8192_proc=create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
1144 #endif
1145 }
1146
1147
1148 void rtl8192_proc_module_remove(void)
1149 {
1150 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1151         remove_proc_entry(DRV_NAME, proc_net);
1152 #else
1153         remove_proc_entry(DRV_NAME, init_net.proc_net);
1154 #endif
1155 }
1156
1157
1158 void rtl8192_proc_remove_one(struct net_device *dev)
1159 {
1160         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1161
1162         printk("dev name %s\n",dev->name);
1163
1164         if (priv->dir_dev) {
1165                 remove_proc_entry("stats-tx", priv->dir_dev);
1166                 remove_proc_entry("stats-rx", priv->dir_dev);
1167                 remove_proc_entry("stats-ap", priv->dir_dev);
1168                 remove_proc_entry("registers-0", priv->dir_dev);
1169                 remove_proc_entry("registers-1", priv->dir_dev);
1170                 remove_proc_entry("registers-2", priv->dir_dev);
1171                 remove_proc_entry("registers-3", priv->dir_dev);
1172                 remove_proc_entry("registers-4", priv->dir_dev);
1173                 remove_proc_entry("registers-5", priv->dir_dev);
1174                 remove_proc_entry("registers-6", priv->dir_dev);
1175                 remove_proc_entry("registers-7", priv->dir_dev);
1176                 remove_proc_entry("registers-8", priv->dir_dev);
1177                 remove_proc_entry("registers-9", priv->dir_dev);
1178                 remove_proc_entry("registers-a", priv->dir_dev);
1179                 remove_proc_entry("registers-b", priv->dir_dev);
1180                 remove_proc_entry("registers-c", priv->dir_dev);
1181                 remove_proc_entry("registers-d", priv->dir_dev);
1182                 remove_proc_entry("registers-e", priv->dir_dev);
1183                 remove_proc_entry("RF-A", priv->dir_dev);
1184                 remove_proc_entry("RF-B", priv->dir_dev);
1185                 remove_proc_entry("RF-C", priv->dir_dev);
1186                 remove_proc_entry("RF-D", priv->dir_dev);
1187                 remove_proc_entry("SEC-CAM", priv->dir_dev);
1188 #ifdef _RTL8192_EXT_PATCH_
1189                 remove_proc_entry("ra0", rtl8192_proc);
1190 #else
1191                 remove_proc_entry("wlan0", rtl8192_proc);
1192 #endif
1193                 priv->dir_dev = NULL;
1194         }
1195 }
1196
1197
1198 void rtl8192_proc_init_one(struct net_device *dev)
1199 {
1200         struct proc_dir_entry *e;
1201         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1202         priv->dir_dev = create_proc_entry(dev->name,
1203                                           S_IFDIR | S_IRUGO | S_IXUGO,
1204                                           rtl8192_proc);
1205         if (!priv->dir_dev) {
1206                 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
1207                       dev->name);
1208                 return;
1209         }
1210         e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
1211                                    priv->dir_dev, proc_get_stats_rx, dev);
1212
1213         if (!e) {
1214                 RT_TRACE(COMP_ERR,"Unable to initialize "
1215                       "/proc/net/rtl8192/%s/stats-rx\n",
1216                       dev->name);
1217         }
1218
1219
1220         e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
1221                                    priv->dir_dev, proc_get_stats_tx, dev);
1222
1223         if (!e) {
1224                 RT_TRACE(COMP_ERR, "Unable to initialize "
1225                       "/proc/net/rtl8192/%s/stats-tx\n",
1226                       dev->name);
1227         }
1228
1229         e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
1230                                    priv->dir_dev, proc_get_stats_ap, dev);
1231
1232         if (!e) {
1233                 RT_TRACE(COMP_ERR, "Unable to initialize "
1234                       "/proc/net/rtl8192/%s/stats-ap\n",
1235                       dev->name);
1236         }
1237
1238         e = create_proc_read_entry("registers-0", S_IFREG | S_IRUGO,
1239                                    priv->dir_dev, proc_get_registers_0, dev);
1240         if (!e) {
1241                 RT_TRACE(COMP_ERR, "Unable to initialize "
1242                       "/proc/net/rtl8192/%s/registers-0\n",
1243                       dev->name);
1244         }
1245         e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
1246                                    priv->dir_dev, proc_get_registers_1, dev);
1247         if (!e) {
1248                 RT_TRACE(COMP_ERR, "Unable to initialize "
1249                       "/proc/net/rtl8192/%s/registers-1\n",
1250                       dev->name);
1251         }
1252         e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
1253                                    priv->dir_dev, proc_get_registers_2, dev);
1254         if (!e) {
1255                 RT_TRACE(COMP_ERR, "Unable to initialize "
1256                       "/proc/net/rtl8192/%s/registers-2\n",
1257                       dev->name);
1258         }
1259         e = create_proc_read_entry("registers-3", S_IFREG | S_IRUGO,
1260                                    priv->dir_dev, proc_get_registers_3, dev);
1261         if (!e) {
1262                 RT_TRACE(COMP_ERR, "Unable to initialize "
1263                       "/proc/net/rtl8192/%s/registers-3\n",
1264                       dev->name);
1265         }
1266         e = create_proc_read_entry("registers-4", S_IFREG | S_IRUGO,
1267                                    priv->dir_dev, proc_get_registers_4, dev);
1268         if (!e) {
1269                 RT_TRACE(COMP_ERR, "Unable to initialize "
1270                       "/proc/net/rtl8192/%s/registers-4\n",
1271                       dev->name);
1272         }
1273         e = create_proc_read_entry("registers-5", S_IFREG | S_IRUGO,
1274                                    priv->dir_dev, proc_get_registers_5, dev);
1275         if (!e) {
1276                 RT_TRACE(COMP_ERR, "Unable to initialize "
1277                       "/proc/net/rtl8192/%s/registers-5\n",
1278                       dev->name);
1279         }
1280         e = create_proc_read_entry("registers-6", S_IFREG | S_IRUGO,
1281                                    priv->dir_dev, proc_get_registers_6, dev);
1282         if (!e) {
1283                 RT_TRACE(COMP_ERR, "Unable to initialize "
1284                       "/proc/net/rtl8192/%s/registers-6\n",
1285                       dev->name);
1286         }
1287         e = create_proc_read_entry("registers-7", S_IFREG | S_IRUGO,
1288                                    priv->dir_dev, proc_get_registers_7, dev);
1289         if (!e) {
1290                 RT_TRACE(COMP_ERR, "Unable to initialize "
1291                       "/proc/net/rtl8192/%s/registers-7\n",
1292                       dev->name);
1293         }
1294         e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
1295                                    priv->dir_dev, proc_get_registers_8, dev);
1296         if (!e) {
1297                 RT_TRACE(COMP_ERR, "Unable to initialize "
1298                       "/proc/net/rtl8192/%s/registers-8\n",
1299                       dev->name);
1300         }
1301         e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
1302                                    priv->dir_dev, proc_get_registers_9, dev);
1303         if (!e) {
1304                 RT_TRACE(COMP_ERR, "Unable to initialize "
1305                       "/proc/net/rtl8192/%s/registers-9\n",
1306                       dev->name);
1307         }
1308         e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
1309                                    priv->dir_dev, proc_get_registers_a, dev);
1310         if (!e) {
1311                 RT_TRACE(COMP_ERR, "Unable to initialize "
1312                       "/proc/net/rtl8192/%s/registers-a\n",
1313                       dev->name);
1314         }
1315         e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
1316                                    priv->dir_dev, proc_get_registers_b, dev);
1317         if (!e) {
1318                 RT_TRACE(COMP_ERR, "Unable to initialize "
1319                       "/proc/net/rtl8192/%s/registers-b\n",
1320                       dev->name);
1321         }
1322         e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
1323                                    priv->dir_dev, proc_get_registers_c, dev);
1324         if (!e) {
1325                 RT_TRACE(COMP_ERR, "Unable to initialize "
1326                       "/proc/net/rtl8192/%s/registers-c\n",
1327                       dev->name);
1328         }
1329         e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
1330                                    priv->dir_dev, proc_get_registers_d, dev);
1331         if (!e) {
1332                 RT_TRACE(COMP_ERR, "Unable to initialize "
1333                       "/proc/net/rtl8192/%s/registers-d\n",
1334                       dev->name);
1335         }
1336         e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
1337                                    priv->dir_dev, proc_get_registers_e, dev);
1338         if (!e) {
1339                 RT_TRACE(COMP_ERR, "Unable to initialize "
1340                       "/proc/net/rtl8192/%s/registers-e\n",
1341                       dev->name);
1342         }
1343         e = create_proc_read_entry("RF-A", S_IFREG | S_IRUGO,
1344                                    priv->dir_dev, proc_get_reg_rf_a, dev);
1345         if (!e) {
1346                 RT_TRACE(COMP_ERR, "Unable to initialize "
1347                       "/proc/net/rtl8192/%s/RF-A\n",
1348                       dev->name);
1349         }
1350         e = create_proc_read_entry("RF-B", S_IFREG | S_IRUGO,
1351                                    priv->dir_dev, proc_get_reg_rf_b, dev);
1352         if (!e) {
1353                 RT_TRACE(COMP_ERR, "Unable to initialize "
1354                       "/proc/net/rtl8192/%s/RF-B\n",
1355                       dev->name);
1356         }
1357         e = create_proc_read_entry("RF-C", S_IFREG | S_IRUGO,
1358                                    priv->dir_dev, proc_get_reg_rf_c, dev);
1359         if (!e) {
1360                 RT_TRACE(COMP_ERR, "Unable to initialize "
1361                       "/proc/net/rtl8192/%s/RF-C\n",
1362                       dev->name);
1363         }
1364         e = create_proc_read_entry("RF-D", S_IFREG | S_IRUGO,
1365                                    priv->dir_dev, proc_get_reg_rf_d, dev);
1366         if (!e) {
1367                 RT_TRACE(COMP_ERR, "Unable to initialize "
1368                       "/proc/net/rtl8192/%s/RF-D\n",
1369                       dev->name);
1370         }
1371         e = create_proc_read_entry("SEC-CAM", S_IFREG | S_IRUGO,
1372                                    priv->dir_dev, proc_get_cam_register, dev);
1373         if (!e) {
1374                 RT_TRACE(COMP_ERR, "Unable to initialize "
1375                       "/proc/net/rtl8192/%s/SEC-CAM\n",
1376                       dev->name);
1377         }
1378 #ifdef _RTL8192_EXT_PATCH_
1379         if( priv->mshobj && priv->mshobj->ext_patch_create_proc )
1380                 priv->mshobj->ext_patch_create_proc(priv);
1381 #endif
1382
1383 }
1384