drivers/net/wireless/rockchip_wlan/rtl8188eu/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 void dump_adapters_status(void *sel, struct dvobj_priv *dvobj)
 155 {
 156         int i;
 157         _adapter *iface;
 158         u8 u_ch, u_bw, u_offset;
 159
 160         DBG_871X_SEL_NL(sel, "%-2s %-8s %-4s %-7s %s\n"
 161                 , "id", "ifname", "port", "ch", "status");
 162
 163         DBG_871X_SEL_NL(sel, "------------------------\n");
 164
 165         for (i = 0; i < dvobj->iface_nums; i++) {
 166                 iface = dvobj->padapters[i];
 167                 if (iface) {
 168                         DBG_871X_SEL_NL(sel, "%2d %-8s %4hhu %3u,%u,%u "MLME_STATE_FMT" %s%s\n"
 169                                 , i, ADPT_ARG(iface)
 170                                 , get_iface_type(iface)
 171                                 , iface->mlmeextpriv.cur_channel
 172                                 , iface->mlmeextpriv.cur_bwmode
 173                                 , iface->mlmeextpriv.cur_ch_offset
 174                                 , ADPT_MLME_S_ARG(iface)
 175                                 , iface->bSurpriseRemoved?" SR":""
 176                                 , iface->bDriverStopped?" DS":""
 177                         );
 178                 }
 179         }
 180
 181         DBG_871X_SEL_NL(sel, "------------------------\n");
 182
 183         rtw_get_ch_setting_union(dvobj->padapters[IFACE_ID0], &u_ch, &u_bw, &u_offset);
 184         DBG_871X_SEL_NL(sel, "%16s %3u,%u,%u\n"
 185                 , "union:"
 186                 , u_ch, u_bw, u_offset
 187         );
 188
 189         DBG_871X_SEL_NL(sel, "%16s %3u,%u,%u\n"
 190                 , "oper:"
 191                 , dvobj->oper_channel
 192                 , dvobj->oper_bwmode
 193                 , dvobj->oper_ch_offset
 194         );
 195 }
 196
 197 #ifdef CONFIG_PROC_DEBUG
 198 ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 199 {
 200         struct net_device *dev = data;
 201         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 202         char tmp[32];
 203         u32 addr, val, len;
 204
 205         if (count < 3)
 206         {
 207                 DBG_871X("argument size is less than 3\n");
 208                 return -EFAULT;
 209         }
 210
 211         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 212
 213                 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
 214
 215                 if (num !=  3) {
 216                         DBG_871X("invalid write_reg parameter!\n");
 217                         return count;
 218                 }
 219
 220                 switch(len)
 221                 {
 222                         case 1:
 223                                 rtw_write8(padapter, addr, (u8)val);
 224                                 break;
 225                         case 2:
 226                                 rtw_write16(padapter, addr, (u16)val);
 227                                 break;
 228                         case 4:
 229                                 rtw_write32(padapter, addr, val);
 230                                 break;
 231                         default:
 232                                 DBG_871X("error write length=%d", len);
 233                                 break;
 234                 }
 235
 236         }
 237
 238         return count;
 239
 240 }
 241
 242 static u32 proc_get_read_addr=0xeeeeeeee;
 243 static u32 proc_get_read_len=0x4;
 244
 245 int proc_get_read_reg(struct seq_file *m, void *v)
 246 {
 247         struct net_device *dev = m->private;
 248         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 249
 250         if (proc_get_read_addr==0xeeeeeeee) {
 251                 DBG_871X_SEL_NL(m, "address not initialized\n");
 252                 return 0;
 253         }
 254
 255         switch(proc_get_read_len)
 256         {
 257                 case 1:
 258                         DBG_871X_SEL_NL(m, "rtw_read8(0x%x)=0x%x\n", proc_get_read_addr, rtw_read8(padapter, proc_get_read_addr));
 259                         break;
 260                 case 2:
 261                         DBG_871X_SEL_NL(m, "rtw_read16(0x%x)=0x%x\n", proc_get_read_addr, rtw_read16(padapter, proc_get_read_addr));
 262                         break;
 263                 case 4:
 264                         DBG_871X_SEL_NL(m, "rtw_read32(0x%x)=0x%x\n", proc_get_read_addr, rtw_read32(padapter, proc_get_read_addr));
 265                         break;
 266                 default:
 267                         DBG_871X_SEL_NL(m, "error read length=%d\n", proc_get_read_len);
 268                         break;
 269         }
 270
 271         return 0;
 272 }
 273
 274 ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 275 {
 276         struct net_device *dev = data;
 277         char tmp[16];
 278         u32 addr, len;
 279
 280         if (count < 2)
 281         {
 282                 DBG_871X("argument size is less than 2\n");
 283                 return -EFAULT;
 284         }
 285
 286         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 287
 288                 int num = sscanf(tmp, "%x %x", &addr, &len);
 289
 290                 if (num !=  2) {
 291                         DBG_871X("invalid read_reg parameter!\n");
 292                         return count;
 293                 }
 294
 295                 proc_get_read_addr = addr;
 296
 297                 proc_get_read_len = len;
 298         }
 299
 300         return count;
 301
 302 }
 303
 304 int proc_get_fwstate(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_priv *pmlmepriv = &(padapter->mlmepriv);
 309
 310         DBG_871X_SEL_NL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
 311
 312         return 0;
 313 }
 314
 315 int proc_get_sec_info(struct seq_file *m, void *v)
 316 {
 317         struct net_device *dev = m->private;
 318         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 319         struct security_priv *sec = &padapter->securitypriv;
 320
 321         DBG_871X_SEL_NL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
 322                                                 sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
 323                                                 sec->ndisauthtype, sec->ndisencryptstatus);
 324
 325         DBG_871X_SEL_NL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
 326
 327 #ifdef DBG_SW_SEC_CNT
 328         DBG_871X_SEL_NL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
 329                 , sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
 330         DBG_871X_SEL_NL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
 331                 , sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
 332
 333         DBG_871X_SEL_NL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
 334                 , sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
 335         DBG_871X_SEL_NL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
 336                 , sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
 337
 338         DBG_871X_SEL_NL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
 339                 , sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
 340         DBG_871X_SEL_NL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
 341                 , sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
 342 #endif /* DBG_SW_SEC_CNT */
 343
 344         return 0;
 345 }
 346
 347 int proc_get_mlmext_state(struct seq_file *m, void *v)
 348 {
 349         struct net_device *dev = m->private;
 350         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 351         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 352         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 353
 354         DBG_871X_SEL_NL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
 355
 356         return 0;
 357 }
 358
 359 #ifdef CONFIG_LAYER2_ROAMING
 360 int proc_get_roam_flags(struct seq_file *m, void *v)
 361 {
 362         struct net_device *dev = m->private;
 363         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 364
 365         DBG_871X_SEL_NL(m, "0x%02x\n", rtw_roam_flags(adapter));
 366
 367         return 0;
 368 }
 369
 370 ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 371 {
 372         struct net_device *dev = data;
 373         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 374
 375         char tmp[32];
 376         u8 flags;
 377
 378         if (count < 1)
 379                 return -EFAULT;
 380
 381         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 382
 383                 int num = sscanf(tmp, "%hhx", &flags);
 384
 385                 if (num == 1)
 386                         rtw_assign_roam_flags(adapter, flags);
 387         }
 388
 389         return count;
 390
 391 }
 392
 393 int proc_get_roam_param(struct seq_file *m, void *v)
 394 {
 395         struct net_device *dev = m->private;
 396         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 397         struct mlme_priv *mlme = &adapter->mlmepriv;
 398
 399         DBG_871X_SEL_NL(m, "%12s %12s %11s\n", "rssi_diff_th", "scanr_exp_ms", "scan_int_ms");
 400         DBG_871X_SEL_NL(m, "%-12u %-12u %-11u\n"
 401                 , mlme->roam_rssi_diff_th
 402                 , mlme->roam_scanr_exp_ms
 403                 , mlme->roam_scan_int_ms
 404         );
 405
 406         return 0;
 407 }
 408
 409 ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 410 {
 411         struct net_device *dev = data;
 412         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 413         struct mlme_priv *mlme = &adapter->mlmepriv;
 414
 415         char tmp[32];
 416         u8 rssi_diff_th;
 417         u32 scanr_exp_ms;
 418         u32 scan_int_ms;
 419
 420         if (count < 1)
 421                 return -EFAULT;
 422
 423         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 424
 425                 int num = sscanf(tmp, "%hhu %u %u", &rssi_diff_th, &scanr_exp_ms, &scan_int_ms);
 426
 427                 if (num >= 1)
 428                         mlme->roam_rssi_diff_th = rssi_diff_th;
 429                 if (num >= 2)
 430                         mlme->roam_scanr_exp_ms = scanr_exp_ms;
 431                 if (num >= 3)
 432                         mlme->roam_scan_int_ms = scan_int_ms;
 433         }
 434
 435         return count;
 436
 437 }
 438
 439 ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 440 {
 441         struct net_device *dev = data;
 442         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 443
 444         char tmp[32];
 445         u8 addr[ETH_ALEN];
 446
 447         if (count < 1)
 448                 return -EFAULT;
 449
 450         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 451
 452                 int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr+1, addr+2, addr+3, addr+4, addr+5);
 453                 if (num == 6)
 454                         _rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
 455
 456                 DBG_871X("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
 457         }
 458
 459         return count;
 460 }
 461 #endif /* CONFIG_LAYER2_ROAMING */
 462
 463 int proc_get_qos_option(struct seq_file *m, void *v)
 464 {
 465         struct net_device *dev = m->private;
 466         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 467         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 468
 469         DBG_871X_SEL_NL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
 470
 471         return 0;
 472 }
 473
 474 int proc_get_ht_option(struct seq_file *m, void *v)
 475 {
 476         struct net_device *dev = m->private;
 477         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 478         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 479
 480 #ifdef CONFIG_80211N_HT
 481         DBG_871X_SEL_NL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
 482 #endif //CONFIG_80211N_HT
 483
 484         return 0;
 485 }
 486
 487 int proc_get_rf_info(struct seq_file *m, void *v)
 488 {
 489         struct net_device *dev = m->private;
 490         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 491         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 492
 493         DBG_871X_SEL_NL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
 494                                         pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 495
 496         DBG_871X_SEL_NL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
 497                                         rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter),  rtw_get_oper_choffset(padapter));
 498
 499         return 0;
 500 }
 501
 502 int proc_get_survey_info(struct seq_file *m, void *v)
 503 {
 504         _irqL irqL;
 505         struct net_device *dev = m->private;
 506         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 507         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 508         _queue  *queue  = &(pmlmepriv->scanned_queue);
 509         struct wlan_network     *pnetwork = NULL;
 510         _list   *plist, *phead;
 511         s32 notify_signal;
 512         s16 notify_noise = 0;
 513         u16  index = 0, ie_cap = 0;
 514         unsigned char *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
 515         unsigned char *ie_p2p = NULL, *ssid = NULL;
 516         char flag_str[64];
 517         int ielen = 0;
 518         u32 wpsielen = 0;
 519
 520         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 521         phead = get_list_head(queue);
 522         if(!phead)
 523                 return 0;
 524         plist = get_next(phead);
 525         if (!plist)
 526                 return 0;
 527
 528         DBG_871X_SEL_NL(m, "%5s  %-17s  %3s  %-3s  %-4s  %-4s  %5s  %32s  %32s\n", "index", "bssid", "ch", "RSSI", "SdBm", "Noise", "age", "flag", "ssid");
 529         while(1)
 530         {
 531                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
 532                         break;
 533
 534                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
 535                 if (!pnetwork)
 536                         break;
 537
 538                 if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE &&
 539                         is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
 540                         notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);//dbm
 541                 } else {
 542                         notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);//dbm
 543                 }
 544
 545                 #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
 546                 rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(pnetwork->network.Configuration.DSConfig), &(notify_noise));
 547                 #endif
 548
 549                 ie_wpa = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength-12);
 550                 ie_wpa2 = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength-12);
 551                 ie_cap = rtw_get_capability(&pnetwork->network);
 552                 ie_wps = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength-12, NULL, &wpsielen);
 553                 ie_p2p = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength-12, NULL, &ielen);
 554                 ssid = pnetwork->network.Ssid.Ssid;
 555                 sprintf(flag_str, "%s%s%s%s%s%s%s",
 556                                         (ie_wpa) ? "[WPA]":"",
 557                                         (ie_wpa2) ? "[WPA2]":"",
 558                                         (!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]":"",
 559                                         (ie_wps) ? "[WPS]":"",
 560                                         (pnetwork->network.InfrastructureMode == Ndis802_11IBSS) ? "[IBSS]":"",
 561                                         (ie_cap & BIT(0)) ? "[ESS]":"",
 562                                         (ie_p2p) ? "[P2P]":"");
 563                 DBG_871X_SEL_NL(m, "%5d  "MAC_FMT"  %3d  %3d  %4d  %4d    %5d  %32s  %32s\n",
 564                         ++index,
 565                         MAC_ARG(pnetwork->network.MacAddress),
 566                         pnetwork->network.Configuration.DSConfig,
 567                         (int)pnetwork->network.Rssi,
 568                         notify_signal,
 569                         notify_noise,
 570                         rtw_get_passing_time_ms((u32)pnetwork->last_scanned),
 571                         flag_str,
 572                         pnetwork->network.Ssid.Ssid);
 573                 plist = get_next(plist);
 574         }
 575         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 576
 577         return 0;
 578 }
 579
 580 ssize_t proc_set_survey_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 581 {
 582         _irqL irqL;
 583         struct net_device *dev = data;
 584         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 585         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
 586         bool need_indicate_scan_done = _FALSE;
 587         u8 _status = _FALSE;
 588         NDIS_802_11_SSID ssid[RTW_SSID_SCAN_AMOUNT];
 589
 590         if (count < 1)
 591                 return -EFAULT;
 592
 593 #ifdef CONFIG_MP_INCLUDED
 594                 if ((padapter->registrypriv.mp_mode == 1)
 595 #ifdef CONFIG_CONCURRENT_MODE
 596                 || ((padapter->pbuddy_adapter) && (padapter->pbuddy_adapter->registrypriv.mp_mode == 1))
 597 #endif
 598                 ){
 599                         DBG_871X(FUNC_ADPT_FMT ": MP mode block Scan request\n", FUNC_ADPT_ARG(padapter));
 600                         goto exit;
 601                 }
 602 #endif
 603         rtw_ps_deny(padapter, PS_DENY_SCAN);
 604         if (_FAIL == rtw_pwr_wakeup(padapter))
 605                 goto exit;
 606
 607         if (padapter->bDriverStopped) {
 608                 DBG_871X("scan abort!! bDriverStopped=%d\n", padapter->bDriverStopped);
 609                 goto exit;
 610         }
 611
 612         if (!padapter->bup) {
 613                 DBG_871X("scan abort!! bup=%d\n", padapter->bup);
 614                 goto exit;
 615         }
 616
 617         if (padapter->hw_init_completed == _FALSE) {
 618                 DBG_871X("scan abort!! hw_init_completed=FALSE\n");
 619                 goto exit;
 620         }
 621
 622         if (rtw_is_scan_deny(padapter)) {
 623                 DBG_871X(FUNC_ADPT_FMT  ": scan deny\n", FUNC_ADPT_ARG(padapter));
 624                 goto exit;
 625         }
 626
 627         if ((pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE)
 628 #ifdef CONFIG_CONCURRENT_MODE
 629         || (rtw_get_buddy_bBusyTraffic(padapter) == _TRUE)
 630 #endif
 631         ) {
 632                 DBG_871X("scan abort!! BusyTraffic == _TRUE\n");
 633                 goto exit;
 634         }
 635
 636         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE) {
 637                 DBG_8192C("scan abort!! fwstate=0x%x\n", pmlmepriv->fw_state);
 638                 goto exit;
 639         }
 640
 641 #ifdef CONFIG_CONCURRENT_MODE
 642         if (check_buddy_fwstate(padapter,
 643                 _FW_UNDER_SURVEY|_FW_UNDER_LINKING|WIFI_UNDER_WPS) == _TRUE) {
 644                 DBG_871X("scan abort!! buddy_fwstate=0x%x\n",
 645                                 get_fwstate(&(padapter->pbuddy_adapter->mlmepriv)));
 646                 goto exit;
 647         }
 648 #endif
 649         _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
 650
 651 exit:
 652         rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
 653         return count;
 654 }
 655
 656 int proc_get_ap_info(struct seq_file *m, void *v)
 657 {
 658         struct net_device *dev = m->private;
 659         struct sta_info *psta;
 660         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 661         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 662         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 663         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
 664         struct sta_priv *pstapriv = &padapter->stapriv;
 665
 666         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
 667         if(psta)
 668         {
 669                 int i;
 670                 struct recv_reorder_ctrl *preorder_ctrl;
 671
 672                 DBG_871X_SEL_NL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
 673                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
 674                 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);
 675                 DBG_871X_SEL_NL(m, "wireless_mode=0x%x, rtsen=%d, cts2slef=%d\n", psta->wireless_mode, psta->rtsen, psta->cts2self);
 676                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
 677 #ifdef CONFIG_80211N_HT
 678                 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);
 679                 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);
 680                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 681                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
 682                 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);
 683 #endif //CONFIG_80211N_HT
 684 #ifdef CONFIG_80211AC_VHT
 685                 DBG_871X_SEL_NL(m, "vht_en=%d, vht_sgi_80m=%d\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
 686                 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);
 687                 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);
 688 #endif
 689
 690                 for(i=0;i<16;i++)
 691                 {
 692                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 693                         if(preorder_ctrl->enable)
 694                         {
 695                                 DBG_871X_SEL_NL(m, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
 696                         }
 697                 }
 698
 699         }
 700         else
 701         {
 702                 DBG_871X_SEL_NL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
 703         }
 704
 705         return 0;
 706 }
 707
 708 int proc_get_trx_info(struct seq_file *m, void *v)
 709 {
 710         struct net_device *dev = m->private;
 711         int i;
 712         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 713         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 714         struct recv_priv  *precvpriv = &padapter->recvpriv;
 715         struct hw_xmit *phwxmit;
 716
 717         dump_os_queue(m, padapter);
 718
 719         DBG_871X_SEL_NL(m, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d\n"
 720                 , pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt);
 721         DBG_871X_SEL_NL(m, "free_ext_xmitbuf_cnt=%d, free_xframe_ext_cnt=%d\n"
 722                 , pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt);
 723         DBG_871X_SEL_NL(m, "free_recvframe_cnt=%d\n"
 724                 , precvpriv->free_recvframe_cnt);
 725
 726         for(i = 0; i < 4; i++)
 727         {
 728                 phwxmit = pxmitpriv->hwxmits + i;
 729                 DBG_871X_SEL_NL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
 730         }
 731
 732 #ifdef CONFIG_USB_HCI
 733         DBG_871X_SEL_NL(m, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
 734 #endif
 735
 736         return 0;
 737 }
 738
 739 int proc_get_rate_ctl(struct seq_file *m, void *v)
 740 {
 741         struct net_device *dev = m->private;
 742         int i;
 743         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 744
 745         if (adapter->fix_rate != 0xff) {
 746                 DBG_871X_SEL_NL(m, "FIX\n");
 747                 DBG_871X_SEL_NL(m, "0x%02x\n", adapter->fix_rate);
 748         } else {
 749                 DBG_871X_SEL_NL(m, "RA\n");
 750         }
 751
 752         return 0;
 753 }
 754
 755 ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 756 {
 757         struct net_device *dev = data;
 758         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 759         char tmp[32];
 760         u8 fix_rate;
 761
 762         if (count < 1)
 763                 return -EFAULT;
 764
 765         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 766
 767                 int num = sscanf(tmp, "%hhx", &fix_rate);
 768
 769                 if (num >= 1)
 770                         adapter->fix_rate = fix_rate;
 771         }
 772
 773         return count;
 774 }
 775
 776 u8 g_fwdl_chksum_fail = 0;
 777 u8 g_fwdl_wintint_rdy_fail = 0;
 778
 779 ssize_t proc_set_fwdl_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 780 {
 781         struct net_device *dev = data;
 782         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 783         char tmp[32];
 784
 785         if (count < 1)
 786                 return -EFAULT;
 787
 788         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 789                 int num = sscanf(tmp, "%hhu %hhu", &g_fwdl_chksum_fail, &g_fwdl_wintint_rdy_fail);
 790         }
 791
 792         return count;
 793 }
 794
 795 u32 g_wait_hiq_empty = 0;
 796
 797 ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 798 {
 799         struct net_device *dev = data;
 800         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 801         char tmp[32];
 802
 803         if (count < 1)
 804                 return -EFAULT;
 805
 806         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 807                 int num = sscanf(tmp, "%u", &g_wait_hiq_empty);
 808         }
 809
 810         return count;
 811 }
 812
 813 int proc_get_suspend_resume_info(struct seq_file *m, void *v)
 814 {
 815         struct net_device *dev = m->private;
 816         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 817         struct dvobj_priv *dvobj = padapter->dvobj;
 818         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
 819
 820         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
 821         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
 822         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n",pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
 823         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
 824         DBG_871X_SEL_NL(m, "dbg_sdio_init_error_cnt=%d\n",pdbgpriv->dbg_sdio_init_error_cnt);
 825         DBG_871X_SEL_NL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
 826         DBG_871X_SEL_NL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
 827         DBG_871X_SEL_NL(m, "dbg_suspend_cnt=%d\n",pdbgpriv->dbg_suspend_cnt);
 828         DBG_871X_SEL_NL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
 829         DBG_871X_SEL_NL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
 830         DBG_871X_SEL_NL(m, "dbg_deinit_fail_cnt=%d\n",pdbgpriv->dbg_deinit_fail_cnt);
 831         DBG_871X_SEL_NL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
 832         DBG_871X_SEL_NL(m, "dbg_ps_insuspend_cnt=%d\n",pdbgpriv->dbg_ps_insuspend_cnt);
 833         DBG_871X_SEL_NL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
 834         DBG_871X_SEL_NL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
 835         DBG_871X_SEL_NL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
 836         DBG_871X_SEL_NL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
 837         DBG_871X_SEL_NL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
 838         DBG_871X_SEL_NL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
 839         DBG_871X_SEL_NL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
 840         DBG_871X_SEL_NL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
 841         DBG_871X_SEL_NL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
 842         DBG_871X_SEL_NL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
 843         DBG_871X_SEL_NL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
 844         DBG_871X_SEL_NL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
 845         DBG_871X_SEL_NL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
 846         DBG_871X_SEL_NL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
 847         DBG_871X_SEL_NL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
 848
 849         return 0;
 850 }
 851
 852 int proc_get_rx_signal(struct seq_file *m, void *v)
 853 {
 854         struct net_device *dev = m->private;
 855         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 856         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 857
 858         DBG_871X_SEL_NL(m, "rssi:%d\n", padapter->recvpriv.rssi);
 859         //DBG_871X_SEL_NL(m, "rxpwdb:%d\n", padapter->recvpriv.rxpwdb);
 860         DBG_871X_SEL_NL(m, "signal_strength:%u\n", padapter->recvpriv.signal_strength);
 861         DBG_871X_SEL_NL(m, "signal_qual:%u\n", padapter->recvpriv.signal_qual);
 862         DBG_871X_SEL_NL(m, "noise:%u\n", padapter->recvpriv.noise);
 863         rtw_odm_get_perpkt_rssi(m,padapter);
 864         #ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
 865         rtw_get_raw_rssi_info(m,padapter);
 866         #endif
 867         return 0;
 868 }
 869
 870
 871 int proc_get_hw_status(struct seq_file *m, void *v)
 872 {
 873         struct net_device *dev = m->private;
 874         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 875         struct dvobj_priv *dvobj = padapter->dvobj;
 876         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
 877
 878         DBG_871X_SEL_NL(m, "RX FIFO full count: last_time=%lld, current_time=%lld, differential=%lld\n"
 879         , pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
 880
 881         return 0;
 882 }
 883
 884 ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 885 {
 886         struct net_device *dev = data;
 887         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 888         char tmp[32];
 889         u32 is_signal_dbg, signal_strength;
 890
 891         if (count < 1)
 892                 return -EFAULT;
 893
 894         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 895
 896                 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
 897
 898                 is_signal_dbg = is_signal_dbg==0?0:1;
 899
 900                 if(is_signal_dbg && num!=2)
 901                         return count;
 902
 903                 signal_strength = signal_strength>100?100:signal_strength;
 904
 905                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
 906                 padapter->recvpriv.signal_strength_dbg=signal_strength;
 907
 908                 if(is_signal_dbg)
 909                         DBG_871X("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
 910                 else
 911                         DBG_871X("set %s\n", "HW_SIGNAL_STRENGTH");
 912
 913         }
 914
 915         return count;
 916
 917 }
 918 #ifdef CONFIG_80211N_HT
 919
 920 int proc_get_ht_enable(struct seq_file *m, void *v)
 921 {
 922         struct net_device *dev = m->private;
 923         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 924         struct registry_priv    *pregpriv = &padapter->registrypriv;
 925
 926         if(pregpriv)
 927                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ht_enable);
 928
 929         return 0;
 930 }
 931
 932 ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 933 {
 934         struct net_device *dev = data;
 935         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 936         struct registry_priv    *pregpriv = &padapter->registrypriv;
 937         char tmp[32];
 938         u32 mode;
 939
 940         if (count < 1)
 941                 return -EFAULT;
 942
 943         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 944
 945                 int num = sscanf(tmp, "%d ", &mode);
 946
 947                 if( pregpriv && mode >= 0 && mode < 2 )
 948                 {
 949                         pregpriv->ht_enable= mode;
 950                         printk("ht_enable=%d\n", pregpriv->ht_enable);
 951                 }
 952         }
 953
 954         return count;
 955
 956 }
 957
 958 int proc_get_bw_mode(struct seq_file *m, void *v)
 959 {
 960         struct net_device *dev = m->private;
 961         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 962         struct registry_priv    *pregpriv = &padapter->registrypriv;
 963
 964         if(pregpriv)
 965                 DBG_871X_SEL_NL(m, "0x%02x\n", pregpriv->bw_mode);
 966
 967         return 0;
 968 }
 969
 970 ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 971 {
 972         struct net_device *dev = data;
 973         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 974         struct registry_priv    *pregpriv = &padapter->registrypriv;
 975         char tmp[32];
 976         u32 mode;
 977
 978         if (count < 1)
 979                 return -EFAULT;
 980
 981         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 982
 983                 int num = sscanf(tmp, "%d ", &mode);
 984
 985                 if( pregpriv &&  mode < 2 )
 986                 {
 987
 988                         pregpriv->bw_mode = mode;
 989                         printk("bw_mode=%d\n", mode);
 990
 991                 }
 992         }
 993
 994         return count;
 995
 996 }
 997
 998 int proc_get_ampdu_enable(struct seq_file *m, void *v)
 999 {
1000         struct net_device *dev = m->private;
1001         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1002         struct registry_priv    *pregpriv = &padapter->registrypriv;
1003
1004         if(pregpriv)
1005                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ampdu_enable);
1006
1007         return 0;
1008 }
1009
1010 ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1011 {
1012         struct net_device *dev = data;
1013         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1014         struct registry_priv    *pregpriv = &padapter->registrypriv;
1015         char tmp[32];
1016         u32 mode;
1017
1018         if (count < 1)
1019                 return -EFAULT;
1020
1021         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1022
1023                 int num = sscanf(tmp, "%d ", &mode);
1024
1025                 if( pregpriv && mode < 3 )
1026                 {
1027                         pregpriv->ampdu_enable= mode;
1028                         printk("ampdu_enable=%d\n", mode);
1029                 }
1030
1031         }
1032
1033         return count;
1034
1035 }
1036
1037 int proc_get_rx_ampdu(struct seq_file *m, void *v)
1038 {
1039         struct net_device *dev = m->private;
1040         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1041         struct registry_priv    *pregpriv = &padapter->registrypriv;
1042         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1043         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1044
1045         if(pregpriv)
1046                 DBG_871X_SEL_NL(m,
1047                         "bAcceptAddbaReq = %d , 0:Reject AP's Add BA req, 1:Accept AP's Add BA req.\n", pmlmeinfo->bAcceptAddbaReq
1048                         );
1049
1050         return 0;
1051 }
1052
1053 ssize_t proc_set_rx_ampdu(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         struct registry_priv    *pregpriv = &padapter->registrypriv;
1058         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1059         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1060         char tmp[32];
1061         u32 mode;
1062
1063         if (count < 1)
1064                 return -EFAULT;
1065
1066         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1067
1068                 int num = sscanf(tmp, "%d ", &mode);
1069
1070                 if( pregpriv && mode >= 0 && mode < 2 )
1071                 {
1072                         pmlmeinfo->bAcceptAddbaReq = mode;
1073                         DBG_871X("pmlmeinfo->bAcceptAddbaReq=%d \n",pmlmeinfo->bAcceptAddbaReq);
1074                         if(mode == 0)
1075                         {
1076                                 //tear down Rx AMPDU
1077                                 send_delba(padapter, 0, get_my_bssid(&(pmlmeinfo->network)));// recipient
1078                         }
1079                 }
1080
1081         }
1082
1083         return count;
1084 }
1085
1086 #endif //CONFIG_80211N_HT
1087
1088 int proc_get_en_fwps(struct seq_file *m, void *v)
1089 {
1090         struct net_device *dev = m->private;
1091         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1092         struct registry_priv    *pregpriv = &padapter->registrypriv;
1093         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1094         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1095
1096         if(pregpriv)
1097                 DBG_871X_SEL_NL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
1098                         , pregpriv->check_fw_ps);
1099
1100         return 0;
1101 }
1102
1103 ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1104 {
1105         struct net_device *dev = data;
1106         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1107         struct registry_priv    *pregpriv = &padapter->registrypriv;
1108         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1109         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1110         char tmp[32];
1111         u32 mode;
1112
1113         if (count < 1)
1114                 return -EFAULT;
1115
1116         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1117
1118                 int num = sscanf(tmp, "%d ", &mode);
1119
1120                 if( pregpriv && mode >= 0 && mode < 2 )
1121                 {
1122                         pregpriv->check_fw_ps = mode;
1123                         DBG_871X("pregpriv->check_fw_ps=%d \n",pregpriv->check_fw_ps);
1124                 }
1125
1126         }
1127
1128         return count;
1129 }
1130
1131 /*
1132 int proc_get_two_path_rssi(struct seq_file *m, void *v)
1133 {
1134         struct net_device *dev = m->private;
1135         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1136
1137         if(padapter)
1138                 DBG_871X_SEL_NL(m, "%d %d\n",
1139                         padapter->recvpriv.RxRssi[0], padapter->recvpriv.RxRssi[1]);
1140
1141         return 0;
1142 }
1143 */
1144 #ifdef CONFIG_80211N_HT
1145 int proc_get_rx_stbc(struct seq_file *m, void *v)
1146 {
1147         struct net_device *dev = m->private;
1148         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1149         struct registry_priv    *pregpriv = &padapter->registrypriv;
1150
1151         if(pregpriv)
1152                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->rx_stbc);
1153
1154         return 0;
1155 }
1156
1157 ssize_t proc_set_rx_stbc(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1158 {
1159         struct net_device *dev = data;
1160         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1161         struct registry_priv    *pregpriv = &padapter->registrypriv;
1162         char tmp[32];
1163         u32 mode;
1164
1165         if (count < 1)
1166                 return -EFAULT;
1167
1168         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1169
1170                 int num = sscanf(tmp, "%d ", &mode);
1171
1172                 if( pregpriv && (mode == 0 || mode == 1|| mode == 2|| mode == 3))
1173                 {
1174                         pregpriv->rx_stbc= mode;
1175                         printk("rx_stbc=%d\n", mode);
1176                 }
1177         }
1178
1179         return count;
1180
1181 }
1182 #endif //CONFIG_80211N_HT
1183
1184 int proc_get_rssi_disp(struct seq_file *m, void *v)
1185 {
1186         struct net_device *dev = m->private;
1187         return 0;
1188 }
1189
1190 ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1191 {
1192         struct net_device *dev = data;
1193         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1194         char tmp[32];
1195         u32 enable=0;
1196
1197         if (count < 1)
1198         {
1199                 DBG_8192C("argument size is less than 1\n");
1200                 return -EFAULT;
1201         }
1202
1203         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1204
1205                 int num = sscanf(tmp, "%x", &enable);
1206
1207                 if (num !=  1) {
1208                         DBG_8192C("invalid set_rssi_disp parameter!\n");
1209                         return count;
1210                 }
1211
1212                 if(enable)
1213                 {
1214                         DBG_8192C("Linked info Function Enable\n");
1215                         padapter->bLinkInfoDump = enable ;
1216                 }
1217                 else
1218                 {
1219                         DBG_8192C("Linked info Function Disable\n");
1220                         padapter->bLinkInfoDump = 0 ;
1221                 }
1222
1223         }
1224
1225         return count;
1226
1227 }
1228
1229
1230 #ifdef CONFIG_AP_MODE
1231
1232 int proc_get_all_sta_info(struct seq_file *m, void *v)
1233 {
1234         struct net_device *dev = m->private;
1235         _irqL irqL;
1236         struct sta_info *psta;
1237         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1238         struct sta_priv *pstapriv = &padapter->stapriv;
1239         int i, j;
1240         _list   *plist, *phead;
1241         struct recv_reorder_ctrl *preorder_ctrl;
1242
1243         DBG_871X_SEL_NL(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
1244
1245         _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
1246
1247         for(i=0; i< NUM_STA; i++)
1248         {
1249                 phead = &(pstapriv->sta_hash[i]);
1250                 plist = get_next(phead);
1251
1252                 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
1253                 {
1254                         psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
1255
1256                         plist = get_next(plist);
1257
1258                         //if(extra_arg == psta->aid)
1259                         {
1260                                 DBG_871X_SEL_NL(m, "==============================\n");
1261                                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
1262                                 DBG_871X_SEL_NL(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
1263                                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
1264 #ifdef CONFIG_80211N_HT
1265                                 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);
1266                                 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);
1267                                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
1268                                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
1269 #endif //CONFIG_80211N_HT
1270                                 DBG_871X_SEL_NL(m, "sleepq_len=%d\n", psta->sleepq_len);
1271                                 DBG_871X_SEL_NL(m, "capability=0x%x\n", psta->capability);
1272                                 DBG_871X_SEL_NL(m, "flags=0x%x\n", psta->flags);
1273                                 DBG_871X_SEL_NL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
1274                                 DBG_871X_SEL_NL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
1275                                 DBG_871X_SEL_NL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
1276                                 DBG_871X_SEL_NL(m, "qos_info=0x%x\n", psta->qos_info);
1277                                 DBG_871X_SEL_NL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
1278
1279                                 for(j=0;j<16;j++)
1280                                 {
1281                                         preorder_ctrl = &psta->recvreorder_ctrl[j];
1282                                         if(preorder_ctrl->enable)
1283                                         {
1284                                                 DBG_871X_SEL_NL(m, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
1285                                         }
1286                                 }
1287
1288 #ifdef CONFIG_TDLS
1289                                 DBG_871X_SEL_NL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
1290                                 DBG_871X_SEL_NL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
1291                                 DBG_871X_SEL_NL(m, "rx_data_pkts=%llu\n", psta->sta_stats.rx_data_pkts);
1292                                 DBG_871X_SEL_NL(m, "rx_bytes=%llu\n", psta->sta_stats.rx_bytes);
1293                                 DBG_871X_SEL_NL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
1294                                 DBG_871X_SEL_NL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
1295 #endif //CONFIG_TDLS
1296                                 DBG_871X_SEL_NL(m, "==============================\n");
1297                         }
1298
1299                 }
1300
1301         }
1302
1303         _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
1304
1305         return 0;
1306 }
1307
1308 #endif
1309
1310 #ifdef DBG_MEMORY_LEAK
1311 #include <asm/atomic.h>
1312 extern atomic_t _malloc_cnt;;
1313 extern atomic_t _malloc_size;;
1314
1315 int proc_get_malloc_cnt(struct seq_file *m, void *v)
1316 {
1317         DBG_871X_SEL_NL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
1318         DBG_871X_SEL_NL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
1319
1320         return 0;
1321 }
1322 #endif /* DBG_MEMORY_LEAK */
1323
1324 #ifdef CONFIG_FIND_BEST_CHANNEL
1325 int proc_get_best_channel(struct seq_file *m, void *v)
1326 {
1327         struct net_device *dev = m->private;
1328         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1329         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1330         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
1331
1332         for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
1333                 if ( pmlmeext->channel_set[i].ChannelNum == 1)
1334                         index_24G = i;
1335                 if ( pmlmeext->channel_set[i].ChannelNum == 36)
1336                         index_5G = i;
1337         }
1338
1339         for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
1340                 // 2.4G
1341                 if ( pmlmeext->channel_set[i].ChannelNum == 6 ) {
1342                         if ( pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count ) {
1343                                 index_24G = i;
1344                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
1345                         }
1346                 }
1347
1348                 // 5G
1349                 if ( pmlmeext->channel_set[i].ChannelNum >= 36
1350                         && pmlmeext->channel_set[i].ChannelNum < 140 ) {
1351                          // Find primary channel
1352                         if ( (( pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0)
1353                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
1354                                 index_5G = i;
1355                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
1356                         }
1357                 }
1358
1359                 if ( pmlmeext->channel_set[i].ChannelNum >= 149
1360                         && pmlmeext->channel_set[i].ChannelNum < 165) {
1361                          // find primary channel
1362                         if ( (( pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0)
1363                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
1364                                 index_5G = i;
1365                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
1366                         }
1367                 }
1368 #if 1 // debug
1369                 DBG_871X_SEL_NL(m, "The rx cnt of channel %3d = %d\n",
1370                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
1371 #endif
1372         }
1373
1374         DBG_871X_SEL_NL(m, "best_channel_5G = %d\n", best_channel_5G);
1375         DBG_871X_SEL_NL(m, "best_channel_24G = %d\n", best_channel_24G);
1376
1377         return 0;
1378 }
1379
1380 ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1381 {
1382         struct net_device *dev = data;
1383         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1384         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1385         char tmp[32];
1386
1387         if(count < 1)
1388                 return -EFAULT;
1389
1390         if(buffer && !copy_from_user(tmp, buffer, sizeof(tmp)))
1391         {
1392                 int i;
1393                 for(i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++)
1394                 {
1395                         pmlmeext->channel_set[i].rx_count = 0;
1396                 }
1397
1398                 DBG_871X("set %s\n", "Clean Best Channel Count");
1399         }
1400
1401         return count;
1402 }
1403 #endif /* CONFIG_FIND_BEST_CHANNEL */
1404
1405 #ifdef CONFIG_BT_COEXIST
1406 int proc_get_btcoex_dbg(struct seq_file *m, void *v)
1407 {
1408         struct net_device *dev = m->private;
1409         PADAPTER padapter;
1410         char buf[512] = {0};
1411         padapter = (PADAPTER)rtw_netdev_priv(dev);
1412
1413         rtw_btcoex_GetDBG(padapter, buf, 512);
1414
1415         DBG_871X_SEL(m, "%s", buf);
1416
1417         return 0;
1418 }
1419
1420 ssize_t proc_set_btcoex_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1421 {
1422         struct net_device *dev = data;
1423         PADAPTER padapter;
1424         u8 tmp[80] = {0};
1425         u32 module[2] = {0};
1426         u32 num;
1427
1428         padapter = (PADAPTER)rtw_netdev_priv(dev);
1429
1430 //      DBG_871X("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter));
1431
1432         if (NULL == buffer)
1433         {
1434                 DBG_871X(FUNC_ADPT_FMT ": input buffer is NULL!\n",
1435                         FUNC_ADPT_ARG(padapter));
1436
1437                 return -EFAULT;
1438         }
1439
1440         if (count < 1)
1441         {
1442                 DBG_871X(FUNC_ADPT_FMT ": input length is 0!\n",
1443                         FUNC_ADPT_ARG(padapter));
1444
1445                 return -EFAULT;
1446         }
1447
1448         num = count;
1449         if (num > (sizeof(tmp) - 1))
1450                 num = (sizeof(tmp) - 1);
1451
1452         if (copy_from_user(tmp, buffer, num))
1453         {
1454                 DBG_871X(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
1455                         FUNC_ADPT_ARG(padapter));
1456
1457                 return -EFAULT;
1458         }
1459
1460         num = sscanf(tmp, "%x %x", module, module+1);
1461         if (1 == num)
1462         {
1463                 if (0 == module[0])
1464                         _rtw_memset(module, 0, sizeof(module));
1465                 else
1466                         _rtw_memset(module, 0xFF, sizeof(module));
1467         }
1468         else if (2 != num)
1469         {
1470                 DBG_871X(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
1471                         FUNC_ADPT_ARG(padapter), tmp);
1472
1473                 if (0 == num)
1474                         return -EFAULT;
1475         }
1476
1477         DBG_871X(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
1478                 FUNC_ADPT_ARG(padapter), module[0], module[1]);
1479         rtw_btcoex_SetDBG(padapter, module);
1480
1481         return count;
1482 }
1483
1484 int proc_get_btcoex_info(struct seq_file *m, void *v)
1485 {
1486         struct net_device *dev = m->private;
1487         PADAPTER padapter;
1488         const u32 bufsize = 30*100;
1489         u8 *pbuf = NULL;
1490
1491         padapter = (PADAPTER)rtw_netdev_priv(dev);
1492
1493         pbuf = rtw_zmalloc(bufsize);
1494         if (NULL == pbuf) {
1495                 return -ENOMEM;
1496         }
1497
1498         rtw_btcoex_DisplayBtCoexInfo(padapter, pbuf, bufsize);
1499
1500         DBG_871X_SEL(m, "%s\n", pbuf);
1501
1502         rtw_mfree(pbuf, bufsize);
1503
1504         return 0;
1505 }
1506 #endif /* CONFIG_BT_COEXIST */
1507
1508 #if defined(DBG_CONFIG_ERROR_DETECT)
1509 int proc_get_sreset(struct seq_file *m, void *v)
1510 {
1511         struct net_device *dev = m->private;
1512         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1513         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1514
1515         return 0;
1516 }
1517
1518 ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1519 {
1520         struct net_device *dev = data;
1521         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1522         char tmp[32];
1523         s32 trigger_point;
1524
1525         if (count < 1)
1526                 return -EFAULT;
1527
1528         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1529
1530                 int num = sscanf(tmp, "%d", &trigger_point);
1531
1532                 if (trigger_point == SRESET_TGP_NULL)
1533                         rtw_hal_sreset_reset(padapter);
1534                 else
1535                         sreset_set_trigger_point(padapter, trigger_point);
1536         }
1537
1538         return count;
1539
1540 }
1541 #endif /* DBG_CONFIG_ERROR_DETECT */
1542
1543 int proc_get_monitor(struct seq_file *m, void *v)
1544 {
1545         struct net_device *dev = m->private;
1546         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1547         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1548         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1549
1550         if (WIFI_MONITOR_STATE == get_fwstate(pmlmepriv)) {
1551                 DBG_871X_SEL_NL(m, "Monitor mode : Enable\n");
1552
1553                 DBG_871X_SEL_NL(m, "ch=%d, ch_offset=%d, bw=%d\n",
1554                                                 rtw_get_oper_ch(padapter), rtw_get_oper_choffset(padapter), rtw_get_oper_bw(padapter));
1555         } else {
1556                 DBG_871X_SEL_NL(m, "Monitor mode : Disable\n");
1557         }
1558
1559         return 0;
1560 }
1561
1562 ssize_t proc_set_monitor(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1563 {
1564         char tmp[32];
1565         struct net_device *dev = data;
1566         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1567         u8 target_chan, target_offset, target_bw;
1568
1569         if (count < 3) {
1570                 DBG_871X("argument size is less than 3\n");
1571                 return -EFAULT;
1572         }
1573
1574         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
1575                 int num = sscanf(tmp, "%hhu %hhu %hhu", &target_chan, &target_offset, &target_bw);
1576
1577                 if (num != 3) {
1578                         DBG_871X("invalid write_reg parameter!\n");
1579                         return count;
1580                 }
1581
1582                 padapter->mlmeextpriv.cur_channel  = target_chan;
1583                 set_channel_bwmode(padapter, target_chan, target_offset, target_bw);
1584         }
1585
1586         return count;
1587 }
1588
1589 #endif
1590