drivers/net/wireless/rockchip_wlan/rtl8189es/core/rtw_debug.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTW_DEBUG_C_
  21
  22 #include <drv_types.h>
  23
  24 u32 GlobalDebugLevel = _drv_err_;
  25
  26 #ifdef CONFIG_DEBUG_RTL871X
  27
  28         u64 GlobalDebugComponents = \
  29                         _module_rtl871x_xmit_c_ |
  30                         _module_xmit_osdep_c_ |
  31                         _module_rtl871x_recv_c_ |
  32                         _module_recv_osdep_c_ |
  33                         _module_rtl871x_mlme_c_ |
  34                         _module_mlme_osdep_c_ |
  35                         _module_rtl871x_sta_mgt_c_ |
  36                         _module_rtl871x_cmd_c_ |
  37                         _module_cmd_osdep_c_ |
  38                         _module_rtl871x_io_c_ |
  39                         _module_io_osdep_c_ |
  40                         _module_os_intfs_c_|
  41                         _module_rtl871x_security_c_|
  42                         _module_rtl871x_eeprom_c_|
  43                         _module_hal_init_c_|
  44                         _module_hci_hal_init_c_|
  45                         _module_rtl871x_ioctl_c_|
  46                         _module_rtl871x_ioctl_set_c_|
  47                         _module_rtl871x_ioctl_query_c_|
  48                         _module_rtl871x_pwrctrl_c_|
  49                         _module_hci_intfs_c_|
  50                         _module_hci_ops_c_|
  51                         _module_hci_ops_os_c_|
  52                         _module_rtl871x_ioctl_os_c|
  53                         _module_rtl8712_cmd_c_|
  54                         _module_hal_xmit_c_|
  55                         _module_rtl8712_recv_c_ |
  56                         _module_mp_ |
  57                         _module_efuse_;
  58
  59 #endif /* CONFIG_DEBUG_RTL871X */
  60
  61 #include <rtw_version.h>
  62
  63 void dump_drv_version(void *sel)
  64 {
  65         DBG_871X_SEL_NL(sel, "%s %s\n", DRV_NAME, DRIVERVERSION);
  66         DBG_871X_SEL_NL(sel, "build time: %s %s\n", __DATE__, __TIME__);
  67 }
  68
  69 void dump_log_level(void *sel)
  70 {
  71         DBG_871X_SEL_NL(sel, "log_level:%d\n", GlobalDebugLevel);
  72 }
  73
  74 #ifdef CONFIG_SDIO_HCI
  75 void sd_f0_reg_dump(void *sel, _adapter *adapter)
  76 {
  77         int i;
  78
  79         for(i=0x0;i<=0xff;i++)
  80         {
  81                 if(i%16==0)
  82                         DBG_871X_SEL_NL(sel, "0x%02x ",i);
  83
  84                 DBG_871X_SEL(sel, "%02x ", rtw_sd_f0_read8(adapter, i));
  85
  86                 if(i%16==15)
  87                         DBG_871X_SEL(sel, "\n");
  88                 else if(i%8==7)
  89                         DBG_871X_SEL(sel, "\t");
  90         }
  91 }
  92 #endif /* CONFIG_SDIO_HCI */
  93
  94 void mac_reg_dump(void *sel, _adapter *adapter)
  95 {
  96         int i, j = 1;
  97
  98         DBG_871X_SEL_NL(sel, "======= MAC REG =======\n");
  99
 100         for(i=0x0;i<0x800;i+=4)
 101         {
 102                 if(j%4==1)
 103                         DBG_871X_SEL_NL(sel, "0x%03x",i);
 104                 DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter,i));
 105                 if((j++)%4 == 0)
 106                         DBG_871X_SEL(sel, "\n");
 107         }
 108 }
 109
 110 void bb_reg_dump(void *sel, _adapter *adapter)
 111 {
 112         int i, j = 1;
 113
 114         DBG_871X_SEL_NL(sel, "======= BB REG =======\n");
 115         for(i=0x800;i<0x1000;i+=4)
 116         {
 117                 if(j%4==1)
 118                         DBG_871X_SEL_NL(sel, "0x%03x",i);
 119                 DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter,i));
 120                 if((j++)%4 == 0)
 121                         DBG_871X_SEL(sel, "\n");
 122         }
 123 }
 124
 125 void rf_reg_dump(void *sel, _adapter *adapter)
 126 {
 127         int i, j = 1, path;
 128         u32 value;
 129         u8 rf_type = 0;
 130         u8 path_nums = 0;
 131
 132         rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 133         if((RF_1T2R == rf_type) ||(RF_1T1R ==rf_type ))
 134                 path_nums = 1;
 135         else
 136                 path_nums = 2;
 137
 138         DBG_871X_SEL_NL(sel, "======= RF REG =======\n");
 139
 140         for (path=0;path<path_nums;path++) {
 141                 DBG_871X_SEL_NL(sel, "RF_Path(%x)\n",path);
 142                 for (i=0;i<0x100;i++) {
 143                         //value = PHY_QueryRFReg(adapter, (RF90_RADIO_PATH_E)path,i, bMaskDWord);
 144                         value = rtw_hal_read_rfreg(adapter, path, i, 0xffffffff);
 145                         if(j%4==1)
 146                                 DBG_871X_SEL_NL(sel, "0x%02x ",i);
 147                         DBG_871X_SEL(sel, " 0x%08x ",value);
 148                         if((j++)%4==0)
 149                                 DBG_871X_SEL(sel, "\n");
 150                 }
 151         }
 152 }
 153
 154 #ifdef CONFIG_PROC_DEBUG
 155 ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 156 {
 157         struct net_device *dev = data;
 158         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 159         char tmp[32];
 160         u32 addr, val, len;
 161
 162         if (count < 3)
 163         {
 164                 DBG_871X("argument size is less than 3\n");
 165                 return -EFAULT;
 166         }
 167
 168         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 169
 170                 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
 171
 172                 if (num !=  3) {
 173                         DBG_871X("invalid write_reg parameter!\n");
 174                         return count;
 175                 }
 176
 177                 switch(len)
 178                 {
 179                         case 1:
 180                                 rtw_write8(padapter, addr, (u8)val);
 181                                 break;
 182                         case 2:
 183                                 rtw_write16(padapter, addr, (u16)val);
 184                                 break;
 185                         case 4:
 186                                 rtw_write32(padapter, addr, val);
 187                                 break;
 188                         default:
 189                                 DBG_871X("error write length=%d", len);
 190                                 break;
 191                 }
 192
 193         }
 194
 195         return count;
 196
 197 }
 198
 199 static u32 proc_get_read_addr=0xeeeeeeee;
 200 static u32 proc_get_read_len=0x4;
 201
 202 int proc_get_read_reg(struct seq_file *m, void *v)
 203 {
 204         struct net_device *dev = m->private;
 205         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 206
 207         if (proc_get_read_addr==0xeeeeeeee) {
 208                 DBG_871X_SEL_NL(m, "address not initialized\n");
 209                 return 0;
 210         }
 211
 212         switch(proc_get_read_len)
 213         {
 214                 case 1:
 215                         DBG_871X_SEL_NL(m, "rtw_read8(0x%x)=0x%x\n", proc_get_read_addr, rtw_read8(padapter, proc_get_read_addr));
 216                         break;
 217                 case 2:
 218                         DBG_871X_SEL_NL(m, "rtw_read16(0x%x)=0x%x\n", proc_get_read_addr, rtw_read16(padapter, proc_get_read_addr));
 219                         break;
 220                 case 4:
 221                         DBG_871X_SEL_NL(m, "rtw_read32(0x%x)=0x%x\n", proc_get_read_addr, rtw_read32(padapter, proc_get_read_addr));
 222                         break;
 223                 default:
 224                         DBG_871X_SEL_NL(m, "error read length=%d\n", proc_get_read_len);
 225                         break;
 226         }
 227
 228         return 0;
 229 }
 230
 231 ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 232 {
 233         struct net_device *dev = data;
 234         char tmp[16];
 235         u32 addr, len;
 236
 237         if (count < 2)
 238         {
 239                 DBG_871X("argument size is less than 2\n");
 240                 return -EFAULT;
 241         }
 242
 243         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 244
 245                 int num = sscanf(tmp, "%x %x", &addr, &len);
 246
 247                 if (num !=  2) {
 248                         DBG_871X("invalid read_reg parameter!\n");
 249                         return count;
 250                 }
 251
 252                 proc_get_read_addr = addr;
 253
 254                 proc_get_read_len = len;
 255         }
 256
 257         return count;
 258
 259 }
 260
 261 int proc_get_fwstate(struct seq_file *m, void *v)
 262 {
 263         struct net_device *dev = m->private;
 264         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 265         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 266
 267         DBG_871X_SEL_NL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
 268
 269         return 0;
 270 }
 271
 272 int proc_get_sec_info(struct seq_file *m, void *v)
 273 {
 274         struct net_device *dev = m->private;
 275         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 276         struct security_priv *sec = &padapter->securitypriv;
 277
 278         DBG_871X_SEL_NL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
 279                                                 sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
 280                                                 sec->ndisauthtype, sec->ndisencryptstatus);
 281
 282         DBG_871X_SEL_NL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
 283
 284 #ifdef DBG_SW_SEC_CNT
 285         DBG_871X_SEL_NL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
 286                 , sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
 287         DBG_871X_SEL_NL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
 288                 , sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
 289
 290         DBG_871X_SEL_NL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
 291                 , sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
 292         DBG_871X_SEL_NL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
 293                 , sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
 294
 295         DBG_871X_SEL_NL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
 296                 , sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
 297         DBG_871X_SEL_NL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
 298                 , sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
 299 #endif /* DBG_SW_SEC_CNT */
 300
 301         return 0;
 302 }
 303
 304 int proc_get_mlmext_state(struct seq_file *m, void *v)
 305 {
 306         struct net_device *dev = m->private;
 307         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 308         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 309         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 310
 311         DBG_871X_SEL_NL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
 312
 313         return 0;
 314 }
 315
 316 #ifdef CONFIG_LAYER2_ROAMING
 317 int proc_get_roam_flags(struct seq_file *m, void *v)
 318 {
 319         struct net_device *dev = m->private;
 320         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 321
 322         DBG_871X_SEL_NL(m, "0x%02x\n", rtw_roam_flags(adapter));
 323
 324         return 0;
 325 }
 326
 327 ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 328 {
 329         struct net_device *dev = data;
 330         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 331
 332         char tmp[32];
 333         u8 flags;
 334
 335         if (count < 1)
 336                 return -EFAULT;
 337
 338         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 339
 340                 int num = sscanf(tmp, "%hhx", &flags);
 341
 342                 if (num == 1)
 343                         rtw_assign_roam_flags(adapter, flags);
 344         }
 345
 346         return count;
 347
 348 }
 349
 350 int proc_get_roam_param(struct seq_file *m, void *v)
 351 {
 352         struct net_device *dev = m->private;
 353         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 354         struct mlme_priv *mlme = &adapter->mlmepriv;
 355
 356         DBG_871X_SEL_NL(m, "%12s %12s %11s\n", "rssi_diff_th", "scanr_exp_ms", "scan_int_ms");
 357         DBG_871X_SEL_NL(m, "%-12u %-12u %-11u\n"
 358                 , mlme->roam_rssi_diff_th
 359                 , mlme->roam_scanr_exp_ms
 360                 , mlme->roam_scan_int_ms
 361         );
 362
 363         return 0;
 364 }
 365
 366 ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 367 {
 368         struct net_device *dev = data;
 369         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 370         struct mlme_priv *mlme = &adapter->mlmepriv;
 371
 372         char tmp[32];
 373         u8 rssi_diff_th;
 374         u32 scanr_exp_ms;
 375         u32 scan_int_ms;
 376
 377         if (count < 1)
 378                 return -EFAULT;
 379
 380         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 381
 382                 int num = sscanf(tmp, "%hhu %u %u", &rssi_diff_th, &scanr_exp_ms, &scan_int_ms);
 383
 384                 if (num >= 1)
 385                         mlme->roam_rssi_diff_th = rssi_diff_th;
 386                 if (num >= 2)
 387                         mlme->roam_scanr_exp_ms = scanr_exp_ms;
 388                 if (num >= 3)
 389                         mlme->roam_scan_int_ms = scan_int_ms;
 390         }
 391
 392         return count;
 393
 394 }
 395
 396 ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 397 {
 398         struct net_device *dev = data;
 399         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 400
 401         char tmp[32];
 402         u8 addr[ETH_ALEN];
 403
 404         if (count < 1)
 405                 return -EFAULT;
 406
 407         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 408
 409                 int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr+1, addr+2, addr+3, addr+4, addr+5);
 410                 if (num == 6)
 411                         _rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
 412
 413                 DBG_871X("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
 414         }
 415
 416         return count;
 417 }
 418 #endif /* CONFIG_LAYER2_ROAMING */
 419
 420 int proc_get_qos_option(struct seq_file *m, void *v)
 421 {
 422         struct net_device *dev = m->private;
 423         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 424         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 425
 426         DBG_871X_SEL_NL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
 427
 428         return 0;
 429 }
 430
 431 int proc_get_ht_option(struct seq_file *m, void *v)
 432 {
 433         struct net_device *dev = m->private;
 434         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 435         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 436
 437 #ifdef CONFIG_80211N_HT
 438         DBG_871X_SEL_NL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
 439 #endif //CONFIG_80211N_HT
 440
 441         return 0;
 442 }
 443
 444 int proc_get_rf_info(struct seq_file *m, void *v)
 445 {
 446         struct net_device *dev = m->private;
 447         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 448         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 449
 450         DBG_871X_SEL_NL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
 451                                         pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 452
 453         DBG_871X_SEL_NL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
 454                                         rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter),  rtw_get_oper_choffset(padapter));
 455
 456         return 0;
 457 }
 458
 459 int proc_get_survey_info(struct seq_file *m, void *v)
 460 {
 461         _irqL irqL;
 462         struct net_device *dev = m->private;
 463         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 464         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 465         _queue  *queue  = &(pmlmepriv->scanned_queue);
 466         struct wlan_network     *pnetwork = NULL;
 467         _list   *plist, *phead;
 468         s32 notify_signal;
 469         u16  index = 0;
 470
 471         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 472         phead = get_list_head(queue);
 473         plist = get_next(phead);
 474         if ((!phead) || (!plist))
 475                 return 0;
 476
 477         DBG_871X_SEL_NL(m, "%5s  %-17s  %3s  %-3s  %-4s  %5s  %s\n","index", "bssid", "ch", "dBm", "SdBm", "age", "ssid");
 478         while(1)
 479         {
 480                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
 481                         break;
 482
 483                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
 484                 if (!pnetwork)
 485                         break;
 486
 487                 if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE &&
 488                         is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
 489                         notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);//dbm
 490                 } else {
 491                         notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);//dbm
 492                 }
 493
 494                 DBG_871X_SEL_NL(m, "%5d  "MAC_FMT"  %3d  %3d  %4d  %5d  %s\n",
 495                         ++index,
 496                         MAC_ARG(pnetwork->network.MacAddress),
 497                         pnetwork->network.Configuration.DSConfig,
 498                         (int)pnetwork->network.Rssi,
 499                         notify_signal,
 500                         rtw_get_passing_time_ms((u32)pnetwork->last_scanned),
 501                         //translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength),
 502                         pnetwork->network.Ssid.Ssid);
 503                 plist = get_next(plist);
 504         }
 505         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 506
 507         return 0;
 508 }
 509
 510 int proc_get_ap_info(struct seq_file *m, void *v)
 511 {
 512         struct net_device *dev = m->private;
 513         struct sta_info *psta;
 514         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 515         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 516         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 517         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
 518         struct sta_priv *pstapriv = &padapter->stapriv;
 519
 520         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
 521         if(psta)
 522         {
 523                 int i;
 524                 struct recv_reorder_ctrl *preorder_ctrl;
 525
 526                 DBG_871X_SEL_NL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
 527                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
 528                 DBG_871X_SEL_NL(m, "cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 529                 DBG_871X_SEL_NL(m, "wireless_mode=0x%x, rtsen=%d, cts2slef=%d\n", psta->wireless_mode, psta->rtsen, psta->cts2self);
 530                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
 531 #ifdef CONFIG_80211N_HT
 532                 DBG_871X_SEL_NL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
 533                 DBG_871X_SEL_NL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n", psta->bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
 534                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 535                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
 536                 DBG_871X_SEL_NL(m, "ldpc_cap=0x%x, stbc_cap=0x%x, beamform_cap=0x%x\n", psta->htpriv.ldpc_cap, psta->htpriv.stbc_cap, psta->htpriv.beamform_cap);
 537 #endif //CONFIG_80211N_HT
 538 #ifdef CONFIG_80211AC_VHT
 539                 DBG_871X_SEL_NL(m, "vht_en=%d, vht_sgi_80m=%d\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
 540                 DBG_871X_SEL_NL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", psta->vhtpriv.ldpc_cap, psta->vhtpriv.stbc_cap, psta->vhtpriv.beamform_cap);
 541                 DBG_871X_SEL_NL(m, "vht_mcs_map=0x%x, vht_highest_rate=0x%x, vht_ampdu_len=%d\n", *(u16*)psta->vhtpriv.vht_mcs_map, psta->vhtpriv.vht_highest_rate, psta->vhtpriv.ampdu_len);
 542 #endif
 543
 544                 for(i=0;i<16;i++)
 545                 {
 546                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 547                         if(preorder_ctrl->enable)
 548                         {
 549                                 DBG_871X_SEL_NL(m, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
 550                         }
 551                 }
 552
 553         }
 554         else
 555         {
 556                 DBG_871X_SEL_NL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
 557         }
 558
 559         return 0;
 560 }
 561
 562 int proc_get_adapter_state(struct seq_file *m, void *v)
 563 {
 564         struct net_device *dev = m->private;
 565         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 566
 567         DBG_871X_SEL_NL(m, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
 568                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
 569
 570         return 0;
 571 }
 572
 573 int proc_get_trx_info(struct seq_file *m, void *v)
 574 {
 575         struct net_device *dev = m->private;
 576         int i;
 577         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 578         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 579         struct recv_priv  *precvpriv = &padapter->recvpriv;
 580         struct hw_xmit *phwxmit;
 581
 582         DBG_871X_SEL_NL(m, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d\n"
 583                 , pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt);
 584         DBG_871X_SEL_NL(m, "free_ext_xmitbuf_cnt=%d, free_xframe_ext_cnt=%d\n"
 585                 , pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt);
 586         DBG_871X_SEL_NL(m, "free_recvframe_cnt=%d\n"
 587                 , precvpriv->free_recvframe_cnt);
 588
 589         for(i = 0; i < 4; i++)
 590         {
 591                 phwxmit = pxmitpriv->hwxmits + i;
 592                 DBG_871X_SEL_NL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
 593         }
 594
 595 #ifdef CONFIG_USB_HCI
 596         DBG_871X_SEL_NL(m, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
 597 #endif
 598
 599         return 0;
 600 }
 601
 602 int proc_get_rate_ctl(struct seq_file *m, void *v)
 603 {
 604         struct net_device *dev = m->private;
 605         int i;
 606         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 607
 608         if (adapter->fix_rate != 0xff) {
 609                 DBG_871X_SEL_NL(m, "FIX\n");
 610                 DBG_871X_SEL_NL(m, "0x%02x\n", adapter->fix_rate);
 611         } else {
 612                 DBG_871X_SEL_NL(m, "RA\n");
 613         }
 614
 615         return 0;
 616 }
 617
 618 ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 619 {
 620         struct net_device *dev = data;
 621         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 622         char tmp[32];
 623         u8 fix_rate;
 624
 625         if (count < 1)
 626                 return -EFAULT;
 627
 628         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 629
 630                 int num = sscanf(tmp, "%hhx", &fix_rate);
 631
 632                 if (num >= 1)
 633                         adapter->fix_rate = fix_rate;
 634         }
 635
 636         return count;
 637 }
 638
 639 u8 g_fwdl_chksum_fail = 0;
 640 u8 g_fwdl_wintint_rdy_fail = 0;
 641
 642 ssize_t proc_set_fwdl_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 643 {
 644         struct net_device *dev = data;
 645         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 646         char tmp[32];
 647
 648         if (count < 1)
 649                 return -EFAULT;
 650
 651         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 652                 int num = sscanf(tmp, "%hhu %hhu", &g_fwdl_chksum_fail, &g_fwdl_wintint_rdy_fail);
 653         }
 654
 655         return count;
 656 }
 657
 658 u32 g_wait_hiq_empty = 0;
 659
 660 ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 661 {
 662         struct net_device *dev = data;
 663         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 664         char tmp[32];
 665
 666         if (count < 1)
 667                 return -EFAULT;
 668
 669         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 670                 int num = sscanf(tmp, "%u", &g_wait_hiq_empty);
 671         }
 672
 673         return count;
 674 }
 675
 676 int proc_get_suspend_resume_info(struct seq_file *m, void *v)
 677 {
 678         struct net_device *dev = m->private;
 679         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 680         struct dvobj_priv *dvobj = padapter->dvobj;
 681         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
 682
 683         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
 684         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
 685         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n",pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
 686         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
 687         DBG_871X_SEL_NL(m, "dbg_sdio_init_error_cnt=%d\n",pdbgpriv->dbg_sdio_init_error_cnt);
 688         DBG_871X_SEL_NL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
 689         DBG_871X_SEL_NL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
 690         DBG_871X_SEL_NL(m, "dbg_suspend_cnt=%d\n",pdbgpriv->dbg_suspend_cnt);
 691         DBG_871X_SEL_NL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
 692         DBG_871X_SEL_NL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
 693         DBG_871X_SEL_NL(m, "dbg_deinit_fail_cnt=%d\n",pdbgpriv->dbg_deinit_fail_cnt);
 694         DBG_871X_SEL_NL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
 695         DBG_871X_SEL_NL(m, "dbg_ps_insuspend_cnt=%d\n",pdbgpriv->dbg_ps_insuspend_cnt);
 696         DBG_871X_SEL_NL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
 697         DBG_871X_SEL_NL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
 698         DBG_871X_SEL_NL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
 699         DBG_871X_SEL_NL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
 700         DBG_871X_SEL_NL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
 701         DBG_871X_SEL_NL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
 702         DBG_871X_SEL_NL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
 703         DBG_871X_SEL_NL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
 704         DBG_871X_SEL_NL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
 705         DBG_871X_SEL_NL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
 706         DBG_871X_SEL_NL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
 707         DBG_871X_SEL_NL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
 708         DBG_871X_SEL_NL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
 709         DBG_871X_SEL_NL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
 710         DBG_871X_SEL_NL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
 711
 712         return 0;
 713 }
 714
 715 int proc_get_rx_signal(struct seq_file *m, void *v)
 716 {
 717         struct net_device *dev = m->private;
 718         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 719         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 720
 721         DBG_871X_SEL_NL(m, "rssi:%d\n", padapter->recvpriv.rssi);
 722         //DBG_871X_SEL_NL(m, "rxpwdb:%d\n", padapter->recvpriv.rxpwdb);
 723         DBG_871X_SEL_NL(m, "signal_strength:%u\n", padapter->recvpriv.signal_strength);
 724         DBG_871X_SEL_NL(m, "signal_qual:%u\n", padapter->recvpriv.signal_qual);
 725         DBG_871X_SEL_NL(m, "noise:%u\n", padapter->recvpriv.noise);
 726         rtw_odm_get_perpkt_rssi(m,padapter);
 727         #ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
 728         rtw_get_raw_rssi_info(m,padapter);
 729         #endif
 730         return 0;
 731 }
 732
 733
 734 int proc_get_hw_status(struct seq_file *m, void *v)
 735 {
 736         struct net_device *dev = m->private;
 737         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 738         struct dvobj_priv *dvobj = padapter->dvobj;
 739         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
 740
 741         DBG_871X_SEL_NL(m, "RX FIFO full count: last_time=%lld, current_time=%lld, differential=%lld\n"
 742         , pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
 743
 744         return 0;
 745 }
 746
 747 ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 748 {
 749         struct net_device *dev = data;
 750         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 751         char tmp[32];
 752         u32 is_signal_dbg, signal_strength;
 753
 754         if (count < 1)
 755                 return -EFAULT;
 756
 757         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 758
 759                 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
 760
 761                 is_signal_dbg = is_signal_dbg==0?0:1;
 762
 763                 if(is_signal_dbg && num!=2)
 764                         return count;
 765
 766                 signal_strength = signal_strength>100?100:signal_strength;
 767
 768                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
 769                 padapter->recvpriv.signal_strength_dbg=signal_strength;
 770
 771                 if(is_signal_dbg)
 772                         DBG_871X("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
 773                 else
 774                         DBG_871X("set %s\n", "HW_SIGNAL_STRENGTH");
 775
 776         }
 777
 778         return count;
 779
 780 }
 781 #ifdef CONFIG_80211N_HT
 782
 783 int proc_get_ht_enable(struct seq_file *m, void *v)
 784 {
 785         struct net_device *dev = m->private;
 786         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 787         struct registry_priv    *pregpriv = &padapter->registrypriv;
 788
 789         if(pregpriv)
 790                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ht_enable);
 791
 792         return 0;
 793 }
 794
 795 ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 796 {
 797         struct net_device *dev = data;
 798         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 799         struct registry_priv    *pregpriv = &padapter->registrypriv;
 800         char tmp[32];
 801         u32 mode;
 802
 803         if (count < 1)
 804                 return -EFAULT;
 805
 806         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 807
 808                 int num = sscanf(tmp, "%d ", &mode);
 809
 810                 if( pregpriv && mode >= 0 && mode < 2 )
 811                 {
 812                         pregpriv->ht_enable= mode;
 813                         printk("ht_enable=%d\n", pregpriv->ht_enable);
 814                 }
 815         }
 816
 817         return count;
 818
 819 }
 820
 821 int proc_get_bw_mode(struct seq_file *m, void *v)
 822 {
 823         struct net_device *dev = m->private;
 824         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 825         struct registry_priv    *pregpriv = &padapter->registrypriv;
 826
 827         if(pregpriv)
 828                 DBG_871X_SEL_NL(m, "0x%02x\n", pregpriv->bw_mode);
 829
 830         return 0;
 831 }
 832
 833 ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 834 {
 835         struct net_device *dev = data;
 836         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 837         struct registry_priv    *pregpriv = &padapter->registrypriv;
 838         char tmp[32];
 839         u32 mode;
 840
 841         if (count < 1)
 842                 return -EFAULT;
 843
 844         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 845
 846                 int num = sscanf(tmp, "%d ", &mode);
 847
 848                 if( pregpriv &&  mode < 2 )
 849                 {
 850
 851                         pregpriv->bw_mode = mode;
 852                         printk("bw_mode=%d\n", mode);
 853
 854                 }
 855         }
 856
 857         return count;
 858
 859 }
 860
 861 int proc_get_ampdu_enable(struct seq_file *m, void *v)
 862 {
 863         struct net_device *dev = m->private;
 864         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 865         struct registry_priv    *pregpriv = &padapter->registrypriv;
 866
 867         if(pregpriv)
 868                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ampdu_enable);
 869
 870         return 0;
 871 }
 872
 873 ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 874 {
 875         struct net_device *dev = data;
 876         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 877         struct registry_priv    *pregpriv = &padapter->registrypriv;
 878         char tmp[32];
 879         u32 mode;
 880
 881         if (count < 1)
 882                 return -EFAULT;
 883
 884         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 885
 886                 int num = sscanf(tmp, "%d ", &mode);
 887
 888                 if( pregpriv && mode < 3 )
 889                 {
 890                         pregpriv->ampdu_enable= mode;
 891                         printk("ampdu_enable=%d\n", mode);
 892                 }
 893
 894         }
 895
 896         return count;
 897
 898 }
 899
 900 int proc_get_rx_ampdu(struct seq_file *m, void *v)
 901 {
 902         struct net_device *dev = m->private;
 903         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 904         struct registry_priv    *pregpriv = &padapter->registrypriv;
 905         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 906         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 907
 908         if(pregpriv)
 909                 DBG_871X_SEL_NL(m,
 910                         "bAcceptAddbaReq = %d , 0:Reject AP's Add BA req, 1:Accept AP's Add BA req.\n", pmlmeinfo->bAcceptAddbaReq
 911                         );
 912
 913         return 0;
 914 }
 915
 916 ssize_t proc_set_rx_ampdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 917 {
 918         struct net_device *dev = data;
 919         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 920         struct registry_priv    *pregpriv = &padapter->registrypriv;
 921         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 922         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 923         char tmp[32];
 924         u32 mode;
 925
 926         if (count < 1)
 927                 return -EFAULT;
 928
 929         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 930
 931                 int num = sscanf(tmp, "%d ", &mode);
 932
 933                 if( pregpriv && mode >= 0 && mode < 2 )
 934                 {
 935                         pmlmeinfo->bAcceptAddbaReq = mode;
 936                         DBG_871X("pmlmeinfo->bAcceptAddbaReq=%d \n",pmlmeinfo->bAcceptAddbaReq);
 937                         if(mode == 0)
 938                         {
 939                                 //tear down Rx AMPDU
 940                                 send_delba(padapter, 0, get_my_bssid(&(pmlmeinfo->network)));// recipient
 941                         }
 942                 }
 943
 944         }
 945
 946         return count;
 947 }
 948
 949 #endif //CONFIG_80211N_HT
 950
 951 int proc_get_en_fwps(struct seq_file *m, void *v)
 952 {
 953         struct net_device *dev = m->private;
 954         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 955         struct registry_priv    *pregpriv = &padapter->registrypriv;
 956         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 957         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 958
 959         if(pregpriv)
 960                 DBG_871X_SEL_NL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
 961                         , pregpriv->check_fw_ps);
 962
 963         return 0;
 964 }
 965
 966 ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 967 {
 968         struct net_device *dev = data;
 969         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 970         struct registry_priv    *pregpriv = &padapter->registrypriv;
 971         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 972         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 973         char tmp[32];
 974         u32 mode;
 975
 976         if (count < 1)
 977                 return -EFAULT;
 978
 979         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 980
 981                 int num = sscanf(tmp, "%d ", &mode);
 982
 983                 if( pregpriv && mode >= 0 && mode < 2 )
 984                 {
 985                         pregpriv->check_fw_ps = mode;
 986                         DBG_871X("pregpriv->check_fw_ps=%d \n",pregpriv->check_fw_ps);
 987                 }
 988
 989         }
 990
 991         return count;
 992 }
 993
 994 /*
 995 int proc_get_two_path_rssi(struct seq_file *m, void *v)
 996 {
 997         struct net_device *dev = m->private;
 998         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 999
1000         if(padapter)
1001                 DBG_871X_SEL_NL(m, "%d %d\n",
1002                         padapter->recvpriv.RxRssi[0], padapter->recvpriv.RxRssi[1]);
1003
1004         return 0;
1005 }
1006 */
1007 #ifdef CONFIG_80211N_HT
1008 int proc_get_rx_stbc(struct seq_file *m, void *v)
1009 {
1010         struct net_device *dev = m->private;
1011         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1012         struct registry_priv    *pregpriv = &padapter->registrypriv;
1013
1014         if(pregpriv)
1015                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->rx_stbc);
1016
1017         return 0;
1018 }
1019
1020 ssize_t proc_set_rx_stbc(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1021 {
1022         struct net_device *dev = data;
1023         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1024         struct registry_priv    *pregpriv = &padapter->registrypriv;
1025         char tmp[32];
1026         u32 mode;
1027
1028         if (count < 1)
1029                 return -EFAULT;
1030
1031         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1032
1033                 int num = sscanf(tmp, "%d ", &mode);
1034
1035                 if( pregpriv && (mode == 0 || mode == 1|| mode == 2|| mode == 3))
1036                 {
1037                         pregpriv->rx_stbc= mode;
1038                         printk("rx_stbc=%d\n", mode);
1039                 }
1040         }
1041
1042         return count;
1043
1044 }
1045 #endif //CONFIG_80211N_HT
1046
1047 int proc_get_rssi_disp(struct seq_file *m, void *v)
1048 {
1049         struct net_device *dev = m->private;
1050         return 0;
1051 }
1052
1053 ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1054 {
1055         struct net_device *dev = data;
1056         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1057         char tmp[32];
1058         u32 enable=0;
1059
1060         if (count < 1)
1061         {
1062                 DBG_8192C("argument size is less than 1\n");
1063                 return -EFAULT;
1064         }
1065
1066         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1067
1068                 int num = sscanf(tmp, "%x", &enable);
1069
1070                 if (num !=  1) {
1071                         DBG_8192C("invalid set_rssi_disp parameter!\n");
1072                         return count;
1073                 }
1074
1075                 if(enable)
1076                 {
1077                         DBG_8192C("Linked info Function Enable\n");
1078                         padapter->bLinkInfoDump = enable ;
1079                 }
1080                 else
1081                 {
1082                         DBG_8192C("Linked info Function Disable\n");
1083                         padapter->bLinkInfoDump = 0 ;
1084                 }
1085
1086         }
1087
1088         return count;
1089
1090 }
1091
1092
1093 #ifdef CONFIG_AP_MODE
1094
1095 int proc_get_all_sta_info(struct seq_file *m, void *v)
1096 {
1097         struct net_device *dev = m->private;
1098         _irqL irqL;
1099         struct sta_info *psta;
1100         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1101         struct sta_priv *pstapriv = &padapter->stapriv;
1102         int i, j;
1103         _list   *plist, *phead;
1104         struct recv_reorder_ctrl *preorder_ctrl;
1105
1106         DBG_871X_SEL_NL(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
1107
1108         _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
1109
1110         for(i=0; i< NUM_STA; i++)
1111         {
1112                 phead = &(pstapriv->sta_hash[i]);
1113                 plist = get_next(phead);
1114
1115                 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
1116                 {
1117                         psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
1118
1119                         plist = get_next(plist);
1120
1121                         //if(extra_arg == psta->aid)
1122                         {
1123                                 DBG_871X_SEL_NL(m, "==============================\n");
1124                                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
1125                                 DBG_871X_SEL_NL(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
1126                                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
1127 #ifdef CONFIG_80211N_HT
1128                                 DBG_871X_SEL_NL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
1129                                 DBG_871X_SEL_NL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n", psta->bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
1130                                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
1131                                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
1132 #endif //CONFIG_80211N_HT
1133                                 DBG_871X_SEL_NL(m, "sleepq_len=%d\n", psta->sleepq_len);
1134                                 DBG_871X_SEL_NL(m, "capability=0x%x\n", psta->capability);
1135                                 DBG_871X_SEL_NL(m, "flags=0x%x\n", psta->flags);
1136                                 DBG_871X_SEL_NL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
1137                                 DBG_871X_SEL_NL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
1138                                 DBG_871X_SEL_NL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
1139                                 DBG_871X_SEL_NL(m, "qos_info=0x%x\n", psta->qos_info);
1140                                 DBG_871X_SEL_NL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
1141
1142                                 for(j=0;j<16;j++)
1143                                 {
1144                                         preorder_ctrl = &psta->recvreorder_ctrl[j];
1145                                         if(preorder_ctrl->enable)
1146                                         {
1147                                                 DBG_871X_SEL_NL(m, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
1148                                         }
1149                                 }
1150
1151 #ifdef CONFIG_TDLS
1152                                 DBG_871X_SEL_NL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
1153                                 DBG_871X_SEL_NL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
1154                                 DBG_871X_SEL_NL(m, "rx_data_pkts=%llu\n", psta->sta_stats.rx_data_pkts);
1155                                 DBG_871X_SEL_NL(m, "rx_bytes=%llu\n", psta->sta_stats.rx_bytes);
1156                                 DBG_871X_SEL_NL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
1157                                 DBG_871X_SEL_NL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
1158 #endif //CONFIG_TDLS
1159                                 DBG_871X_SEL_NL(m, "==============================\n");
1160                         }
1161
1162                 }
1163
1164         }
1165
1166         _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
1167
1168         return 0;
1169 }
1170
1171 #endif
1172
1173 #ifdef DBG_MEMORY_LEAK
1174 #include <asm/atomic.h>
1175 extern atomic_t _malloc_cnt;;
1176 extern atomic_t _malloc_size;;
1177
1178 int proc_get_malloc_cnt(struct seq_file *m, void *v)
1179 {
1180         DBG_871X_SEL_NL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
1181         DBG_871X_SEL_NL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
1182
1183         return 0;
1184 }
1185 #endif /* DBG_MEMORY_LEAK */
1186
1187 #ifdef CONFIG_FIND_BEST_CHANNEL
1188 int proc_get_best_channel(struct seq_file *m, void *v)
1189 {
1190         struct net_device *dev = m->private;
1191         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1192         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1193         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
1194
1195         for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
1196                 if ( pmlmeext->channel_set[i].ChannelNum == 1)
1197                         index_24G = i;
1198                 if ( pmlmeext->channel_set[i].ChannelNum == 36)
1199                         index_5G = i;
1200         }
1201
1202         for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
1203                 // 2.4G
1204                 if ( pmlmeext->channel_set[i].ChannelNum == 6 ) {
1205                         if ( pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count ) {
1206                                 index_24G = i;
1207                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
1208                         }
1209                 }
1210
1211                 // 5G
1212                 if ( pmlmeext->channel_set[i].ChannelNum >= 36
1213                         && pmlmeext->channel_set[i].ChannelNum < 140 ) {
1214                          // Find primary channel
1215                         if ( (( pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0)
1216                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
1217                                 index_5G = i;
1218                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
1219                         }
1220                 }
1221
1222                 if ( pmlmeext->channel_set[i].ChannelNum >= 149
1223                         && pmlmeext->channel_set[i].ChannelNum < 165) {
1224                          // find primary channel
1225                         if ( (( pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0)
1226                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
1227                                 index_5G = i;
1228                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
1229                         }
1230                 }
1231 #if 1 // debug
1232                 DBG_871X_SEL_NL(m, "The rx cnt of channel %3d = %d\n",
1233                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
1234 #endif
1235         }
1236
1237         DBG_871X_SEL_NL(m, "best_channel_5G = %d\n", best_channel_5G);
1238         DBG_871X_SEL_NL(m, "best_channel_24G = %d\n", best_channel_24G);
1239
1240         return 0;
1241 }
1242
1243 ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1244 {
1245         struct net_device *dev = data;
1246         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1247         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1248         char tmp[32];
1249
1250         if(count < 1)
1251                 return -EFAULT;
1252
1253         if(buffer && !copy_from_user(tmp, buffer, sizeof(tmp)))
1254         {
1255                 int i;
1256                 for(i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++)
1257                 {
1258                         pmlmeext->channel_set[i].rx_count = 0;
1259                 }
1260
1261                 DBG_871X("set %s\n", "Clean Best Channel Count");
1262         }
1263
1264         return count;
1265 }
1266 #endif /* CONFIG_FIND_BEST_CHANNEL */
1267
1268 #ifdef CONFIG_BT_COEXIST
1269 int proc_get_btcoex_dbg(struct seq_file *m, void *v)
1270 {
1271         struct net_device *dev = m->private;
1272         PADAPTER padapter;
1273         char buf[512] = {0};
1274         padapter = (PADAPTER)rtw_netdev_priv(dev);
1275
1276         rtw_btcoex_GetDBG(padapter, buf, 512);
1277
1278         DBG_871X_SEL(m, "%s", buf);
1279
1280         return 0;
1281 }
1282
1283 ssize_t proc_set_btcoex_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1284 {
1285         struct net_device *dev = data;
1286         PADAPTER padapter;
1287         u8 tmp[80] = {0};
1288         u32 module[2] = {0};
1289         u32 num;
1290
1291         padapter = (PADAPTER)rtw_netdev_priv(dev);
1292
1293 //      DBG_871X("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter));
1294
1295         if (NULL == buffer)
1296         {
1297                 DBG_871X(FUNC_ADPT_FMT ": input buffer is NULL!\n",
1298                         FUNC_ADPT_ARG(padapter));
1299
1300                 return -EFAULT;
1301         }
1302
1303         if (count < 1)
1304         {
1305                 DBG_871X(FUNC_ADPT_FMT ": input length is 0!\n",
1306                         FUNC_ADPT_ARG(padapter));
1307
1308                 return -EFAULT;
1309         }
1310
1311         num = count;
1312         if (num > (sizeof(tmp) - 1))
1313                 num = (sizeof(tmp) - 1);
1314
1315         if (copy_from_user(tmp, buffer, num))
1316         {
1317                 DBG_871X(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
1318                         FUNC_ADPT_ARG(padapter));
1319
1320                 return -EFAULT;
1321         }
1322
1323         num = sscanf(tmp, "%x %x", module, module+1);
1324         if (1 == num)
1325         {
1326                 if (0 == module[0])
1327                         _rtw_memset(module, 0, sizeof(module));
1328                 else
1329                         _rtw_memset(module, 0xFF, sizeof(module));
1330         }
1331         else if (2 != num)
1332         {
1333                 DBG_871X(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
1334                         FUNC_ADPT_ARG(padapter), tmp);
1335
1336                 if (0 == num)
1337                         return -EFAULT;
1338         }
1339
1340         DBG_871X(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
1341                 FUNC_ADPT_ARG(padapter), module[0], module[1]);
1342         rtw_btcoex_SetDBG(padapter, module);
1343
1344         return count;
1345 }
1346
1347 int proc_get_btcoex_info(struct seq_file *m, void *v)
1348 {
1349         struct net_device *dev = m->private;
1350         PADAPTER padapter;
1351         const u32 bufsize = 30*100;
1352         u8 *pbuf = NULL;
1353
1354         padapter = (PADAPTER)rtw_netdev_priv(dev);
1355
1356         pbuf = rtw_zmalloc(bufsize);
1357         if (NULL == pbuf) {
1358                 return -ENOMEM;
1359         }
1360
1361         rtw_btcoex_DisplayBtCoexInfo(padapter, pbuf, bufsize);
1362
1363         DBG_871X_SEL(m, "%s\n", pbuf);
1364
1365         rtw_mfree(pbuf, bufsize);
1366
1367         return 0;
1368 }
1369 #endif /* CONFIG_BT_COEXIST */
1370
1371 #if defined(DBG_CONFIG_ERROR_DETECT)
1372 int proc_get_sreset(struct seq_file *m, void *v)
1373 {
1374         struct net_device *dev = m->private;
1375         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1376         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1377
1378         return 0;
1379 }
1380
1381 ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1382 {
1383         struct net_device *dev = data;
1384         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1385         char tmp[32];
1386         s32 trigger_point;
1387
1388         if (count < 1)
1389                 return -EFAULT;
1390
1391         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1392
1393                 int num = sscanf(tmp, "%d", &trigger_point);
1394
1395                 if (trigger_point == SRESET_TGP_NULL)
1396                         rtw_hal_sreset_reset(padapter);
1397                 else
1398                         sreset_set_trigger_point(padapter, trigger_point);
1399         }
1400
1401         return count;
1402
1403 }
1404 #endif /* DBG_CONFIG_ERROR_DETECT */
1405
1406 #endif
1407