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 #include <hal_data.h>
  24
  25 u32 GlobalDebugLevel = _drv_err_;
  26
  27 #ifdef CONFIG_DEBUG_RTL871X
  28
  29         u64 GlobalDebugComponents = \
  30                         _module_rtl871x_xmit_c_ |
  31                         _module_xmit_osdep_c_ |
  32                         _module_rtl871x_recv_c_ |
  33                         _module_recv_osdep_c_ |
  34                         _module_rtl871x_mlme_c_ |
  35                         _module_mlme_osdep_c_ |
  36                         _module_rtl871x_sta_mgt_c_ |
  37                         _module_rtl871x_cmd_c_ |
  38                         _module_cmd_osdep_c_ |
  39                         _module_rtl871x_io_c_ |
  40                         _module_io_osdep_c_ |
  41                         _module_os_intfs_c_|
  42                         _module_rtl871x_security_c_|
  43                         _module_rtl871x_eeprom_c_|
  44                         _module_hal_init_c_|
  45                         _module_hci_hal_init_c_|
  46                         _module_rtl871x_ioctl_c_|
  47                         _module_rtl871x_ioctl_set_c_|
  48                         _module_rtl871x_ioctl_query_c_|
  49                         _module_rtl871x_pwrctrl_c_|
  50                         _module_hci_intfs_c_|
  51                         _module_hci_ops_c_|
  52                         _module_hci_ops_os_c_|
  53                         _module_rtl871x_ioctl_os_c|
  54                         _module_rtl8712_cmd_c_|
  55                         _module_hal_xmit_c_|
  56                         _module_rtl8712_recv_c_ |
  57                         _module_mp_ |
  58                         _module_efuse_;
  59
  60 #endif /* CONFIG_DEBUG_RTL871X */
  61
  62 #include <rtw_version.h>
  63
  64 #ifdef CONFIG_TDLS
  65 #define TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE 41
  66 #endif
  67
  68 void dump_drv_version(void *sel)
  69 {
  70         DBG_871X_SEL_NL(sel, "%s %s\n", DRV_NAME, DRIVERVERSION);
  71         //DBG_871X_SEL_NL(sel, "build time: %s %s\n", __DATE__, __TIME__);
  72 }
  73
  74 void dump_drv_cfg(void *sel)
  75 {
  76         char *kernel_version = utsname()->release;
  77
  78         DBG_871X_SEL_NL(sel, "\nKernel Version: %s\n", kernel_version);
  79         DBG_871X_SEL_NL(sel, "Driver Version: %s\n", DRIVERVERSION);
  80         DBG_871X_SEL_NL(sel, "------------------------------------------------\n");
  81 #ifdef CONFIG_IOCTL_CFG80211
  82         DBG_871X_SEL_NL(sel, "CFG80211\n");
  83         #ifdef RTW_USE_CFG80211_STA_EVENT
  84         DBG_871X_SEL_NL(sel, "RTW_USE_CFG80211_STA_EVENT\n");
  85         #endif
  86 #else
  87         DBG_871X_SEL_NL(sel, "WEXT\n");
  88 #endif
  89
  90         DBG_871X_SEL_NL(sel, "DBG:%d\n", DBG);
  91 #ifdef CONFIG_DEBUG
  92         DBG_871X_SEL_NL(sel, "CONFIG_DEBUG\n");
  93 #endif
  94
  95 #ifdef CONFIG_CONCURRENT_MODE
  96         DBG_871X_SEL_NL(sel, "CONFIG_CONCURRENT_MODE\n");
  97 #endif
  98
  99 #ifdef CONFIG_POWER_SAVING
 100         DBG_871X_SEL_NL(sel, "CONFIG_POWER_SAVING\n");
 101 #endif
 102
 103 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
 104         DBG_871X_SEL_NL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH=%s\n", REALTEK_CONFIG_PATH);
 105         #ifdef CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY
 106         DBG_871X_SEL_NL(sel, "CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY\n");
 107         #endif
 108         #ifdef CONFIG_CALIBRATE_TX_POWER_TO_MAX
 109         DBG_871X_SEL_NL(sel, "CONFIG_CALIBRATE_TX_POWER_TO_MAX\n");
 110         #endif
 111 #endif
 112
 113 #ifdef CONFIG_DISABLE_ODM
 114         DBG_871X_SEL_NL(sel, "CONFIG_DISABLE_ODM\n");
 115 #endif
 116
 117 #ifdef CONFIG_MINIMAL_MEMORY_USAGE
 118         DBG_871X_SEL_NL(sel, "CONFIG_MINIMAL_MEMORY_USAGE\n");
 119 #endif
 120
 121         DBG_871X_SEL_NL(sel, "CONFIG_RTW_ADAPTIVITY_EN = %d\n", CONFIG_RTW_ADAPTIVITY_EN);
 122 #if (CONFIG_RTW_ADAPTIVITY_EN)
 123         DBG_871X_SEL_NL(sel, "ADAPTIVITY_MODE = %s\n", (CONFIG_RTW_ADAPTIVITY_MODE) ? "carrier_sense" : "normal");
 124 #endif
 125
 126 #ifdef CONFIG_WOWLAN
 127         DBG_871X_SEL_NL(sel, "CONFIG_WOWLAN - ");
 128
 129         #ifdef CONFIG_GPIO_WAKEUP
 130         DBG_871X_SEL_NL(sel, "CONFIG_GPIO_WAKEUP - WAKEUP_GPIO_IDX:%d\n", WAKEUP_GPIO_IDX);
 131         #endif
 132 #endif
 133
 134 #ifdef CONFIG_TDLS
 135         DBG_871X_SEL_NL(sel, "CONFIG_TDLS\n");
 136 #endif
 137
 138 #ifdef CONFIG_USB_HCI
 139         #ifdef CONFIG_SUPPORT_USB_INT
 140         DBG_871X_SEL_NL(sel, "CONFIG_SUPPORT_USB_INT\n");
 141         #endif
 142         #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
 143         DBG_871X_SEL_NL(sel, "CONFIG_USB_INTERRUPT_IN_PIPE\n");
 144         #endif
 145         #ifdef CONFIG_USB_TX_AGGREGATION
 146         DBG_871X_SEL_NL(sel, "CONFIG_USB_TX_AGGREGATION\n");
 147         #endif
 148         #ifdef CONFIG_USB_RX_AGGREGATION
 149         DBG_871X_SEL_NL(sel, "CONFIG_USB_RX_AGGREGATION\n");
 150         #endif
 151         #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
 152         DBG_871X_SEL_NL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_TX\n");
 153         #endif
 154         #ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
 155         DBG_871X_SEL_NL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_RX\n");
 156         #endif
 157         #ifdef CONFIG_PREALLOC_RECV_SKB
 158         DBG_871X_SEL_NL(sel, "CONFIG_PREALLOC_RECV_SKB\n");
 159         #endif
 160         #ifdef CONFIG_FIX_NR_BULKIN_BUFFER
 161         DBG_871X_SEL_NL(sel, "CONFIG_FIX_NR_BULKIN_BUFFER\n");
 162         #endif
 163 #endif /*CONFIG_USB_HCI*/
 164
 165 #ifdef CONFIG_SDIO_HCI
 166         #ifdef CONFIG_TX_AGGREGATION
 167         DBG_871X_SEL_NL(sel, "CONFIG_TX_AGGREGATION\n");
 168         #endif
 169         #ifdef CONFIG_RX_AGGREGATION
 170         DBG_871X_SEL_NL(sel, "CONFIG_RX_AGGREGATION\n");
 171         #endif
 172 #endif /*CONFIG_SDIO_HCI*/
 173
 174 #ifdef CONFIG_PCI_HCI
 175 #endif
 176
 177         DBG_871X_SEL_NL(sel, "MAX_XMITBUF_SZ = %d\n", MAX_XMITBUF_SZ);
 178         DBG_871X_SEL_NL(sel, "MAX_RECVBUF_SZ = %d\n", MAX_RECVBUF_SZ);
 179
 180 }
 181
 182 void dump_log_level(void *sel)
 183 {
 184         DBG_871X_SEL_NL(sel, "log_level:%d\n", GlobalDebugLevel);
 185 }
 186
 187 #ifdef CONFIG_SDIO_HCI
 188 void sd_f0_reg_dump(void *sel, _adapter *adapter)
 189 {
 190         int i;
 191
 192         for(i=0x0;i<=0xff;i++)
 193         {
 194                 if(i%16==0)
 195                         DBG_871X_SEL_NL(sel, "0x%02x ",i);
 196
 197                 DBG_871X_SEL(sel, "%02x ", rtw_sd_f0_read8(adapter, i));
 198
 199                 if(i%16==15)
 200                         DBG_871X_SEL(sel, "\n");
 201                 else if(i%8==7)
 202                         DBG_871X_SEL(sel, "\t");
 203         }
 204 }
 205
 206 void sdio_local_reg_dump(void *sel, _adapter *adapter)
 207 {
 208         int i, j = 1;
 209
 210         for (i = 0x0; i < 0x100; i += 4) {
 211                 if (j % 4 == 1)
 212                         DBG_871X_SEL_NL(sel, "0x%02x", i);
 213                 DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter, (0x1025 << 16) | i));
 214                 if ((j++) % 4 == 0)
 215                         DBG_871X_SEL(sel, "\n");
 216         }
 217 }
 218 #endif /* CONFIG_SDIO_HCI */
 219
 220 void mac_reg_dump(void *sel, _adapter *adapter)
 221 {
 222         int i, j = 1;
 223
 224         DBG_871X_SEL_NL(sel, "======= MAC REG =======\n");
 225
 226         for(i=0x0;i<0x800;i+=4)
 227         {
 228                 if(j%4==1)
 229                         DBG_871X_SEL_NL(sel, "0x%03x",i);
 230                 DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter,i));
 231                 if((j++)%4 == 0)
 232                         DBG_871X_SEL(sel, "\n");
 233         }
 234
 235 #ifdef CONFIG_RTL8814A
 236         {
 237                 for(i=0x1000;i<0x1650;i+=4)
 238                 {
 239                         if(j%4==1)
 240                                 DBG_871X_SEL_NL(sel, "0x%03x",i);
 241                         DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter,i));
 242                         if((j++)%4 == 0)
 243                                 DBG_871X_SEL(sel, "\n");
 244                 }
 245         }
 246 #endif /* CONFIG_RTL8814A */
 247 }
 248
 249 void bb_reg_dump(void *sel, _adapter *adapter)
 250 {
 251         int i, j = 1;
 252
 253         DBG_871X_SEL_NL(sel, "======= BB REG =======\n");
 254         for(i=0x800;i<0x1000;i+=4)
 255         {
 256                 if(j%4==1)
 257                         DBG_871X_SEL_NL(sel, "0x%03x",i);
 258                 DBG_871X_SEL(sel, " 0x%08x ", rtw_read32(adapter,i));
 259                 if((j++)%4 == 0)
 260                         DBG_871X_SEL(sel, "\n");
 261         }
 262 }
 263
 264 void rf_reg_dump(void *sel, _adapter *adapter)
 265 {
 266         int i, j = 1, path;
 267         u32 value;
 268         u8 rf_type = 0;
 269         u8 path_nums = 0;
 270
 271         rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 272         if((RF_1T2R == rf_type) ||(RF_1T1R ==rf_type ))
 273                 path_nums = 1;
 274         else
 275                 path_nums = 2;
 276
 277         DBG_871X_SEL_NL(sel, "======= RF REG =======\n");
 278
 279         for (path=0;path<path_nums;path++) {
 280                 DBG_871X_SEL_NL(sel, "RF_Path(%x)\n",path);
 281                 for (i=0;i<0x100;i++) {
 282                         value = rtw_hal_read_rfreg(adapter, path, i, 0xffffffff);
 283                         if(j%4==1)
 284                                 DBG_871X_SEL_NL(sel, "0x%02x ",i);
 285                         DBG_871X_SEL(sel, " 0x%08x ",value);
 286                         if((j++)%4==0)
 287                                 DBG_871X_SEL(sel, "\n");
 288                 }
 289         }
 290 }
 291
 292 static u8 fwdl_test_chksum_fail = 0;
 293 static u8 fwdl_test_wintint_rdy_fail = 0;
 294
 295 bool rtw_fwdl_test_trigger_chksum_fail(void)
 296 {
 297         if (fwdl_test_chksum_fail) {
 298                 DBG_871X_LEVEL(_drv_always_, "fwdl test case: trigger chksum_fail\n");
 299                 fwdl_test_chksum_fail--;
 300                 return _TRUE;
 301         }
 302         return _FALSE;
 303 }
 304
 305 bool rtw_fwdl_test_trigger_wintint_rdy_fail(void)
 306 {
 307         if (fwdl_test_wintint_rdy_fail) {
 308                 DBG_871X_LEVEL(_drv_always_, "fwdl test case: trigger wintint_rdy_fail\n");
 309                 fwdl_test_wintint_rdy_fail--;
 310                 return _TRUE;
 311         }
 312         return _FALSE;
 313 }
 314
 315 static u32 g_wait_hiq_empty_ms = 0;
 316
 317 u32 rtw_get_wait_hiq_empty_ms(void)
 318 {
 319         return g_wait_hiq_empty_ms;
 320 }
 321
 322 static u8 del_rx_ampdu_test_no_tx_fail = 0;
 323
 324 bool rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)
 325 {
 326         if (del_rx_ampdu_test_no_tx_fail) {
 327                 DBG_871X_LEVEL(_drv_always_, "del_rx_ampdu test case: trigger no_tx_fail\n");
 328                 del_rx_ampdu_test_no_tx_fail--;
 329                 return _TRUE;
 330         }
 331         return _FALSE;
 332 }
 333
 334 void rtw_sink_rtp_seq_dbg( _adapter *adapter,_pkt *pkt)
 335 {
 336         struct recv_priv *precvpriv = &(adapter->recvpriv);
 337         if( precvpriv->sink_udpport > 0)
 338         {
 339                 if(*((u16*)((pkt->data)+0x24)) == cpu_to_be16(precvpriv->sink_udpport))
 340                 {
 341                         precvpriv->pre_rtp_rxseq= precvpriv->cur_rtp_rxseq;
 342                         precvpriv->cur_rtp_rxseq = be16_to_cpu(*((u16*)((pkt->data)+0x2C)));
 343                         if( precvpriv->pre_rtp_rxseq+1 != precvpriv->cur_rtp_rxseq)
 344                                 DBG_871X("%s : RTP Seq num from %d to %d\n",__FUNCTION__,precvpriv->pre_rtp_rxseq,precvpriv->cur_rtp_rxseq);
 345                 }
 346         }
 347 }
 348
 349 void sta_rx_reorder_ctl_dump(void *sel, struct sta_info *sta)
 350 {
 351         struct recv_reorder_ctrl *reorder_ctl;
 352         int i;
 353
 354         for (i = 0; i < 16; i++) {
 355                 reorder_ctl = &sta->recvreorder_ctrl[i];
 356                 if (reorder_ctl->ampdu_size != RX_AMPDU_SIZE_INVALID || reorder_ctl->indicate_seq != 0xFFFF) {
 357                         DBG_871X_SEL_NL(sel, "tid=%d, enable=%d, ampdu_size=%u, indicate_seq=%u\n"
 358                                 , i, reorder_ctl->enable, reorder_ctl->ampdu_size, reorder_ctl->indicate_seq
 359                         );
 360                 }
 361         }
 362 }
 363
 364 void dump_adapters_status(void *sel, struct dvobj_priv *dvobj)
 365 {
 366         struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
 367         int i;
 368         _adapter *iface;
 369         u8 u_ch, u_bw, u_offset;
 370
 371         DBG_871X_SEL_NL(sel, "%-2s %-8s %-17s %-4s %-7s %s\n"
 372                 , "id", "ifname", "macaddr", "port", "ch", "status");
 373
 374         DBG_871X_SEL_NL(sel, "------------------------------------------\n");
 375
 376         for (i = 0; i < dvobj->iface_nums; i++) {
 377                 iface = dvobj->padapters[i];
 378                 if (iface) {
 379                         DBG_871X_SEL_NL(sel, "%2d %-8s "MAC_FMT" %4hhu %3u,%u,%u "MLME_STATE_FMT" %s%s\n"
 380                                 , i, ADPT_ARG(iface)
 381                                 , MAC_ARG(adapter_mac_addr(iface))
 382                                 , get_iface_type(iface)
 383                                 , iface->mlmeextpriv.cur_channel
 384                                 , iface->mlmeextpriv.cur_bwmode
 385                                 , iface->mlmeextpriv.cur_ch_offset
 386                                 , MLME_STATE_ARG(iface)
 387                                 , rtw_is_surprise_removed(iface)?" SR":""
 388                                 , rtw_is_drv_stopped(iface)?" DS":""
 389                         );
 390                 }
 391         }
 392
 393         DBG_871X_SEL_NL(sel, "------------------------------------------\n");
 394
 395         rtw_get_ch_setting_union(dvobj->padapters[IFACE_ID0], &u_ch, &u_bw, &u_offset);
 396         DBG_871X_SEL_NL(sel, "%34s %3u,%u,%u\n"
 397                 , "union:"
 398                 , u_ch, u_bw, u_offset
 399         );
 400
 401         DBG_871X_SEL_NL(sel, "%34s %3u,%u,%u\n"
 402                 , "oper:"
 403                 , dvobj->oper_channel
 404                 , dvobj->oper_bwmode
 405                 , dvobj->oper_ch_offset
 406         );
 407
 408         #ifdef CONFIG_DFS_MASTER
 409         if (rfctl->radar_detect_ch != 0) {
 410                 DBG_871X_SEL_NL(sel, "%34s %3u,%u,%u"
 411                         , "radar_detect:"
 412                         , rfctl->radar_detect_ch
 413                         , rfctl->radar_detect_bw
 414                         , rfctl->radar_detect_offset
 415                 );
 416
 417                 if (IS_UNDER_CAC(rfctl))
 418                         DBG_871X_SEL(sel, ", cac:%d\n", rtw_systime_to_ms(rfctl->cac_end_time - rtw_get_current_time()));
 419                 else
 420                         DBG_871X_SEL(sel, "\n");
 421         }
 422         #endif
 423 }
 424
 425 #define SEC_CAM_ENT_ID_TITLE_FMT "%-2s"
 426 #define SEC_CAM_ENT_ID_TITLE_ARG "id"
 427 #define SEC_CAM_ENT_ID_VALUE_FMT "%2u"
 428 #define SEC_CAM_ENT_ID_VALUE_ARG(id) (id)
 429
 430 #define SEC_CAM_ENT_TITLE_FMT "%-6s %-17s %-32s %-3s %-7s %-2s %-2s %-5s"
 431 #define SEC_CAM_ENT_TITLE_ARG "ctrl", "addr", "key", "kid", "type", "MK", "GK", "valid"
 432 #define SEC_CAM_ENT_VALUE_FMT "0x%04x "MAC_FMT" "KEY_FMT" %3u %-7s %2u %2u %5u"
 433 #define SEC_CAM_ENT_VALUE_ARG(ent) \
 434         (ent)->ctrl \
 435         , MAC_ARG((ent)->mac) \
 436         , KEY_ARG((ent)->key) \
 437         , ((ent)->ctrl) & 0x03 \
 438         , security_type_str((((ent)->ctrl) >> 2) & 0x07) \
 439         , (((ent)->ctrl) >> 5) & 0x01 \
 440         , (((ent)->ctrl) >> 6) & 0x01 \
 441         , (((ent)->ctrl) >> 15) & 0x01
 442
 443 void dump_sec_cam_ent(void *sel, struct sec_cam_ent *ent, int id)
 444 {
 445         if (id >= 0) {
 446                 DBG_871X_SEL_NL(sel, SEC_CAM_ENT_ID_VALUE_FMT " " SEC_CAM_ENT_VALUE_FMT"\n"
 447                         , SEC_CAM_ENT_ID_VALUE_ARG(id), SEC_CAM_ENT_VALUE_ARG(ent));
 448         } else {
 449                 DBG_871X_SEL_NL(sel, SEC_CAM_ENT_VALUE_FMT"\n", SEC_CAM_ENT_VALUE_ARG(ent));
 450         }
 451 }
 452
 453 void dump_sec_cam_ent_title(void *sel, u8 has_id)
 454 {
 455         if (has_id) {
 456                 DBG_871X_SEL_NL(sel, SEC_CAM_ENT_ID_TITLE_FMT " " SEC_CAM_ENT_TITLE_FMT"\n"
 457                         , SEC_CAM_ENT_ID_TITLE_ARG, SEC_CAM_ENT_TITLE_ARG);
 458         } else {
 459                 DBG_871X_SEL_NL(sel, SEC_CAM_ENT_TITLE_FMT"\n", SEC_CAM_ENT_TITLE_ARG);
 460         }
 461 }
 462
 463 void dump_sec_cam(void *sel, _adapter *adapter)
 464 {
 465         struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
 466         struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
 467         struct sec_cam_ent ent;
 468         int i;
 469
 470         DBG_871X_SEL_NL(sel, "HW sec cam:\n");
 471         dump_sec_cam_ent_title(sel, 1);
 472         for (i = 0; i < cam_ctl->num; i++) {
 473                 rtw_sec_read_cam_ent(adapter, i, (u8 *)(&ent.ctrl), ent.mac, ent.key);
 474                 dump_sec_cam_ent(sel , &ent, i);
 475         }
 476 }
 477
 478 #ifdef CONFIG_PROC_DEBUG
 479 ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 480 {
 481         struct net_device *dev = data;
 482         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 483         char tmp[32];
 484         u32 addr, val, len;
 485
 486         if (count < 3)
 487         {
 488                 DBG_871X("argument size is less than 3\n");
 489                 return -EFAULT;
 490         }
 491
 492         if (count > sizeof(tmp)) {
 493                 rtw_warn_on(1);
 494                 return -EFAULT;
 495         }
 496
 497         if (buffer && !copy_from_user(tmp, buffer, count)) {
 498
 499                 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
 500
 501                 if (num !=  3) {
 502                         DBG_871X("invalid write_reg parameter!\n");
 503                         return count;
 504                 }
 505
 506                 switch(len)
 507                 {
 508                         case 1:
 509                                 rtw_write8(padapter, addr, (u8)val);
 510                                 break;
 511                         case 2:
 512                                 rtw_write16(padapter, addr, (u16)val);
 513                                 break;
 514                         case 4:
 515                                 rtw_write32(padapter, addr, val);
 516                                 break;
 517                         default:
 518                                 DBG_871X("error write length=%d", len);
 519                                 break;
 520                 }
 521
 522         }
 523
 524         return count;
 525
 526 }
 527
 528 static u32 proc_get_read_addr=0xeeeeeeee;
 529 static u32 proc_get_read_len=0x4;
 530
 531 int proc_get_read_reg(struct seq_file *m, void *v)
 532 {
 533         struct net_device *dev = m->private;
 534         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 535
 536         if (proc_get_read_addr==0xeeeeeeee) {
 537                 DBG_871X_SEL_NL(m, "address not initialized\n");
 538                 return 0;
 539         }
 540
 541         switch(proc_get_read_len)
 542         {
 543                 case 1:
 544                         DBG_871X_SEL_NL(m, "rtw_read8(0x%x)=0x%x\n", proc_get_read_addr, rtw_read8(padapter, proc_get_read_addr));
 545                         break;
 546                 case 2:
 547                         DBG_871X_SEL_NL(m, "rtw_read16(0x%x)=0x%x\n", proc_get_read_addr, rtw_read16(padapter, proc_get_read_addr));
 548                         break;
 549                 case 4:
 550                         DBG_871X_SEL_NL(m, "rtw_read32(0x%x)=0x%x\n", proc_get_read_addr, rtw_read32(padapter, proc_get_read_addr));
 551                         break;
 552                 default:
 553                         DBG_871X_SEL_NL(m, "error read length=%d\n", proc_get_read_len);
 554                         break;
 555         }
 556
 557         return 0;
 558 }
 559
 560 ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 561 {
 562         struct net_device *dev = data;
 563         char tmp[16];
 564         u32 addr, len;
 565
 566         if (count < 2)
 567         {
 568                 DBG_871X("argument size is less than 2\n");
 569                 return -EFAULT;
 570         }
 571
 572         if (count > sizeof(tmp)) {
 573                 rtw_warn_on(1);
 574                 return -EFAULT;
 575         }
 576
 577         if (buffer && !copy_from_user(tmp, buffer, count)) {
 578
 579                 int num = sscanf(tmp, "%x %x", &addr, &len);
 580
 581                 if (num !=  2) {
 582                         DBG_871X("invalid read_reg parameter!\n");
 583                         return count;
 584                 }
 585
 586                 proc_get_read_addr = addr;
 587
 588                 proc_get_read_len = len;
 589         }
 590
 591         return count;
 592
 593 }
 594
 595 int proc_get_fwstate(struct seq_file *m, void *v)
 596 {
 597         struct net_device *dev = m->private;
 598         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 599         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 600
 601         DBG_871X_SEL_NL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
 602
 603         return 0;
 604 }
 605
 606 int proc_get_sec_info(struct seq_file *m, void *v)
 607 {
 608         struct net_device *dev = m->private;
 609         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 610         struct security_priv *sec = &padapter->securitypriv;
 611
 612         DBG_871X_SEL_NL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
 613                                                 sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
 614                                                 sec->ndisauthtype, sec->ndisencryptstatus);
 615
 616         DBG_871X_SEL_NL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
 617
 618 #ifdef DBG_SW_SEC_CNT
 619         DBG_871X_SEL_NL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
 620                 , sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
 621         DBG_871X_SEL_NL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
 622                 , sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
 623
 624         DBG_871X_SEL_NL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
 625                 , sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
 626         DBG_871X_SEL_NL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
 627                 , sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
 628
 629         DBG_871X_SEL_NL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
 630                 , sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
 631         DBG_871X_SEL_NL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
 632                 , sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
 633 #endif /* DBG_SW_SEC_CNT */
 634
 635         return 0;
 636 }
 637
 638 int proc_get_mlmext_state(struct seq_file *m, void *v)
 639 {
 640         struct net_device *dev = m->private;
 641         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 642         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 643         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 644
 645         DBG_871X_SEL_NL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
 646
 647         return 0;
 648 }
 649
 650 #ifdef CONFIG_LAYER2_ROAMING
 651 int proc_get_roam_flags(struct seq_file *m, void *v)
 652 {
 653         struct net_device *dev = m->private;
 654         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 655
 656         DBG_871X_SEL_NL(m, "0x%02x\n", rtw_roam_flags(adapter));
 657
 658         return 0;
 659 }
 660
 661 ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 662 {
 663         struct net_device *dev = data;
 664         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 665
 666         char tmp[32];
 667         u8 flags;
 668
 669         if (count < 1)
 670                 return -EFAULT;
 671
 672         if (count > sizeof(tmp)) {
 673                 rtw_warn_on(1);
 674                 return -EFAULT;
 675         }
 676
 677         if (buffer && !copy_from_user(tmp, buffer, count)) {
 678
 679                 int num = sscanf(tmp, "%hhx", &flags);
 680
 681                 if (num == 1)
 682                         rtw_assign_roam_flags(adapter, flags);
 683         }
 684
 685         return count;
 686
 687 }
 688
 689 int proc_get_roam_param(struct seq_file *m, void *v)
 690 {
 691         struct net_device *dev = m->private;
 692         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 693         struct mlme_priv *mlme = &adapter->mlmepriv;
 694
 695         DBG_871X_SEL_NL(m, "%12s %12s %11s\n", "rssi_diff_th", "scanr_exp_ms", "scan_int_ms");
 696         DBG_871X_SEL_NL(m, "%-12u %-12u %-11u\n"
 697                 , mlme->roam_rssi_diff_th
 698                 , mlme->roam_scanr_exp_ms
 699                 , mlme->roam_scan_int_ms
 700         );
 701
 702         return 0;
 703 }
 704
 705 ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 706 {
 707         struct net_device *dev = data;
 708         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 709         struct mlme_priv *mlme = &adapter->mlmepriv;
 710
 711         char tmp[32];
 712         u8 rssi_diff_th;
 713         u32 scanr_exp_ms;
 714         u32 scan_int_ms;
 715
 716         if (count < 1)
 717                 return -EFAULT;
 718
 719         if (count > sizeof(tmp)) {
 720                 rtw_warn_on(1);
 721                 return -EFAULT;
 722         }
 723
 724         if (buffer && !copy_from_user(tmp, buffer, count)) {
 725
 726                 int num = sscanf(tmp, "%hhu %u %u", &rssi_diff_th, &scanr_exp_ms, &scan_int_ms);
 727
 728                 if (num >= 1)
 729                         mlme->roam_rssi_diff_th = rssi_diff_th;
 730                 if (num >= 2)
 731                         mlme->roam_scanr_exp_ms = scanr_exp_ms;
 732                 if (num >= 3)
 733                         mlme->roam_scan_int_ms = scan_int_ms;
 734         }
 735
 736         return count;
 737
 738 }
 739
 740 ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 741 {
 742         struct net_device *dev = data;
 743         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 744
 745         char tmp[32];
 746         u8 addr[ETH_ALEN];
 747
 748         if (count < 1)
 749                 return -EFAULT;
 750
 751         if (count > sizeof(tmp)) {
 752                 rtw_warn_on(1);
 753                 return -EFAULT;
 754         }
 755
 756         if (buffer && !copy_from_user(tmp, buffer, count)) {
 757
 758                 int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr+1, addr+2, addr+3, addr+4, addr+5);
 759                 if (num == 6)
 760                         _rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
 761
 762                 DBG_871X("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
 763         }
 764
 765         return count;
 766 }
 767 #endif /* CONFIG_LAYER2_ROAMING */
 768
 769 int proc_get_qos_option(struct seq_file *m, void *v)
 770 {
 771         struct net_device *dev = m->private;
 772         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 773         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 774
 775         DBG_871X_SEL_NL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
 776
 777         return 0;
 778 }
 779
 780 int proc_get_ht_option(struct seq_file *m, void *v)
 781 {
 782         struct net_device *dev = m->private;
 783         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 784         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 785
 786 #ifdef CONFIG_80211N_HT
 787         DBG_871X_SEL_NL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
 788 #endif //CONFIG_80211N_HT
 789
 790         return 0;
 791 }
 792
 793 int proc_get_rf_info(struct seq_file *m, void *v)
 794 {
 795         struct net_device *dev = m->private;
 796         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 797         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 798
 799         DBG_871X_SEL_NL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
 800                                         pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 801
 802         DBG_871X_SEL_NL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
 803                                         rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter),  rtw_get_oper_choffset(padapter));
 804
 805         return 0;
 806 }
 807
 808 int proc_get_scan_param(struct seq_file *m, void *v)
 809 {
 810         struct net_device *dev = m->private;
 811         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 812         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
 813         struct ss_res *ss = &mlmeext->sitesurvey_res;
 814
 815 #define SCAN_PARAM_TITLE_FMT "%10s"
 816 #define SCAN_PARAM_VALUE_FMT "%-10u"
 817 #define SCAN_PARAM_TITLE_ARG , "scan_ch_ms"
 818 #define SCAN_PARAM_VALUE_ARG , ss->scan_ch_ms
 819 #ifdef CONFIG_80211N_HT
 820         #define SCAN_PARAM_TITLE_FMT_HT " %15s %13s"
 821         #define SCAN_PARAM_VALUE_FMT_HT " %-15u %-13u"
 822         #define SCAN_PARAM_TITLE_ARG_HT , "rx_ampdu_accept", "rx_ampdu_size"
 823         #define SCAN_PARAM_VALUE_ARG_HT , ss->rx_ampdu_accept, ss->rx_ampdu_size
 824 #else
 825         #define SCAN_PARAM_TITLE_FMT_HT ""
 826         #define SCAN_PARAM_VALUE_FMT_HT ""
 827         #define SCAN_PARAM_TITLE_ARG_HT
 828         #define SCAN_PARAM_VALUE_ARG_HT
 829 #endif
 830 #ifdef CONFIG_SCAN_BACKOP
 831         #define SCAN_PARAM_TITLE_FMT_BACKOP " %9s %12s"
 832         #define SCAN_PARAM_VALUE_FMT_BACKOP " %-9u %-12u"
 833         #define SCAN_PARAM_TITLE_ARG_BACKOP , "backop_ms", "scan_cnt_max"
 834         #define SCAN_PARAM_VALUE_ARG_BACKOP , ss->backop_ms, ss->scan_cnt_max
 835 #else
 836         #define SCAN_PARAM_TITLE_FMT_BACKOP ""
 837         #define SCAN_PARAM_VALUE_FMT_BACKOP ""
 838         #define SCAN_PARAM_TITLE_ARG_BACKOP
 839         #define SCAN_PARAM_VALUE_ARG_BACKOP
 840 #endif
 841
 842         DBG_871X_SEL_NL(m,
 843                 SCAN_PARAM_TITLE_FMT
 844                 SCAN_PARAM_TITLE_FMT_HT
 845                 SCAN_PARAM_TITLE_FMT_BACKOP
 846                 "\n"
 847                 SCAN_PARAM_TITLE_ARG
 848                 SCAN_PARAM_TITLE_ARG_HT
 849                 SCAN_PARAM_TITLE_ARG_BACKOP
 850         );
 851
 852         DBG_871X_SEL_NL(m,
 853                 SCAN_PARAM_VALUE_FMT
 854                 SCAN_PARAM_VALUE_FMT_HT
 855                 SCAN_PARAM_VALUE_FMT_BACKOP
 856                 "\n"
 857                 SCAN_PARAM_VALUE_ARG
 858                 SCAN_PARAM_VALUE_ARG_HT
 859                 SCAN_PARAM_VALUE_ARG_BACKOP
 860         );
 861
 862         return 0;
 863 }
 864
 865 ssize_t proc_set_scan_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 866 {
 867         struct net_device *dev = data;
 868         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 869         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
 870         struct ss_res *ss = &mlmeext->sitesurvey_res;
 871
 872         char tmp[32] = {0};
 873
 874 u16 scan_ch_ms;
 875 #define SCAN_PARAM_INPUT_FMT "%hu"
 876 #define SCAN_PARAM_INPUT_ARG , &scan_ch_ms
 877 #ifdef CONFIG_80211N_HT
 878         u8 rx_ampdu_accept;
 879         u8 rx_ampdu_size;
 880         #define SCAN_PARAM_INPUT_FMT_HT " %hhu %hhu"
 881         #define SCAN_PARAM_INPUT_ARG_HT , &rx_ampdu_accept, &rx_ampdu_size
 882 #else
 883         #define SCAN_PARAM_INPUT_FMT_HT ""
 884         #define SCAN_PARAM_INPUT_ARG_HT
 885 #endif
 886 #ifdef CONFIG_SCAN_BACKOP
 887         u16 backop_ms;
 888         u8 scan_cnt_max;
 889         #define SCAN_PARAM_INPUT_FMT_BACKOP " %hu %hhu"
 890         #define SCAN_PARAM_INPUT_ARG_BACKOP , &backop_ms, &scan_cnt_max
 891 #else
 892         #define SCAN_PARAM_INPUT_FMT_BACKOP ""
 893         #define SCAN_PARAM_INPUT_ARG_BACKOP
 894 #endif
 895
 896         if (count < 1)
 897                 return -EFAULT;
 898
 899         if (count > sizeof(tmp)) {
 900                 rtw_warn_on(1);
 901                 return -EFAULT;
 902         }
 903
 904         if (buffer && !copy_from_user(tmp, buffer, count)) {
 905
 906                 int num = sscanf(tmp,
 907                         SCAN_PARAM_INPUT_FMT
 908                         SCAN_PARAM_INPUT_FMT_HT
 909                         SCAN_PARAM_INPUT_FMT_BACKOP
 910                         SCAN_PARAM_INPUT_ARG
 911                         SCAN_PARAM_INPUT_ARG_HT
 912                         SCAN_PARAM_INPUT_ARG_BACKOP
 913                 );
 914
 915                 if (num-- > 0)
 916                         ss->scan_ch_ms = scan_ch_ms;
 917                 #ifdef CONFIG_80211N_HT
 918                 if (num-- > 0)
 919                         ss->rx_ampdu_accept = rx_ampdu_accept;
 920                 if (num-- > 0)
 921                         ss->rx_ampdu_size = rx_ampdu_size;
 922                 #endif
 923                 #ifdef CONFIG_SCAN_BACKOP
 924                 if (num-- > 0)
 925                         ss->backop_ms = backop_ms;
 926                 if (num-- > 0)
 927                         ss->scan_cnt_max = scan_cnt_max;
 928                 #endif
 929         }
 930
 931         return count;
 932 }
 933
 934 int proc_get_scan_abort(struct seq_file *m, void *v)
 935 {
 936         struct net_device *dev = m->private;
 937         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 938         u32 pass_ms;
 939
 940         pass_ms = rtw_scan_abort_timeout(adapter, 10000);
 941
 942         DBG_871X_SEL_NL(m, "%u\n", pass_ms);
 943
 944         return 0;
 945 }
 946
 947 #ifdef CONFIG_SCAN_BACKOP
 948 int proc_get_backop_flags_sta(struct seq_file *m, void *v)
 949 {
 950         struct net_device *dev = m->private;
 951         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 952         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
 953
 954         DBG_871X_SEL_NL(m, "0x%02x\n", mlmeext_scan_backop_flags_sta(mlmeext));
 955
 956         return 0;
 957 }
 958
 959 ssize_t proc_set_backop_flags_sta(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 960 {
 961         struct net_device *dev = data;
 962         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 963         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
 964
 965         char tmp[32];
 966         u8 flags;
 967
 968         if (count < 1)
 969                 return -EFAULT;
 970
 971         if (count > sizeof(tmp)) {
 972                 rtw_warn_on(1);
 973                 return -EFAULT;
 974         }
 975
 976         if (buffer && !copy_from_user(tmp, buffer, count)) {
 977
 978                 int num = sscanf(tmp, "%hhx", &flags);
 979
 980                 if (num == 1)
 981                         mlmeext_assign_scan_backop_flags_sta(mlmeext, flags);
 982         }
 983
 984         return count;
 985 }
 986
 987 int proc_get_backop_flags_ap(struct seq_file *m, void *v)
 988 {
 989         struct net_device *dev = m->private;
 990         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
 991         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
 992
 993         DBG_871X_SEL_NL(m, "0x%02x\n", mlmeext_scan_backop_flags_ap(mlmeext));
 994
 995         return 0;
 996 }
 997
 998 ssize_t proc_set_backop_flags_ap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
 999 {
1000         struct net_device *dev = data;
1001         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1002         struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1003
1004         char tmp[32];
1005         u8 flags;
1006
1007         if (count < 1)
1008                 return -EFAULT;
1009
1010         if (count > sizeof(tmp)) {
1011                 rtw_warn_on(1);
1012                 return -EFAULT;
1013         }
1014
1015         if (buffer && !copy_from_user(tmp, buffer, count)) {
1016
1017                 int num = sscanf(tmp, "%hhx", &flags);
1018
1019                 if (num == 1)
1020                         mlmeext_assign_scan_backop_flags_ap(mlmeext, flags);
1021         }
1022
1023         return count;
1024 }
1025
1026 #endif /* CONFIG_SCAN_BACKOP */
1027
1028 int proc_get_survey_info(struct seq_file *m, void *v)
1029 {
1030         _irqL irqL;
1031         struct net_device *dev = m->private;
1032         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1033         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
1034         _queue  *queue  = &(pmlmepriv->scanned_queue);
1035         struct wlan_network     *pnetwork = NULL;
1036         _list   *plist, *phead;
1037         s32 notify_signal;
1038         s16 notify_noise = 0;
1039         u16  index = 0, ie_cap = 0;
1040         unsigned char *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
1041         unsigned char *ie_p2p = NULL, *ssid = NULL;
1042         char flag_str[64];
1043         int ielen = 0;
1044         u32 wpsielen = 0;
1045
1046         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
1047         phead = get_list_head(queue);
1048         if(!phead)
1049                 return 0;
1050         plist = get_next(phead);
1051         if (!plist)
1052                 return 0;
1053
1054         DBG_871X_SEL_NL(m, "%5s  %-17s  %3s  %-3s  %-4s  %-4s  %5s  %32s  %32s\n", "index", "bssid", "ch", "RSSI", "SdBm", "Noise", "age", "flag", "ssid");
1055         while(1)
1056         {
1057                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
1058                         break;
1059
1060                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1061                 if (!pnetwork)
1062                         break;
1063
1064                 if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE &&
1065                         is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
1066                         notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);//dbm
1067                 } else {
1068                         notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);//dbm
1069                 }
1070
1071                 #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
1072                 rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(pnetwork->network.Configuration.DSConfig), &(notify_noise));
1073                 #endif
1074
1075                 ie_wpa = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength-12);
1076                 ie_wpa2 = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength-12);
1077                 ie_cap = rtw_get_capability(&pnetwork->network);
1078                 ie_wps = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength-12, NULL, &wpsielen);
1079                 ie_p2p = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength-12, NULL, &ielen);
1080                 ssid = pnetwork->network.Ssid.Ssid;
1081                 sprintf(flag_str, "%s%s%s%s%s%s%s",
1082                                         (ie_wpa) ? "[WPA]":"",
1083                                         (ie_wpa2) ? "[WPA2]":"",
1084                                         (!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]":"",
1085                                         (ie_wps) ? "[WPS]":"",
1086                                         (pnetwork->network.InfrastructureMode == Ndis802_11IBSS) ? "[IBSS]":"",
1087                                         (ie_cap & BIT(0)) ? "[ESS]":"",
1088                                         (ie_p2p) ? "[P2P]":"");
1089                 DBG_871X_SEL_NL(m, "%5d  "MAC_FMT"  %3d  %3d  %4d  %4d    %5d  %32s  %32s\n",
1090                         ++index,
1091                         MAC_ARG(pnetwork->network.MacAddress),
1092                         pnetwork->network.Configuration.DSConfig,
1093                         (int)pnetwork->network.Rssi,
1094                         notify_signal,
1095                         notify_noise,
1096                         rtw_get_passing_time_ms((u32)pnetwork->last_scanned),
1097                         flag_str,
1098                         pnetwork->network.Ssid.Ssid);
1099                 plist = get_next(plist);
1100         }
1101         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
1102
1103         return 0;
1104 }
1105
1106 ssize_t proc_set_survey_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1107 {
1108         _irqL irqL;
1109         struct net_device *dev = data;
1110         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1111         struct mlme_priv        *pmlmepriv = &(padapter->mlmepriv);
1112         bool need_indicate_scan_done = _FALSE;
1113         u8 _status = _FALSE;
1114         NDIS_802_11_SSID ssid[RTW_SSID_SCAN_AMOUNT];
1115
1116         if (count < 1)
1117                 return -EFAULT;
1118
1119 #ifdef CONFIG_MP_INCLUDED
1120                 if ((padapter->registrypriv.mp_mode == 1)
1121 #ifdef CONFIG_CONCURRENT_MODE
1122                 || ((padapter->pbuddy_adapter) && (padapter->pbuddy_adapter->registrypriv.mp_mode == 1))
1123 #endif
1124                 ){
1125                         DBG_871X(FUNC_ADPT_FMT ": MP mode block Scan request\n", FUNC_ADPT_ARG(padapter));
1126                         goto exit;
1127                 }
1128 #endif
1129         rtw_ps_deny(padapter, PS_DENY_SCAN);
1130         if (_FAIL == rtw_pwr_wakeup(padapter))
1131                 goto exit;
1132
1133         if (rtw_is_drv_stopped(padapter)) {
1134                 DBG_871X("scan abort!! bDriverStopped=_TRUE\n");
1135                 goto exit;
1136         }
1137
1138         if (!padapter->bup) {
1139                 DBG_871X("scan abort!! bup=%d\n", padapter->bup);
1140                 goto exit;
1141         }
1142
1143         if (!rtw_is_hw_init_completed(padapter)) {
1144                 DBG_871X("scan abort!! hw_init_completed=FALSE\n");
1145                 goto exit;
1146         }
1147
1148         if (rtw_is_scan_deny(padapter)) {
1149                 DBG_871X(FUNC_ADPT_FMT  ": scan deny\n", FUNC_ADPT_ARG(padapter));
1150                 goto exit;
1151         }
1152
1153         if ((pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE)
1154 #ifdef CONFIG_CONCURRENT_MODE
1155         || (rtw_get_buddy_bBusyTraffic(padapter) == _TRUE)
1156 #endif
1157         ) {
1158                 DBG_871X("scan abort!! BusyTraffic == _TRUE\n");
1159                 goto exit;
1160         }
1161
1162         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE) {
1163                 DBG_8192C("scan abort!! fwstate=0x%x\n", pmlmepriv->fw_state);
1164                 goto exit;
1165         }
1166
1167 #ifdef CONFIG_CONCURRENT_MODE
1168         if (check_buddy_fwstate(padapter,
1169                 _FW_UNDER_SURVEY|_FW_UNDER_LINKING|WIFI_UNDER_WPS) == _TRUE) {
1170                 DBG_871X("scan abort!! buddy_fwstate=0x%x\n",
1171                                 get_fwstate(&(padapter->pbuddy_adapter->mlmepriv)));
1172                 goto exit;
1173         }
1174 #endif
1175         _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1176
1177 exit:
1178         rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1179         return count;
1180 }
1181
1182 int proc_get_ap_info(struct seq_file *m, void *v)
1183 {
1184         struct net_device *dev = m->private;
1185         struct sta_info *psta;
1186         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1187         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1188         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1189         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1190         struct sta_priv *pstapriv = &padapter->stapriv;
1191
1192         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
1193         if(psta)
1194         {
1195                 int i;
1196                 struct recv_reorder_ctrl *preorder_ctrl;
1197
1198                 DBG_871X_SEL_NL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
1199                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
1200                 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);
1201                 DBG_871X_SEL_NL(m, "wireless_mode=0x%x, rtsen=%d, cts2slef=%d\n", psta->wireless_mode, psta->rtsen, psta->cts2self);
1202                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
1203 #ifdef CONFIG_80211N_HT
1204                 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);
1205                 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);
1206                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
1207                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
1208                 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);
1209 #endif //CONFIG_80211N_HT
1210 #ifdef CONFIG_80211AC_VHT
1211                 DBG_871X_SEL_NL(m, "vht_en=%d, vht_sgi_80m=%d\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
1212                 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);
1213                 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);
1214 #endif
1215
1216                 sta_rx_reorder_ctl_dump(m, psta);
1217         }
1218         else
1219         {
1220                 DBG_871X_SEL_NL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
1221         }
1222
1223         return 0;
1224 }
1225
1226 ssize_t proc_reset_trx_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1227 {
1228         struct net_device *dev = data;
1229         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1230         struct dvobj_priv *psdpriv = padapter->dvobj;
1231         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1232         char cmd[32] = {0};
1233         u8 cnt = 0;
1234
1235         if (count > sizeof(cmd)) {
1236                 rtw_warn_on(1);
1237                 return -EFAULT;
1238         }
1239
1240         if (buffer && !copy_from_user(cmd, buffer, count)) {
1241                 int num = sscanf(cmd, "%hhx", &cnt);
1242
1243                 if (0 == cnt) {
1244                         pdbgpriv->dbg_rx_ampdu_drop_count = 0;
1245                         pdbgpriv->dbg_rx_ampdu_forced_indicate_count = 0;
1246                         pdbgpriv->dbg_rx_ampdu_loss_count = 0;
1247                         pdbgpriv->dbg_rx_dup_mgt_frame_drop_count = 0;
1248                         pdbgpriv->dbg_rx_ampdu_window_shift_cnt = 0;
1249                         pdbgpriv->dbg_rx_conflic_mac_addr_cnt = 0;
1250                 }
1251         }
1252
1253         return count;
1254 }
1255
1256 int proc_get_trx_info(struct seq_file *m, void *v)
1257 {
1258         struct net_device *dev = m->private;
1259         int i;
1260         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1261         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1262         struct recv_priv  *precvpriv = &padapter->recvpriv;
1263         struct dvobj_priv *psdpriv = padapter->dvobj;
1264         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1265         struct hw_xmit *phwxmit;
1266
1267         dump_os_queue(m, padapter);
1268
1269         DBG_871X_SEL_NL(m, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d\n"
1270                 , pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt);
1271         DBG_871X_SEL_NL(m, "free_ext_xmitbuf_cnt=%d, free_xframe_ext_cnt=%d\n"
1272                 , pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt);
1273         DBG_871X_SEL_NL(m, "free_recvframe_cnt=%d\n"
1274                 , precvpriv->free_recvframe_cnt);
1275
1276         for(i = 0; i < 4; i++)
1277         {
1278                 phwxmit = pxmitpriv->hwxmits + i;
1279                 DBG_871X_SEL_NL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
1280         }
1281
1282 #ifdef CONFIG_USB_HCI
1283         DBG_871X_SEL_NL(m, "rx_urb_pending_cn=%d\n", ATOMIC_READ(&(precvpriv->rx_pending_cnt)));
1284 #endif
1285
1286         //Folowing are RX info
1287         //Counts of packets whose seq_num is less than preorder_ctrl->indicate_seq, Ex delay, retransmission, redundant packets and so on
1288         DBG_871X_SEL_NL(m,"Rx: Counts of Packets Whose Seq_Num Less Than Reorder Control Seq_Num: %llu\n",(unsigned long long)pdbgpriv->dbg_rx_ampdu_drop_count);
1289         //How many times the Rx Reorder Timer is triggered.
1290         DBG_871X_SEL_NL(m,"Rx: Reorder Time-out Trigger Counts: %llu\n",(unsigned long long)pdbgpriv->dbg_rx_ampdu_forced_indicate_count);
1291         //Total counts of packets loss
1292         DBG_871X_SEL_NL(m,"Rx: Packet Loss Counts: %llu\n",(unsigned long long)pdbgpriv->dbg_rx_ampdu_loss_count);
1293         DBG_871X_SEL_NL(m,"Rx: Duplicate Management Frame Drop Count: %llu\n",(unsigned long long)pdbgpriv->dbg_rx_dup_mgt_frame_drop_count);
1294         DBG_871X_SEL_NL(m,"Rx: AMPDU BA window shift Count: %llu\n",(unsigned long long)pdbgpriv->dbg_rx_ampdu_window_shift_cnt);
1295         /*The same mac addr counts*/
1296         DBG_871X_SEL_NL(m, "Rx: Conflict MAC Address Frames Count: %llu\n", (unsigned long long)pdbgpriv->dbg_rx_conflic_mac_addr_cnt);
1297         return 0;
1298 }
1299
1300 int proc_get_dis_pwt(struct seq_file *m, void *v)
1301 {
1302         struct net_device *dev = m->private;
1303         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1304         u8 dis_pwt = 0;
1305         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DIS_PWT, &(dis_pwt));
1306         DBG_871X_SEL_NL(m, " Tx Power training mode:%s \n",(dis_pwt==_TRUE)?"Disable":"Enable");
1307         return 0;
1308 }
1309 ssize_t proc_set_dis_pwt(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1310 {
1311         struct net_device *dev = data;
1312         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1313         char tmp[4]={0};
1314         u8 dis_pwt = 0;
1315
1316         if (count < 1)
1317                 return -EFAULT;
1318
1319         if (count > sizeof(tmp)) {
1320                 rtw_warn_on(1);
1321                 return -EFAULT;
1322         }
1323
1324         if (buffer && !copy_from_user(tmp, buffer, count)) {
1325
1326                 int num = sscanf(tmp, "%hhx", &dis_pwt);
1327                 DBG_871X("Set Tx Power training mode:%s\n", (dis_pwt == _TRUE)?"Disable":"Enable");
1328
1329                 if (num >= 1)
1330                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DIS_PWT, &(dis_pwt));
1331         }
1332
1333         return count;
1334
1335 }
1336
1337 int proc_get_rate_ctl(struct seq_file *m, void *v)
1338 {
1339         struct net_device *dev = m->private;
1340         int i;
1341         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1342         u8 data_rate = 0, sgi=0, data_fb = 0;
1343
1344         if (adapter->fix_rate != 0xff) {
1345                 data_rate = adapter->fix_rate & 0x7F;
1346                 sgi = adapter->fix_rate >>7;
1347                 data_fb = adapter->data_fb?1:0;
1348                 DBG_871X_SEL_NL(m, "FIXED %s%s%s\n"
1349                         , HDATA_RATE(data_rate)
1350                         , data_rate>DESC_RATE54M?(sgi?" SGI":" LGI"):""
1351                         , data_fb?" FB":""
1352                 );
1353                 DBG_871X_SEL_NL(m, "0x%02x %u\n", adapter->fix_rate, adapter->data_fb);
1354         } else {
1355                 DBG_871X_SEL_NL(m, "RA\n");
1356         }
1357
1358         return 0;
1359 }
1360
1361 ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1362 {
1363         struct net_device *dev = data;
1364         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1365         char tmp[32];
1366         u8 fix_rate;
1367         u8 data_fb;
1368
1369         if (count < 1)
1370                 return -EFAULT;
1371
1372         if (count > sizeof(tmp)) {
1373                 rtw_warn_on(1);
1374                 return -EFAULT;
1375         }
1376
1377         if (buffer && !copy_from_user(tmp, buffer, count)) {
1378
1379                 int num = sscanf(tmp, "%hhx %hhu", &fix_rate, &data_fb);
1380
1381                 if (num >= 1)
1382                         adapter->fix_rate = fix_rate;
1383                 if (num >= 2)
1384                         adapter->data_fb = data_fb?1:0;
1385         }
1386
1387         return count;
1388 }
1389 #ifdef DBG_RX_COUNTER_DUMP
1390 int proc_get_rx_cnt_dump(struct seq_file *m, void *v)
1391 {
1392         struct net_device *dev = m->private;
1393         int i;
1394         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1395
1396         DBG_871X_SEL_NL(m, "BIT0- Dump RX counters of DRV \n");
1397         DBG_871X_SEL_NL(m, "BIT1- Dump RX counters of MAC \n");
1398         DBG_871X_SEL_NL(m, "BIT2- Dump RX counters of PHY \n");
1399         DBG_871X_SEL_NL(m, "BIT3- Dump TRX data frame of DRV \n");
1400         DBG_871X_SEL_NL(m, "dump_rx_cnt_mode = 0x%02x \n", adapter->dump_rx_cnt_mode);
1401
1402         return 0;
1403 }
1404 ssize_t proc_set_rx_cnt_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1405 {
1406         struct net_device *dev = data;
1407         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1408         char tmp[32];
1409         u8 dump_rx_cnt_mode;
1410
1411         if (count < 1)
1412                 return -EFAULT;
1413
1414         if (count > sizeof(tmp)) {
1415                 rtw_warn_on(1);
1416                 return -EFAULT;
1417         }
1418
1419         if (buffer && !copy_from_user(tmp, buffer, count)) {
1420
1421                 int num = sscanf(tmp, "%hhx", &dump_rx_cnt_mode);
1422
1423                 rtw_dump_phy_rxcnts_preprocess(adapter,dump_rx_cnt_mode);
1424                 adapter->dump_rx_cnt_mode = dump_rx_cnt_mode;
1425
1426         }
1427
1428         return count;
1429 }
1430 #endif
1431 ssize_t proc_set_fwdl_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1432 {
1433         struct net_device *dev = data;
1434         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1435         char tmp[32];
1436         int num;
1437
1438         if (count < 1)
1439                 return -EFAULT;
1440
1441         if (count > sizeof(tmp)) {
1442                 rtw_warn_on(1);
1443                 return -EFAULT;
1444         }
1445
1446         if (buffer && !copy_from_user(tmp, buffer, count))
1447                 num = sscanf(tmp, "%hhu %hhu", &fwdl_test_chksum_fail, &fwdl_test_wintint_rdy_fail);
1448
1449         return count;
1450 }
1451
1452 ssize_t proc_set_del_rx_ampdu_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1453 {
1454         struct net_device *dev = data;
1455         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1456         char tmp[32];
1457         int num;
1458
1459         if (count < 1)
1460                 return -EFAULT;
1461
1462         if (count > sizeof(tmp)) {
1463                 rtw_warn_on(1);
1464                 return -EFAULT;
1465         }
1466
1467         if (buffer && !copy_from_user(tmp, buffer, count))
1468                 num = sscanf(tmp, "%hhu", &del_rx_ampdu_test_no_tx_fail);
1469
1470         return count;
1471 }
1472
1473 #ifdef CONFIG_DFS_MASTER
1474 int proc_get_dfs_master_test_case(struct seq_file *m, void *v)
1475 {
1476         struct net_device *dev = m->private;
1477         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1478         struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
1479
1480         DBG_871X_SEL_NL(m, "%-24s %-19s\n", "radar_detect_trigger_non", "choose_dfs_ch_first");
1481         DBG_871X_SEL_NL(m, "%24hhu %19hhu\n"
1482                 , rfctl->dbg_dfs_master_radar_detect_trigger_non
1483                 , rfctl->dbg_dfs_master_choose_dfs_ch_first
1484         );
1485
1486         return 0;
1487 }
1488
1489 ssize_t proc_set_dfs_master_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1490 {
1491         struct net_device *dev = data;
1492         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1493         struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
1494         char tmp[32];
1495         u8 radar_detect_trigger_non;
1496         u8 choose_dfs_ch_first;
1497
1498         if (count < 1)
1499                 return -EFAULT;
1500
1501         if (count > sizeof(tmp)) {
1502                 rtw_warn_on(1);
1503                 return -EFAULT;
1504         }
1505
1506         if (buffer && !copy_from_user(tmp, buffer, count)) {
1507                 int num = sscanf(tmp, "%hhu %hhu", &radar_detect_trigger_non, &choose_dfs_ch_first);
1508
1509                 if (num >= 1)
1510                         rfctl->dbg_dfs_master_radar_detect_trigger_non = radar_detect_trigger_non;
1511                 if (num >= 2)
1512                         rfctl->dbg_dfs_master_choose_dfs_ch_first = choose_dfs_ch_first;
1513         }
1514
1515         return count;
1516 }
1517 #endif /* CONFIG_DFS_MASTER */
1518
1519 ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1520 {
1521         struct net_device *dev = data;
1522         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1523         char tmp[32];
1524         int num;
1525
1526         if (count < 1)
1527                 return -EFAULT;
1528
1529         if (count > sizeof(tmp)) {
1530                 rtw_warn_on(1);
1531                 return -EFAULT;
1532         }
1533
1534         if (buffer && !copy_from_user(tmp, buffer, count))
1535                 num = sscanf(tmp, "%u", &g_wait_hiq_empty_ms);
1536
1537         return count;
1538 }
1539
1540 int proc_get_suspend_resume_info(struct seq_file *m, void *v)
1541 {
1542         struct net_device *dev = m->private;
1543         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1544         struct dvobj_priv *dvobj = padapter->dvobj;
1545         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
1546
1547         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
1548         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
1549         DBG_871X_SEL_NL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n",pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
1550         DBG_871X_SEL_NL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
1551         DBG_871X_SEL_NL(m, "dbg_sdio_init_error_cnt=%d\n",pdbgpriv->dbg_sdio_init_error_cnt);
1552         DBG_871X_SEL_NL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
1553         DBG_871X_SEL_NL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
1554         DBG_871X_SEL_NL(m, "dbg_suspend_cnt=%d\n",pdbgpriv->dbg_suspend_cnt);
1555         DBG_871X_SEL_NL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
1556         DBG_871X_SEL_NL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
1557         DBG_871X_SEL_NL(m, "dbg_deinit_fail_cnt=%d\n",pdbgpriv->dbg_deinit_fail_cnt);
1558         DBG_871X_SEL_NL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
1559         DBG_871X_SEL_NL(m, "dbg_ps_insuspend_cnt=%d\n",pdbgpriv->dbg_ps_insuspend_cnt);
1560         DBG_871X_SEL_NL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
1561         DBG_871X_SEL_NL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
1562         DBG_871X_SEL_NL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
1563         DBG_871X_SEL_NL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
1564         DBG_871X_SEL_NL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
1565         DBG_871X_SEL_NL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
1566         DBG_871X_SEL_NL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
1567         DBG_871X_SEL_NL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
1568         DBG_871X_SEL_NL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
1569         DBG_871X_SEL_NL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
1570         DBG_871X_SEL_NL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
1571         DBG_871X_SEL_NL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
1572         DBG_871X_SEL_NL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
1573         DBG_871X_SEL_NL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
1574         DBG_871X_SEL_NL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
1575
1576         return 0;
1577 }
1578
1579 #ifdef CONFIG_DBG_COUNTER
1580
1581 int proc_get_rx_logs(struct seq_file *m, void *v)
1582 {
1583         struct net_device *dev = m->private;
1584         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1585         struct rx_logs *rx_logs = &padapter->rx_logs;
1586
1587         DBG_871X_SEL_NL(m,
1588                 "intf_rx=%d\n"
1589                 "intf_rx_err_recvframe=%d\n"
1590                 "intf_rx_err_skb=%d\n"
1591                 "intf_rx_report=%d\n"
1592                 "core_rx=%d\n"
1593                 "core_rx_pre=%d\n"
1594                 "core_rx_pre_ver_err=%d\n"
1595                 "core_rx_pre_mgmt=%d\n"
1596                 "core_rx_pre_mgmt_err_80211w=%d\n"
1597                 "core_rx_pre_mgmt_err=%d\n"
1598                 "core_rx_pre_ctrl=%d\n"
1599                 "core_rx_pre_ctrl_err=%d\n"
1600                 "core_rx_pre_data=%d\n"
1601                 "core_rx_pre_data_wapi_seq_err=%d\n"
1602                 "core_rx_pre_data_wapi_key_err=%d\n"
1603                 "core_rx_pre_data_handled=%d\n"
1604                 "core_rx_pre_data_err=%d\n"
1605                 "core_rx_pre_data_unknown=%d\n"
1606                 "core_rx_pre_unknown=%d\n"
1607                 "core_rx_enqueue=%d\n"
1608                 "core_rx_dequeue=%d\n"
1609                 "core_rx_post=%d\n"
1610                 "core_rx_post_decrypt=%d\n"
1611                 "core_rx_post_decrypt_wep=%d\n"
1612                 "core_rx_post_decrypt_tkip=%d\n"
1613                 "core_rx_post_decrypt_aes=%d\n"
1614                 "core_rx_post_decrypt_wapi=%d\n"
1615                 "core_rx_post_decrypt_hw=%d\n"
1616                 "core_rx_post_decrypt_unknown=%d\n"
1617                 "core_rx_post_decrypt_err=%d\n"
1618                 "core_rx_post_defrag_err=%d\n"
1619                 "core_rx_post_portctrl_err=%d\n"
1620                 "core_rx_post_indicate=%d\n"
1621                 "core_rx_post_indicate_in_oder=%d\n"
1622                 "core_rx_post_indicate_reoder=%d\n"
1623                 "core_rx_post_indicate_err=%d\n"
1624                 "os_indicate=%d\n"
1625                 "os_indicate_ap_mcast=%d\n"
1626                 "os_indicate_ap_forward=%d\n"
1627                 "os_indicate_ap_self=%d\n"
1628                 "os_indicate_err=%d\n"
1629                 "os_netif_ok=%d\n"
1630                 "os_netif_err=%d\n",
1631                 rx_logs->intf_rx,
1632                 rx_logs->intf_rx_err_recvframe,
1633                 rx_logs->intf_rx_err_skb,
1634                 rx_logs->intf_rx_report,
1635                 rx_logs->core_rx,
1636                 rx_logs->core_rx_pre,
1637                 rx_logs->core_rx_pre_ver_err,
1638                 rx_logs->core_rx_pre_mgmt,
1639                 rx_logs->core_rx_pre_mgmt_err_80211w,
1640                 rx_logs->core_rx_pre_mgmt_err,
1641                 rx_logs->core_rx_pre_ctrl,
1642                 rx_logs->core_rx_pre_ctrl_err,
1643                 rx_logs->core_rx_pre_data,
1644                 rx_logs->core_rx_pre_data_wapi_seq_err,
1645                 rx_logs->core_rx_pre_data_wapi_key_err,
1646                 rx_logs->core_rx_pre_data_handled,
1647                 rx_logs->core_rx_pre_data_err,
1648                 rx_logs->core_rx_pre_data_unknown,
1649                 rx_logs->core_rx_pre_unknown,
1650                 rx_logs->core_rx_enqueue,
1651                 rx_logs->core_rx_dequeue,
1652                 rx_logs->core_rx_post,
1653                 rx_logs->core_rx_post_decrypt,
1654                 rx_logs->core_rx_post_decrypt_wep,
1655                 rx_logs->core_rx_post_decrypt_tkip,
1656                 rx_logs->core_rx_post_decrypt_aes,
1657                 rx_logs->core_rx_post_decrypt_wapi,
1658                 rx_logs->core_rx_post_decrypt_hw,
1659                 rx_logs->core_rx_post_decrypt_unknown,
1660                 rx_logs->core_rx_post_decrypt_err,
1661                 rx_logs->core_rx_post_defrag_err,
1662                 rx_logs->core_rx_post_portctrl_err,
1663                 rx_logs->core_rx_post_indicate,
1664                 rx_logs->core_rx_post_indicate_in_oder,
1665                 rx_logs->core_rx_post_indicate_reoder,
1666                 rx_logs->core_rx_post_indicate_err,
1667                 rx_logs->os_indicate,
1668                 rx_logs->os_indicate_ap_mcast,
1669                 rx_logs->os_indicate_ap_forward,
1670                 rx_logs->os_indicate_ap_self,
1671                 rx_logs->os_indicate_err,
1672                 rx_logs->os_netif_ok,
1673                 rx_logs->os_netif_err
1674         );
1675
1676         return 0;
1677 }
1678
1679 int proc_get_tx_logs(struct seq_file *m, void *v)
1680 {
1681         struct net_device *dev = m->private;
1682         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1683         struct tx_logs *tx_logs = &padapter->tx_logs;
1684
1685         DBG_871X_SEL_NL(m,
1686                 "os_tx=%d\n"
1687                 "os_tx_err_up=%d\n"
1688                 "os_tx_err_xmit=%d\n"
1689                 "os_tx_m2u=%d\n"
1690                 "os_tx_m2u_ignore_fw_linked=%d\n"
1691                 "os_tx_m2u_ignore_self=%d\n"
1692                 "os_tx_m2u_entry=%d\n"
1693                 "os_tx_m2u_entry_err_xmit=%d\n"
1694                 "os_tx_m2u_entry_err_skb=%d\n"
1695                 "os_tx_m2u_stop=%d\n"
1696                 "core_tx=%d\n"
1697                 "core_tx_err_pxmitframe=%d\n"
1698                 "core_tx_err_brtx=%d\n"
1699                 "core_tx_upd_attrib=%d\n"
1700                 "core_tx_upd_attrib_adhoc=%d\n"
1701                 "core_tx_upd_attrib_sta=%d\n"
1702                 "core_tx_upd_attrib_ap=%d\n"
1703                 "core_tx_upd_attrib_unknown=%d\n"
1704                 "core_tx_upd_attrib_dhcp=%d\n"
1705                 "core_tx_upd_attrib_icmp=%d\n"
1706                 "core_tx_upd_attrib_active=%d\n"
1707                 "core_tx_upd_attrib_err_ucast_sta=%d\n"
1708                 "core_tx_upd_attrib_err_ucast_ap_link=%d\n"
1709                 "core_tx_upd_attrib_err_sta=%d\n"
1710                 "core_tx_upd_attrib_err_link=%d\n"
1711                 "core_tx_upd_attrib_err_sec=%d\n"
1712                 "core_tx_ap_enqueue_warn_fwstate=%d\n"
1713                 "core_tx_ap_enqueue_warn_sta=%d\n"
1714                 "core_tx_ap_enqueue_warn_nosta=%d\n"
1715                 "core_tx_ap_enqueue_warn_link=%d\n"
1716                 "core_tx_ap_enqueue_warn_trigger=%d\n"
1717                 "core_tx_ap_enqueue_mcast=%d\n"
1718                 "core_tx_ap_enqueue_ucast=%d\n"
1719                 "core_tx_ap_enqueue=%d\n"
1720                 "intf_tx=%d\n"
1721                 "intf_tx_pending_ac=%d\n"
1722                 "intf_tx_pending_fw_under_survey=%d\n"
1723                 "intf_tx_pending_fw_under_linking=%d\n"
1724                 "intf_tx_pending_xmitbuf=%d\n"
1725                 "intf_tx_enqueue=%d\n"
1726                 "core_tx_enqueue=%d\n"
1727                 "core_tx_enqueue_class=%d\n"
1728                 "core_tx_enqueue_class_err_sta=%d\n"
1729                 "core_tx_enqueue_class_err_nosta=%d\n"
1730                 "core_tx_enqueue_class_err_fwlink=%d\n"
1731                 "intf_tx_direct=%d\n"
1732                 "intf_tx_direct_err_coalesce=%d\n"
1733                 "intf_tx_dequeue=%d\n"
1734                 "intf_tx_dequeue_err_coalesce=%d\n"
1735                 "intf_tx_dump_xframe=%d\n"
1736                 "intf_tx_dump_xframe_err_txdesc=%d\n"
1737                 "intf_tx_dump_xframe_err_port=%d\n",
1738                 tx_logs->os_tx,
1739                 tx_logs->os_tx_err_up,
1740                 tx_logs->os_tx_err_xmit,
1741                 tx_logs->os_tx_m2u,
1742                 tx_logs->os_tx_m2u_ignore_fw_linked,
1743                 tx_logs->os_tx_m2u_ignore_self,
1744                 tx_logs->os_tx_m2u_entry,
1745                 tx_logs->os_tx_m2u_entry_err_xmit,
1746                 tx_logs->os_tx_m2u_entry_err_skb,
1747                 tx_logs->os_tx_m2u_stop,
1748                 tx_logs->core_tx,
1749                 tx_logs->core_tx_err_pxmitframe,
1750                 tx_logs->core_tx_err_brtx,
1751                 tx_logs->core_tx_upd_attrib,
1752                 tx_logs->core_tx_upd_attrib_adhoc,
1753                 tx_logs->core_tx_upd_attrib_sta,
1754                 tx_logs->core_tx_upd_attrib_ap,
1755                 tx_logs->core_tx_upd_attrib_unknown,
1756                 tx_logs->core_tx_upd_attrib_dhcp,
1757                 tx_logs->core_tx_upd_attrib_icmp,
1758                 tx_logs->core_tx_upd_attrib_active,
1759                 tx_logs->core_tx_upd_attrib_err_ucast_sta,
1760                 tx_logs->core_tx_upd_attrib_err_ucast_ap_link,
1761                 tx_logs->core_tx_upd_attrib_err_sta,
1762                 tx_logs->core_tx_upd_attrib_err_link,
1763                 tx_logs->core_tx_upd_attrib_err_sec,
1764                 tx_logs->core_tx_ap_enqueue_warn_fwstate,
1765                 tx_logs->core_tx_ap_enqueue_warn_sta,
1766                 tx_logs->core_tx_ap_enqueue_warn_nosta,
1767                 tx_logs->core_tx_ap_enqueue_warn_link,
1768                 tx_logs->core_tx_ap_enqueue_warn_trigger,
1769                 tx_logs->core_tx_ap_enqueue_mcast,
1770                 tx_logs->core_tx_ap_enqueue_ucast,
1771                 tx_logs->core_tx_ap_enqueue,
1772                 tx_logs->intf_tx,
1773                 tx_logs->intf_tx_pending_ac,
1774                 tx_logs->intf_tx_pending_fw_under_survey,
1775                 tx_logs->intf_tx_pending_fw_under_linking,
1776                 tx_logs->intf_tx_pending_xmitbuf,
1777                 tx_logs->intf_tx_enqueue,
1778                 tx_logs->core_tx_enqueue,
1779                 tx_logs->core_tx_enqueue_class,
1780                 tx_logs->core_tx_enqueue_class_err_sta,
1781                 tx_logs->core_tx_enqueue_class_err_nosta,
1782                 tx_logs->core_tx_enqueue_class_err_fwlink,
1783                 tx_logs->intf_tx_direct,
1784                 tx_logs->intf_tx_direct_err_coalesce,
1785                 tx_logs->intf_tx_dequeue,
1786                 tx_logs->intf_tx_dequeue_err_coalesce,
1787                 tx_logs->intf_tx_dump_xframe,
1788                 tx_logs->intf_tx_dump_xframe_err_txdesc,
1789                 tx_logs->intf_tx_dump_xframe_err_port
1790         );
1791
1792         return 0;
1793 }
1794
1795 int proc_get_int_logs(struct seq_file *m, void *v)
1796 {
1797         struct net_device *dev = m->private;
1798         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1799
1800         DBG_871X_SEL_NL(m,
1801                 "all=%d\n"
1802                 "err=%d\n"
1803                 "tbdok=%d\n"
1804                 "tbder=%d\n"
1805                 "bcnderr=%d\n"
1806                 "bcndma=%d\n"
1807                 "bcndma_e=%d\n"
1808                 "rx=%d\n"
1809                 "rx_rdu=%d\n"
1810                 "rx_fovw=%d\n"
1811                 "txfovw=%d\n"
1812                 "mgntok=%d\n"
1813                 "highdok=%d\n"
1814                 "bkdok=%d\n"
1815                 "bedok=%d\n"
1816                 "vidok=%d\n"
1817                 "vodok=%d\n",
1818                 padapter->int_logs.all,
1819                 padapter->int_logs.err,
1820                 padapter->int_logs.tbdok,
1821                 padapter->int_logs.tbder,
1822                 padapter->int_logs.bcnderr,
1823                 padapter->int_logs.bcndma,
1824                 padapter->int_logs.bcndma_e,
1825                 padapter->int_logs.rx,
1826                 padapter->int_logs.rx_rdu,
1827                 padapter->int_logs.rx_fovw,
1828                 padapter->int_logs.txfovw,
1829                 padapter->int_logs.mgntok,
1830                 padapter->int_logs.highdok,
1831                 padapter->int_logs.bkdok,
1832                 padapter->int_logs.bedok,
1833                 padapter->int_logs.vidok,
1834                 padapter->int_logs.vodok
1835         );
1836
1837         return 0;
1838 }
1839
1840 #endif // CONFIG_DBG_COUNTER
1841
1842 int proc_get_hw_status(struct seq_file *m, void *v)
1843 {
1844         struct net_device *dev = m->private;
1845         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1846         struct dvobj_priv *dvobj = padapter->dvobj;
1847         struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
1848
1849         if (pdbgpriv->dbg_rx_fifo_last_overflow == 1
1850                 && pdbgpriv->dbg_rx_fifo_curr_overflow == 1
1851                 && pdbgpriv->dbg_rx_fifo_diff_overflow == 1
1852         ) {
1853                 DBG_871X_SEL_NL(m, "RX FIFO full count: no implementation\n");
1854         } else {
1855                 DBG_871X_SEL_NL(m, "RX FIFO full count: last_time=%llu, current_time=%llu, differential=%llu\n"
1856                         , pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
1857         }
1858
1859         return 0;
1860 }
1861 int proc_get_trx_info_debug(struct seq_file *m, void *v)
1862 {
1863         struct net_device *dev = m->private;
1864         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1865         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
1866
1867         int i;
1868
1869
1870         /*============  tx info ============    */
1871         rtw_hal_get_def_var(padapter, HW_DEF_RA_INFO_DUMP, m);
1872
1873         /*============  rx info ============    */
1874         rtw_hal_set_odm_var(padapter, HAL_ODM_RX_INFO_DUMP, m, _FALSE);
1875
1876
1877 return 0;
1878 }
1879
1880 int proc_get_rx_signal(struct seq_file *m, void *v)
1881 {
1882         struct net_device *dev = m->private;
1883         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1884         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1885
1886         DBG_871X_SEL_NL(m, "rssi:%d\n", padapter->recvpriv.rssi);
1887         //DBG_871X_SEL_NL(m, "rxpwdb:%d\n", padapter->recvpriv.rxpwdb);
1888         DBG_871X_SEL_NL(m, "signal_strength:%u\n", padapter->recvpriv.signal_strength);
1889         DBG_871X_SEL_NL(m, "signal_qual:%u\n", padapter->recvpriv.signal_qual);
1890
1891         rtw_get_noise(padapter);
1892         DBG_871X_SEL_NL(m, "noise:%d\n", padapter->recvpriv.noise);
1893         #ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
1894         rtw_odm_get_perpkt_rssi(m,padapter);
1895         rtw_get_raw_rssi_info(m,padapter);
1896         #endif
1897         return 0;
1898 }
1899
1900 ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1901 {
1902         struct net_device *dev = data;
1903         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1904         char tmp[32];
1905         u32 is_signal_dbg, signal_strength;
1906
1907         if (count < 1)
1908                 return -EFAULT;
1909
1910         if (count > sizeof(tmp)) {
1911                 rtw_warn_on(1);
1912                 return -EFAULT;
1913         }
1914
1915         if (buffer && !copy_from_user(tmp, buffer, count)) {
1916
1917                 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
1918
1919                 is_signal_dbg = is_signal_dbg==0?0:1;
1920
1921                 if(is_signal_dbg && num!=2)
1922                         return count;
1923
1924                 signal_strength = signal_strength>100?100:signal_strength;
1925
1926                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
1927                 padapter->recvpriv.signal_strength_dbg=signal_strength;
1928
1929                 if(is_signal_dbg)
1930                         DBG_871X("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
1931                 else
1932                         DBG_871X("set %s\n", "HW_SIGNAL_STRENGTH");
1933
1934         }
1935
1936         return count;
1937
1938 }
1939 #ifdef CONFIG_80211N_HT
1940
1941 int proc_get_ht_enable(struct seq_file *m, void *v)
1942 {
1943         struct net_device *dev = m->private;
1944         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1945         struct registry_priv    *pregpriv = &padapter->registrypriv;
1946
1947         if(pregpriv)
1948                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ht_enable);
1949
1950         return 0;
1951 }
1952
1953 ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1954 {
1955         struct net_device *dev = data;
1956         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1957         struct registry_priv    *pregpriv = &padapter->registrypriv;
1958         char tmp[32];
1959         u32 mode;
1960
1961         if (count < 1)
1962                 return -EFAULT;
1963
1964         if (count > sizeof(tmp)) {
1965                 rtw_warn_on(1);
1966                 return -EFAULT;
1967         }
1968
1969         if (buffer && !copy_from_user(tmp, buffer, count)) {
1970
1971                 int num = sscanf(tmp, "%d ", &mode);
1972
1973                 if( pregpriv && mode < 2 )
1974                 {
1975                         pregpriv->ht_enable= mode;
1976                         DBG_871X("ht_enable=%d\n", pregpriv->ht_enable);
1977                 }
1978         }
1979
1980         return count;
1981
1982 }
1983
1984 int proc_get_bw_mode(struct seq_file *m, void *v)
1985 {
1986         struct net_device *dev = m->private;
1987         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1988         struct registry_priv    *pregpriv = &padapter->registrypriv;
1989
1990         if(pregpriv)
1991                 DBG_871X_SEL_NL(m, "0x%02x\n", pregpriv->bw_mode);
1992
1993         return 0;
1994 }
1995
1996 ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1997 {
1998         struct net_device *dev = data;
1999         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2000         struct registry_priv    *pregpriv = &padapter->registrypriv;
2001         char tmp[32];
2002         u32 mode;
2003
2004         if (count < 1)
2005                 return -EFAULT;
2006
2007         if (count > sizeof(tmp)) {
2008                 rtw_warn_on(1);
2009                 return -EFAULT;
2010         }
2011
2012         if (buffer && !copy_from_user(tmp, buffer, count)) {
2013
2014                 int num = sscanf(tmp, "%d ", &mode);
2015
2016                 if( pregpriv &&  mode < 2 )
2017                 {
2018
2019                         pregpriv->bw_mode = mode;
2020                         printk("bw_mode=%d\n", mode);
2021
2022                 }
2023         }
2024
2025         return count;
2026
2027 }
2028
2029 int proc_get_ampdu_enable(struct seq_file *m, void *v)
2030 {
2031         struct net_device *dev = m->private;
2032         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2033         struct registry_priv    *pregpriv = &padapter->registrypriv;
2034
2035         if(pregpriv)
2036                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->ampdu_enable);
2037
2038         return 0;
2039 }
2040
2041 ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2042 {
2043         struct net_device *dev = data;
2044         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2045         struct registry_priv    *pregpriv = &padapter->registrypriv;
2046         char tmp[32];
2047         u32 mode;
2048
2049         if (count < 1)
2050                 return -EFAULT;
2051
2052         if (count > sizeof(tmp)) {
2053                 rtw_warn_on(1);
2054                 return -EFAULT;
2055         }
2056
2057         if (buffer && !copy_from_user(tmp, buffer, count)) {
2058
2059                 int num = sscanf(tmp, "%d ", &mode);
2060
2061                 if( pregpriv && mode < 3 )
2062                 {
2063                         pregpriv->ampdu_enable= mode;
2064                         printk("ampdu_enable=%d\n", mode);
2065                 }
2066
2067         }
2068
2069         return count;
2070
2071 }
2072
2073 int proc_get_mac_rptbuf(struct seq_file *m, void *v)
2074 {
2075         struct net_device *dev = m->private;
2076         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2077         u16 i;
2078         u16 mac_id;
2079         u32 shcut_addr = 0;
2080         u32 read_addr = 0;
2081 #ifdef CONFIG_RTL8814A
2082         DBG_871X_SEL_NL(m, "TX ShortCut:\n");
2083         for (mac_id = 0; mac_id < 64; mac_id++) {
2084                 rtw_write16(padapter, 0x140, 0x662 | ((mac_id & BIT5)>>5));
2085                 shcut_addr = 0x8000;
2086                 shcut_addr = shcut_addr | ((mac_id&0x1f) << 7);
2087                 DBG_871X_SEL_NL(m, "mac_id=%d, 0x140=%x =>\n", mac_id, 0x662 | ((mac_id & BIT5)>>5));
2088                 for (i = 0; i < 30; i++) {
2089                         read_addr = 0;
2090                         read_addr = shcut_addr | (i<<2);
2091                         DBG_871X_SEL_NL(m, "i=%02d: MAC_%04x= %08x ", i, read_addr, rtw_read32(padapter, read_addr));
2092                         if (!((i+1) % 4))
2093                                 DBG_871X_SEL_NL(m, "\n");
2094                         if (i == 29)
2095                                 DBG_871X_SEL_NL(m, "\n");
2096                 }
2097         }
2098 #endif /* CONFIG_RTL8814A */
2099         return 0;
2100 }
2101
2102
2103 int proc_get_rx_ampdu(struct seq_file *m, void *v)
2104 {
2105         struct net_device *dev = m->private;
2106         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2107
2108         DBG_871X_SEL(m, "accept: ");
2109         if (padapter->fix_rx_ampdu_accept == RX_AMPDU_ACCEPT_INVALID)
2110                 DBG_871X_SEL_NL(m, "%u%s\n", rtw_rx_ampdu_is_accept(padapter), "(auto)");
2111         else
2112                 DBG_871X_SEL_NL(m, "%u%s\n", padapter->fix_rx_ampdu_accept, "(fixed)");
2113
2114         DBG_871X_SEL(m, "size: ");
2115         if (padapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID)
2116                 DBG_871X_SEL_NL(m, "%u%s\n", rtw_rx_ampdu_size(padapter), "(auto)");
2117         else
2118                 DBG_871X_SEL_NL(m, "%u%s\n", padapter->fix_rx_ampdu_size, "(fixed)");
2119
2120         DBG_871X_SEL_NL(m, "%19s %17s\n", "fix_rx_ampdu_accept", "fix_rx_ampdu_size");
2121
2122         DBG_871X_SEL(m, "%-19d %-17u\n"
2123                 , padapter->fix_rx_ampdu_accept
2124                 , padapter->fix_rx_ampdu_size);
2125
2126         return 0;
2127 }
2128
2129 ssize_t proc_set_rx_ampdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2130 {
2131         struct net_device *dev = data;
2132         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2133         struct registry_priv    *pregpriv = &padapter->registrypriv;
2134         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
2135         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
2136         char tmp[32];
2137         u8 accept;
2138         u8 size;
2139
2140         if (count < 1)
2141                 return -EFAULT;
2142
2143         if (count > sizeof(tmp)) {
2144                 rtw_warn_on(1);
2145                 return -EFAULT;
2146         }
2147
2148         if (buffer && !copy_from_user(tmp, buffer, count)) {
2149
2150                 int num = sscanf(tmp, "%hhu %hhu", &accept, &size);
2151
2152                 if (num >= 1)
2153                         rtw_rx_ampdu_set_accept(padapter, accept, RX_AMPDU_DRV_FIXED);
2154                 if (num >= 2)
2155                         rtw_rx_ampdu_set_size(padapter, size, RX_AMPDU_DRV_FIXED);
2156
2157                 rtw_rx_ampdu_apply(padapter);
2158         }
2159
2160 exit:
2161         return count;
2162 }
2163 int proc_get_rx_ampdu_factor(struct seq_file *m, void *v)
2164 {
2165         struct net_device *dev = m->private;
2166         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2167
2168
2169         if(padapter)
2170         {
2171                 DBG_871X_SEL_NL(m,"rx ampdu factor = %x\n",padapter->driver_rx_ampdu_factor);
2172         }
2173
2174         return 0;
2175 }
2176
2177 ssize_t proc_set_rx_ampdu_factor(struct file *file, const char __user *buffer
2178                                  , size_t count, loff_t *pos, void *data)
2179 {
2180         struct net_device *dev = data;
2181         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2182         char tmp[32];
2183         u32 factor;
2184
2185         if (count < 1)
2186                 return -EFAULT;
2187
2188         if (count > sizeof(tmp)) {
2189                 rtw_warn_on(1);
2190                 return -EFAULT;
2191         }
2192
2193         if (buffer && !copy_from_user(tmp, buffer, count)) {
2194
2195                 int num = sscanf(tmp, "%d ", &factor);
2196
2197                 if( padapter && (num == 1) )
2198                 {
2199                         DBG_871X("padapter->driver_rx_ampdu_factor = %x\n", factor);
2200
2201                         if(factor  > 0x03)
2202                                 padapter->driver_rx_ampdu_factor = 0xFF;
2203                         else
2204                                 padapter->driver_rx_ampdu_factor = factor;
2205                 }
2206         }
2207
2208         return count;
2209 }
2210
2211 int proc_get_rx_ampdu_density(struct seq_file *m, void *v)
2212 {
2213         struct net_device *dev = m->private;
2214         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2215
2216
2217         if(padapter)
2218         {
2219                 DBG_871X_SEL_NL(m,"rx ampdu densityg = %x\n",padapter->driver_rx_ampdu_spacing);
2220         }
2221
2222         return 0;
2223 }
2224
2225 ssize_t proc_set_rx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2226 {
2227         struct net_device *dev = data;
2228         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2229         char tmp[32];
2230         u32 density;
2231
2232         if (count < 1)
2233                 return -EFAULT;
2234
2235         if (count > sizeof(tmp)) {
2236                 rtw_warn_on(1);
2237                 return -EFAULT;
2238         }
2239
2240         if (buffer && !copy_from_user(tmp, buffer, count)) {
2241
2242                 int num = sscanf(tmp, "%d ", &density);
2243
2244                 if( padapter && (num == 1) )
2245                 {
2246                         DBG_871X("padapter->driver_rx_ampdu_spacing = %x\n", density);
2247
2248                         if(density > 0x07)
2249                                 padapter->driver_rx_ampdu_spacing = 0xFF;
2250                         else
2251                                 padapter->driver_rx_ampdu_spacing = density;
2252                 }
2253         }
2254
2255         return count;
2256 }
2257
2258 int proc_get_tx_ampdu_density(struct seq_file *m, void *v)
2259 {
2260         struct net_device *dev = m->private;
2261         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2262
2263
2264         if(padapter)
2265         {
2266                 DBG_871X_SEL_NL(m,"tx ampdu density = %x\n",padapter->driver_ampdu_spacing);
2267         }
2268
2269         return 0;
2270 }
2271
2272 ssize_t proc_set_tx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2273 {
2274         struct net_device *dev = data;
2275         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2276         char tmp[32];
2277         u32 density;
2278
2279         if (count < 1)
2280                 return -EFAULT;
2281
2282         if (count > sizeof(tmp)) {
2283                 rtw_warn_on(1);
2284                 return -EFAULT;
2285         }
2286
2287         if (buffer && !copy_from_user(tmp, buffer, count)) {
2288
2289                 int num = sscanf(tmp, "%d ", &density);
2290
2291                 if( padapter && (num == 1) )
2292                 {
2293                         DBG_871X("padapter->driver_ampdu_spacing = %x\n", density);
2294
2295                         if(density > 0x07)
2296                                 padapter->driver_ampdu_spacing = 0xFF;
2297                         else
2298                                 padapter->driver_ampdu_spacing = density;
2299                 }
2300         }
2301
2302         return count;
2303 }
2304 #endif //CONFIG_80211N_HT
2305
2306 int proc_get_en_fwps(struct seq_file *m, void *v)
2307 {
2308         struct net_device *dev = m->private;
2309         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2310         struct registry_priv    *pregpriv = &padapter->registrypriv;
2311         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
2312         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
2313
2314         if(pregpriv)
2315                 DBG_871X_SEL_NL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
2316                         , pregpriv->check_fw_ps);
2317
2318         return 0;
2319 }
2320
2321 ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2322 {
2323         struct net_device *dev = data;
2324         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2325         struct registry_priv    *pregpriv = &padapter->registrypriv;
2326         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
2327         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
2328         char tmp[32];
2329         u32 mode;
2330
2331         if (count < 1)
2332                 return -EFAULT;
2333
2334         if (count > sizeof(tmp)) {
2335                 rtw_warn_on(1);
2336                 return -EFAULT;
2337         }
2338
2339         if (buffer && !copy_from_user(tmp, buffer, count)) {
2340
2341                 int num = sscanf(tmp, "%d ", &mode);
2342
2343                 if( pregpriv &&  mode < 2 )
2344                 {
2345                         pregpriv->check_fw_ps = mode;
2346                         DBG_871X("pregpriv->check_fw_ps=%d \n",pregpriv->check_fw_ps);
2347                 }
2348
2349         }
2350
2351         return count;
2352 }
2353
2354 /*
2355 int proc_get_two_path_rssi(struct seq_file *m, void *v)
2356 {
2357         struct net_device *dev = m->private;
2358         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2359
2360         if(padapter)
2361                 DBG_871X_SEL_NL(m, "%d %d\n",
2362                         padapter->recvpriv.RxRssi[0], padapter->recvpriv.RxRssi[1]);
2363
2364         return 0;
2365 }
2366 */
2367 #ifdef CONFIG_80211N_HT
2368 int proc_get_rx_stbc(struct seq_file *m, void *v)
2369 {
2370         struct net_device *dev = m->private;
2371         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2372         struct registry_priv    *pregpriv = &padapter->registrypriv;
2373
2374         if(pregpriv)
2375                 DBG_871X_SEL_NL(m, "%d\n", pregpriv->rx_stbc);
2376
2377         return 0;
2378 }
2379
2380 ssize_t proc_set_rx_stbc(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2381 {
2382         struct net_device *dev = data;
2383         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2384         struct registry_priv    *pregpriv = &padapter->registrypriv;
2385         char tmp[32];
2386         u32 mode;
2387
2388         if (count < 1)
2389                 return -EFAULT;
2390
2391         if (count > sizeof(tmp)) {
2392                 rtw_warn_on(1);
2393                 return -EFAULT;
2394         }
2395
2396         if (buffer && !copy_from_user(tmp, buffer, count)) {
2397
2398                 int num = sscanf(tmp, "%d ", &mode);
2399
2400                 if( pregpriv && (mode == 0 || mode == 1|| mode == 2|| mode == 3))
2401                 {
2402                         pregpriv->rx_stbc= mode;
2403                         printk("rx_stbc=%d\n", mode);
2404                 }
2405         }
2406
2407         return count;
2408
2409 }
2410 #endif //CONFIG_80211N_HT
2411
2412 /*int proc_get_rssi_disp(struct seq_file *m, void *v)
2413 {
2414         struct net_device *dev = m->private;
2415         return 0;
2416 }
2417 */
2418
2419 /*ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2420 {
2421         struct net_device *dev = data;
2422         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2423         char tmp[32];
2424         u32 enable=0;
2425
2426         if (count < 1)
2427         {
2428                 DBG_8192C("argument size is less than 1\n");
2429                 return -EFAULT;
2430         }
2431
2432         if (count > sizeof(tmp)) {
2433                 rtw_warn_on(1);
2434                 return -EFAULT;
2435         }
2436
2437         if (buffer && !copy_from_user(tmp, buffer, count)) {
2438
2439                 int num = sscanf(tmp, "%x", &enable);
2440
2441                 if (num !=  1) {
2442                         DBG_8192C("invalid set_rssi_disp parameter!\n");
2443                         return count;
2444                 }
2445
2446                 if(enable)
2447                 {
2448                         DBG_8192C("Linked info Function Enable\n");
2449                         padapter->bLinkInfoDump = enable ;
2450                 }
2451                 else
2452                 {
2453                         DBG_8192C("Linked info Function Disable\n");
2454                         padapter->bLinkInfoDump = 0 ;
2455                 }
2456
2457         }
2458
2459         return count;
2460
2461 }
2462
2463 */
2464 #ifdef CONFIG_AP_MODE
2465
2466 int proc_get_all_sta_info(struct seq_file *m, void *v)
2467 {
2468         struct net_device *dev = m->private;
2469         _irqL irqL;
2470         struct sta_info *psta;
2471         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2472         struct sta_priv *pstapriv = &padapter->stapriv;
2473         int i;
2474         _list   *plist, *phead;
2475
2476         DBG_871X_SEL_NL(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
2477
2478         _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
2479
2480         for(i=0; i< NUM_STA; i++)
2481         {
2482                 phead = &(pstapriv->sta_hash[i]);
2483                 plist = get_next(phead);
2484
2485                 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
2486                 {
2487                         psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
2488
2489                         plist = get_next(plist);
2490
2491                         //if(extra_arg == psta->aid)
2492                         {
2493                                 DBG_871X_SEL_NL(m, "==============================\n");
2494                                 DBG_871X_SEL_NL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
2495                                 DBG_871X_SEL_NL(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
2496                                 DBG_871X_SEL_NL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
2497 #ifdef CONFIG_80211N_HT
2498                                 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);
2499                                 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);
2500                                 DBG_871X_SEL_NL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
2501                                 DBG_871X_SEL_NL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
2502 #endif //CONFIG_80211N_HT
2503                                 DBG_871X_SEL_NL(m, "sleepq_len=%d\n", psta->sleepq_len);
2504                                 DBG_871X_SEL_NL(m, "sta_xmitpriv.vo_q_qcnt=%d\n", psta->sta_xmitpriv.vo_q.qcnt);
2505                                 DBG_871X_SEL_NL(m, "sta_xmitpriv.vi_q_qcnt=%d\n", psta->sta_xmitpriv.vi_q.qcnt);
2506                                 DBG_871X_SEL_NL(m, "sta_xmitpriv.be_q_qcnt=%d\n", psta->sta_xmitpriv.be_q.qcnt);
2507                                 DBG_871X_SEL_NL(m, "sta_xmitpriv.bk_q_qcnt=%d\n", psta->sta_xmitpriv.bk_q.qcnt);
2508
2509                                 DBG_871X_SEL_NL(m, "capability=0x%x\n", psta->capability);
2510                                 DBG_871X_SEL_NL(m, "flags=0x%x\n", psta->flags);
2511                                 DBG_871X_SEL_NL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
2512                                 DBG_871X_SEL_NL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
2513                                 DBG_871X_SEL_NL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
2514                                 DBG_871X_SEL_NL(m, "qos_info=0x%x\n", psta->qos_info);
2515                                 DBG_871X_SEL_NL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
2516
2517                                 sta_rx_reorder_ctl_dump(m, psta);
2518
2519 #ifdef CONFIG_TDLS
2520                                 DBG_871X_SEL_NL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
2521                                 DBG_871X_SEL_NL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
2522                                 DBG_871X_SEL_NL(m, "rx_data_pkts=%llu\n", psta->sta_stats.rx_data_pkts);
2523                                 DBG_871X_SEL_NL(m, "rx_bytes=%llu\n", psta->sta_stats.rx_bytes);
2524                                 DBG_871X_SEL_NL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
2525                                 DBG_871X_SEL_NL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
2526 #endif //CONFIG_TDLS
2527
2528                                 dump_st_ctl(m, &psta->st_ctl);
2529
2530                                 if (STA_OP_WFD_MODE(psta))
2531                                         DBG_871X_SEL_NL(m, "op_wfd_mode:0x%02x\n", STA_OP_WFD_MODE(psta));
2532
2533                                 DBG_871X_SEL_NL(m, "==============================\n");
2534                         }
2535
2536                 }
2537
2538         }
2539
2540         _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
2541
2542         return 0;
2543 }
2544
2545 #endif
2546
2547 #ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
2548 int proc_get_rtkm_info(struct seq_file *m, void *v)
2549 {
2550         struct net_device *dev = m->private;
2551         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2552         struct recv_priv        *precvpriv = &padapter->recvpriv;
2553         struct recv_buf *precvbuf;
2554
2555         precvbuf = (struct recv_buf *)precvpriv->precv_buf;
2556
2557         DBG_871X_SEL_NL(m, "============[RTKM Info]============\n");
2558         DBG_871X_SEL_NL(m, "MAX_RTKM_NR_PREALLOC_RECV_SKB: %d\n", rtw_rtkm_get_nr_recv_skb());
2559         DBG_871X_SEL_NL(m, "MAX_RTKM_RECVBUF_SZ: %d\n", rtw_rtkm_get_buff_size());
2560
2561         DBG_871X_SEL_NL(m, "============[Driver Info]============\n");
2562         DBG_871X_SEL_NL(m, "NR_PREALLOC_RECV_SKB: %d\n", NR_PREALLOC_RECV_SKB);
2563         DBG_871X_SEL_NL(m, "MAX_RECVBUF_SZ: %d\n", precvbuf->alloc_sz);
2564
2565         return 0;
2566 }
2567 #endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */
2568
2569 #ifdef DBG_MEMORY_LEAK
2570 #include <asm/atomic.h>
2571 extern atomic_t _malloc_cnt;;
2572 extern atomic_t _malloc_size;;
2573
2574 int proc_get_malloc_cnt(struct seq_file *m, void *v)
2575 {
2576         DBG_871X_SEL_NL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
2577         DBG_871X_SEL_NL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
2578
2579         return 0;
2580 }
2581 #endif /* DBG_MEMORY_LEAK */
2582
2583 #ifdef CONFIG_FIND_BEST_CHANNEL
2584 int proc_get_best_channel(struct seq_file *m, void *v)
2585 {
2586         struct net_device *dev = m->private;
2587         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2588         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2589         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
2590
2591         for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
2592                 if ( pmlmeext->channel_set[i].ChannelNum == 1)
2593                         index_24G = i;
2594                 if ( pmlmeext->channel_set[i].ChannelNum == 36)
2595                         index_5G = i;
2596         }
2597
2598         for (i=0; (i < MAX_CHANNEL_NUM) && (pmlmeext->channel_set[i].ChannelNum !=0) ; i++) {
2599                 // 2.4G
2600                 if ( pmlmeext->channel_set[i].ChannelNum == 6 ) {
2601                         if ( pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count ) {
2602                                 index_24G = i;
2603                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
2604                         }
2605                 }
2606
2607                 // 5G
2608                 if ( pmlmeext->channel_set[i].ChannelNum >= 36
2609                         && pmlmeext->channel_set[i].ChannelNum < 140 ) {
2610                          // Find primary channel
2611                         if ( (( pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0)
2612                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
2613                                 index_5G = i;
2614                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
2615                         }
2616                 }
2617
2618                 if ( pmlmeext->channel_set[i].ChannelNum >= 149
2619                         && pmlmeext->channel_set[i].ChannelNum < 165) {
2620                          // find primary channel
2621                         if ( (( pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0)
2622                                 && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
2623                                 index_5G = i;
2624                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
2625                         }
2626                 }
2627 #if 1 // debug
2628                 DBG_871X_SEL_NL(m, "The rx cnt of channel %3d = %d\n",
2629                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
2630 #endif
2631         }
2632
2633         DBG_871X_SEL_NL(m, "best_channel_5G = %d\n", best_channel_5G);
2634         DBG_871X_SEL_NL(m, "best_channel_24G = %d\n", best_channel_24G);
2635
2636         return 0;
2637 }
2638
2639 ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2640 {
2641         struct net_device *dev = data;
2642         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2643         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2644         char tmp[32];
2645
2646         if(count < 1)
2647                 return -EFAULT;
2648
2649         if (count > sizeof(tmp)) {
2650                 rtw_warn_on(1);
2651                 return -EFAULT;
2652         }
2653
2654         if (buffer && !copy_from_user(tmp, buffer, count)) {
2655                 int i;
2656                 for(i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++)
2657                 {
2658                         pmlmeext->channel_set[i].rx_count = 0;
2659                 }
2660
2661                 DBG_871X("set %s\n", "Clean Best Channel Count");
2662         }
2663
2664         return count;
2665 }
2666 #endif /* CONFIG_FIND_BEST_CHANNEL */
2667
2668 #ifdef CONFIG_BT_COEXIST
2669 int proc_get_btcoex_dbg(struct seq_file *m, void *v)
2670 {
2671         struct net_device *dev = m->private;
2672         PADAPTER padapter;
2673         char buf[512] = {0};
2674         padapter = (PADAPTER)rtw_netdev_priv(dev);
2675
2676         rtw_btcoex_GetDBG(padapter, buf, 512);
2677
2678         DBG_871X_SEL(m, "%s", buf);
2679
2680         return 0;
2681 }
2682
2683 ssize_t proc_set_btcoex_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2684 {
2685         struct net_device *dev = data;
2686         PADAPTER padapter;
2687         u8 tmp[80] = {0};
2688         u32 module[2] = {0};
2689         u32 num;
2690
2691         padapter = (PADAPTER)rtw_netdev_priv(dev);
2692
2693 //      DBG_871X("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter));
2694
2695         if (NULL == buffer)
2696         {
2697                 DBG_871X(FUNC_ADPT_FMT ": input buffer is NULL!\n",
2698                         FUNC_ADPT_ARG(padapter));
2699
2700                 return -EFAULT;
2701         }
2702
2703         if (count < 1)
2704         {
2705                 DBG_871X(FUNC_ADPT_FMT ": input length is 0!\n",
2706                         FUNC_ADPT_ARG(padapter));
2707
2708                 return -EFAULT;
2709         }
2710
2711         num = count;
2712         if (num > (sizeof(tmp) - 1))
2713                 num = (sizeof(tmp) - 1);
2714
2715         if (copy_from_user(tmp, buffer, num))
2716         {
2717                 DBG_871X(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
2718                         FUNC_ADPT_ARG(padapter));
2719
2720                 return -EFAULT;
2721         }
2722
2723         num = sscanf(tmp, "%x %x", module, module+1);
2724         if (1 == num)
2725         {
2726                 if (0 == module[0])
2727                         _rtw_memset(module, 0, sizeof(module));
2728                 else
2729                         _rtw_memset(module, 0xFF, sizeof(module));
2730         }
2731         else if (2 != num)
2732         {
2733                 DBG_871X(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
2734                         FUNC_ADPT_ARG(padapter), tmp);
2735
2736                 if (0 == num)
2737                         return -EFAULT;
2738         }
2739
2740         DBG_871X(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
2741                 FUNC_ADPT_ARG(padapter), module[0], module[1]);
2742         rtw_btcoex_SetDBG(padapter, module);
2743
2744         return count;
2745 }
2746
2747 int proc_get_btcoex_info(struct seq_file *m, void *v)
2748 {
2749         struct net_device *dev = m->private;
2750         PADAPTER padapter;
2751         const u32 bufsize = 30*100;
2752         u8 *pbuf = NULL;
2753
2754         padapter = (PADAPTER)rtw_netdev_priv(dev);
2755
2756         pbuf = rtw_zmalloc(bufsize);
2757         if (NULL == pbuf) {
2758                 return -ENOMEM;
2759         }
2760
2761         rtw_btcoex_DisplayBtCoexInfo(padapter, pbuf, bufsize);
2762
2763         DBG_871X_SEL(m, "%s\n", pbuf);
2764
2765         rtw_mfree(pbuf, bufsize);
2766
2767         return 0;
2768 }
2769 #endif /* CONFIG_BT_COEXIST */
2770
2771 #if defined(DBG_CONFIG_ERROR_DETECT)
2772 int proc_get_sreset(struct seq_file *m, void *v)
2773 {
2774         struct net_device *dev = m->private;
2775         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2776         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2777
2778         return 0;
2779 }
2780
2781 ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2782 {
2783         struct net_device *dev = data;
2784         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2785         char tmp[32];
2786         s32 trigger_point;
2787
2788         if (count < 1)
2789                 return -EFAULT;
2790
2791         if (count > sizeof(tmp)) {
2792                 rtw_warn_on(1);
2793                 return -EFAULT;
2794         }
2795
2796         if (buffer && !copy_from_user(tmp, buffer, count)) {
2797
2798                 int num = sscanf(tmp, "%d", &trigger_point);
2799
2800                 if (trigger_point == SRESET_TGP_NULL)
2801                         rtw_hal_sreset_reset(padapter);
2802                 else
2803                         sreset_set_trigger_point(padapter, trigger_point);
2804         }
2805
2806         return count;
2807
2808 }
2809 #endif /* DBG_CONFIG_ERROR_DETECT */
2810
2811 #ifdef CONFIG_PCI_HCI
2812
2813 int proc_get_rx_ring(struct seq_file *m, void *v)
2814 {
2815         _irqL irqL;
2816         struct net_device *dev = m->private;
2817         _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
2818         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
2819         struct recv_priv *precvpriv = &padapter->recvpriv;
2820         struct rtw_rx_ring *rx_ring = &precvpriv->rx_ring[RX_MPDU_QUEUE];
2821         int i, j;
2822
2823         DBG_871X_SEL_NL(m, "rx ring (%p)\n", rx_ring);
2824         DBG_871X_SEL_NL(m, "  dma: 0x%08x\n", (int) rx_ring->dma);
2825         DBG_871X_SEL_NL(m, "  idx: %d\n", rx_ring->idx);
2826
2827         _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
2828         for (i=0; i<precvpriv->rxringcount; i++)
2829         {
2830                 struct recv_stat *entry = &rx_ring->desc[i];
2831                 struct sk_buff *skb = rx_ring->rx_buf[i];
2832
2833                 DBG_871X_SEL_NL(m, "  desc[%03d]: %p, rx_buf[%03d]: 0x%08x\n",
2834                         i, entry, i, cpu_to_le32(*((dma_addr_t *)skb->cb)));
2835
2836                 for (j=0; j<sizeof(*entry)/4; j++)
2837                 {
2838                         if ((j % 4) == 0)
2839                                 DBG_871X_SEL_NL(m, "  0x%03x", j);
2840
2841                         DBG_871X_SEL_NL(m, " 0x%08x ", ((int *) entry)[j]);
2842
2843                         if ((j % 4) == 3)
2844                                 DBG_871X_SEL_NL(m, "\n");
2845                 }
2846         }
2847         _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
2848
2849         return 0;
2850 }
2851
2852 int proc_get_tx_ring(struct seq_file *m, void *v)
2853 {
2854         _irqL irqL;
2855         struct net_device *dev = m->private;
2856         _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
2857         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
2858         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2859         int i, j, k;
2860
2861         _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
2862         for (i = 0; i < PCI_MAX_TX_QUEUE_COUNT; i++)
2863         {
2864                 struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
2865
2866                 DBG_871X_SEL_NL(m, "tx ring[%d] (%p)\n", i, tx_ring);
2867                 DBG_871X_SEL_NL(m, "  dma: 0x%08x\n", (int) tx_ring->dma);
2868                 DBG_871X_SEL_NL(m, "  idx: %d\n", tx_ring->idx);
2869                 DBG_871X_SEL_NL(m, "  entries: %d\n", tx_ring->entries);
2870 //              DBG_871X_SEL_NL(m, "  queue: %d\n", tx_ring->queue);
2871                 DBG_871X_SEL_NL(m, "  qlen: %d\n", tx_ring->qlen);
2872
2873                 for (j=0; j < pxmitpriv->txringcount[i]; j++)
2874                 {
2875                         struct tx_desc *entry = &tx_ring->desc[j];
2876
2877                         DBG_871X_SEL_NL(m, "  desc[%03d]: %p\n", j, entry);
2878                         for (k=0; k < sizeof(*entry)/4; k++)
2879                         {
2880                                 if ((k % 4) == 0)
2881                                         DBG_871X_SEL_NL(m, "  0x%03x", k);
2882
2883                                 DBG_871X_SEL_NL(m, " 0x%08x ", ((int *) entry)[k]);
2884
2885                                 if ((k % 4) == 3)
2886                                         DBG_871X_SEL_NL(m, "\n");
2887                         }
2888                 }
2889         }
2890         _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
2891
2892         return 0;
2893 }
2894 #endif
2895
2896 #ifdef CONFIG_GPIO_WAKEUP
2897 int proc_get_wowlan_gpio_info(struct seq_file *m, void *v)
2898 {
2899         struct net_device *dev = m->private;
2900         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2901         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2902         u8 val = pwrpriv->is_high_active;
2903
2904         DBG_871X_SEL_NL(m, "wakeup_gpio_idx: %d\n", WAKEUP_GPIO_IDX);
2905         DBG_871X_SEL_NL(m, "high_active: %d\n", val);
2906
2907         return 0;
2908 }
2909
2910 ssize_t proc_set_wowlan_gpio_info(struct file *file, const char __user *buffer,
2911                 size_t count, loff_t *pos, void *data)
2912 {
2913         struct net_device *dev = data;
2914         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2915         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2916         char tmp[32] = {0};
2917         int num = 0;
2918         u32 is_high_active = 0;
2919         u8 val8 = 0;
2920
2921         if (count < 1)
2922                 return -EFAULT;
2923
2924         if (count > sizeof(tmp)) {
2925                 rtw_warn_on(1);
2926                 return -EFAULT;
2927         }
2928
2929         if (buffer && !copy_from_user(tmp, buffer, count)) {
2930
2931                 num = sscanf(tmp, "%u", &is_high_active);
2932
2933                 is_high_active = is_high_active == 0 ? 0 : 1;
2934
2935                 pwrpriv->is_high_active = is_high_active;
2936
2937                 rtw_ps_deny(padapter, PS_DENY_IOCTL);
2938                 LeaveAllPowerSaveModeDirect(padapter);
2939                 val8 = (pwrpriv->is_high_active == 0) ? 1 : 0;
2940                 rtw_hal_set_output_gpio(padapter, WAKEUP_GPIO_IDX, val8);
2941                 rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
2942
2943                 DBG_871X("set %s %d\n", "gpio_high_active",
2944                                 pwrpriv->is_high_active);
2945                 DBG_871X("%s: set GPIO_%d %d as default.\n",
2946                          __func__, WAKEUP_GPIO_IDX, val8);
2947         }
2948
2949         return count;
2950 }
2951 #endif /* CONFIG_GPIO_WAKEUP */
2952
2953 #ifdef CONFIG_P2P_WOWLAN
2954 int proc_get_p2p_wowlan_info(struct seq_file *m, void *v)
2955 {
2956         struct net_device *dev = m->private;
2957         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2958         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
2959         struct p2p_wowlan_info   peerinfo = pwdinfo->p2p_wow_info;
2960         if(_TRUE == peerinfo.is_trigger)
2961         {
2962                 DBG_871X_SEL_NL(m,"is_trigger: TRUE\n");
2963                 switch(peerinfo.wowlan_recv_frame_type)
2964                 {
2965                         case P2P_WOWLAN_RECV_NEGO_REQ:
2966                                 DBG_871X_SEL_NL(m,"Frame Type: Nego Request\n");
2967                                 break;
2968                         case P2P_WOWLAN_RECV_INVITE_REQ:
2969                                 DBG_871X_SEL_NL(m,"Frame Type: Invitation Request\n");
2970                                 break;
2971                         case P2P_WOWLAN_RECV_PROVISION_REQ:
2972                                 DBG_871X_SEL_NL(m,"Frame Type: Provision Request\n");
2973                                 break;
2974                         default:
2975                                 break;
2976                 }
2977                 DBG_871X_SEL_NL(m,"Peer Addr: "MAC_FMT"\n", MAC_ARG(peerinfo.wowlan_peer_addr));
2978                 DBG_871X_SEL_NL(m,"Peer WPS Config: %x\n", peerinfo.wowlan_peer_wpsconfig);
2979                 DBG_871X_SEL_NL(m,"Persistent Group: %d\n", peerinfo.wowlan_peer_is_persistent);
2980                 DBG_871X_SEL_NL(m,"Intivation Type: %d\n", peerinfo.wowlan_peer_invitation_type);
2981         }
2982         else
2983         {
2984                 DBG_871X_SEL_NL(m,"is_trigger: False\n");
2985         }
2986         return 0;
2987 }
2988 #endif /* CONFIG_P2P_WOWLAN */
2989
2990 int proc_get_new_bcn_max(struct seq_file *m, void *v)
2991 {
2992         extern int new_bcn_max;
2993
2994         DBG_871X_SEL_NL(m, "%d", new_bcn_max);
2995         return 0;
2996 }
2997
2998 ssize_t proc_set_new_bcn_max(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2999 {
3000         char tmp[32];
3001         extern int new_bcn_max;
3002
3003         if(count < 1)
3004                 return -EFAULT;
3005
3006         if (count > sizeof(tmp)) {
3007                 rtw_warn_on(1);
3008                 return -EFAULT;
3009         }
3010
3011         if (buffer && !copy_from_user(tmp, buffer, count))
3012                 sscanf(tmp, "%d ", &new_bcn_max);
3013
3014         return count;
3015 }
3016
3017 #ifdef CONFIG_POWER_SAVING
3018 int proc_get_ps_info(struct seq_file *m, void *v)
3019 {
3020         struct net_device *dev = m->private;
3021         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3022         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3023         u8 ips_mode = pwrpriv->ips_mode;
3024         u8 lps_mode = pwrpriv->power_mgnt;
3025         char *str = "";
3026
3027         DBG_871X_SEL_NL(m, "======Power Saving Info:======\n");
3028         DBG_871X_SEL_NL(m, "*IPS:\n");
3029
3030         if (ips_mode == IPS_NORMAL) {
3031 #ifdef CONFIG_FWLPS_IN_IPS
3032                 str = "FW_LPS_IN_IPS";
3033 #else
3034                 str = "Card Disable";
3035 #endif
3036         } else if (ips_mode == IPS_NONE) {
3037                 str = "NO IPS";
3038         } else if (ips_mode == IPS_LEVEL_2) {
3039                 str = "IPS_LEVEL_2";
3040         } else {
3041                 str = "invalid ips_mode";
3042         }
3043
3044         DBG_871X_SEL_NL(m, " IPS mode: %s\n", str);
3045         DBG_871X_SEL_NL(m, " IPS enter count:%d, IPS leave count:%d\n",
3046                         pwrpriv->ips_enter_cnts, pwrpriv->ips_leave_cnts);
3047         DBG_871X_SEL_NL(m, "------------------------------\n");
3048         DBG_871X_SEL_NL(m, "*LPS:\n");
3049
3050         if (lps_mode == PS_MODE_ACTIVE) {
3051                 str = "NO LPS";
3052         } else if (lps_mode == PS_MODE_MIN) {
3053                 str = "MIN";
3054         } else if (lps_mode == PS_MODE_MAX) {
3055                 str = "MAX";
3056         } else if (lps_mode == PS_MODE_DTIM) {
3057                 str = "DTIM";
3058         } else {
3059                 sprintf(str, "%d", lps_mode);
3060         }
3061
3062         DBG_871X_SEL_NL(m, " LPS mode: %s\n", str);
3063
3064         if (pwrpriv->dtim != 0)
3065                 DBG_871X_SEL_NL(m, " DTIM: %d\n", pwrpriv->dtim);
3066         DBG_871X_SEL_NL(m, " LPS enter count:%d, LPS leave count:%d\n",
3067                         pwrpriv->lps_enter_cnts, pwrpriv->lps_leave_cnts);
3068         DBG_871X_SEL_NL(m, "=============================\n");
3069         return 0;
3070 }
3071 #endif //CONFIG_POWER_SAVING
3072
3073 #ifdef CONFIG_TDLS
3074 static int proc_tdls_display_tdls_function_info(struct seq_file *m)
3075 {
3076         struct net_device *dev = m->private;
3077         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3078         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3079         u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
3080         u8 SpaceBtwnItemAndValueTmp = 0;
3081         BOOLEAN FirstMatchFound = _FALSE;
3082         int j= 0;
3083
3084         DBG_871X_SEL_NL(m, "============[TDLS Function Info]============\n");
3085         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Prohibited", (ptdlsinfo->ap_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
3086         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Channel Switch Prohibited", (ptdlsinfo->ch_switch_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
3087         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Link Established", (ptdlsinfo->link_established == _TRUE) ? "_TRUE" : "_FALSE");
3088         DBG_871X_SEL_NL(m, "%-*s = %d/%d\n", SpaceBtwnItemAndValue, "TDLS STA Num (Linked/Allowed)", ptdlsinfo->sta_cnt, MAX_ALLOWED_TDLS_STA_NUM);
3089         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Allowed STA Num Reached", (ptdlsinfo->sta_maximum == _TRUE) ? "_TRUE" : "_FALSE");
3090
3091 #ifdef CONFIG_TDLS_CH_SW
3092         DBG_871X_SEL_NL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS CH SW State");
3093         if (ptdlsinfo->chsw_info.ch_sw_state == TDLS_STATE_NONE)
3094         {
3095                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_STATE_NONE");
3096         }
3097         else
3098         {
3099                 for (j = 0; j < 32; j++)
3100                 {
3101                         if (ptdlsinfo->chsw_info.ch_sw_state & BIT(j))
3102                         {
3103                                 if (FirstMatchFound ==  _FALSE)
3104                                 {
3105                                         SpaceBtwnItemAndValueTmp = 1;
3106                                         FirstMatchFound = _TRUE;
3107                                 }
3108                                 else
3109                                 {
3110                                         SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
3111                                 }
3112                                 switch (BIT(j))
3113                                 {
3114                                         case TDLS_INITIATOR_STATE:
3115                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
3116                                                 break;
3117                                         case TDLS_RESPONDER_STATE:
3118                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
3119                                                 break;
3120                                         case TDLS_LINKED_STATE:
3121                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
3122                                                 break;
3123                                         case TDLS_WAIT_PTR_STATE:
3124                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
3125                                                 break;
3126                                         case TDLS_ALIVE_STATE:
3127                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
3128                                                 break;
3129                                         case TDLS_CH_SWITCH_ON_STATE:
3130                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
3131                                                 break;
3132                                         case TDLS_PEER_AT_OFF_STATE:
3133                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
3134                                                 break;
3135                                         case TDLS_CH_SW_INITIATOR_STATE:
3136                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
3137                                                 break;
3138                                         case TDLS_WAIT_CH_RSP_STATE:
3139                                                 DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
3140                                                 break;
3141                                         default:
3142                                                 DBG_871X_SEL_NL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
3143                                                 break;
3144                                 }
3145                         }
3146                 }
3147         }
3148
3149         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW On", (ATOMIC_READ(&ptdlsinfo->chsw_info.chsw_on) == _TRUE) ? "_TRUE" : "_FALSE");
3150         DBG_871X_SEL_NL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Off-Channel Num", ptdlsinfo->chsw_info.off_ch_num);
3151         DBG_871X_SEL_NL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Channel Offset", ptdlsinfo->chsw_info.ch_offset);
3152         DBG_871X_SEL_NL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Current Time", ptdlsinfo->chsw_info.cur_time);
3153         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW Delay Switch Back", (ptdlsinfo->chsw_info.delay_switch_back == _TRUE) ? "_TRUE" : "_FALSE");
3154         DBG_871X_SEL_NL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Dump Back", ptdlsinfo->chsw_info.dump_stack);
3155 #endif
3156
3157         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Device Discovered", (ptdlsinfo->dev_discovered == _TRUE) ? "_TRUE" : "_FALSE");
3158         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Enable", (ptdlsinfo->tdls_enable == _TRUE) ? "_TRUE" : "_FALSE");
3159         DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Driver Setup", (ptdlsinfo->driver_setup == _TRUE) ? "_TRUE" : "_FALSE");
3160
3161         return 0;
3162 }
3163
3164 static int proc_tdls_display_network_info(struct seq_file *m)
3165 {
3166         struct net_device *dev = m->private;
3167         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3168         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3169         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3170         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
3171         int i = 0;
3172         u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
3173
3174         /* Display the linked AP/GO info */
3175         DBG_871X_SEL_NL(m, "============[Associated AP/GO Info]============\n");
3176
3177         if ((pmlmepriv->fw_state & WIFI_STATION_STATE) && (pmlmepriv->fw_state & _FW_LINKED))
3178         {
3179                 DBG_871X_SEL_NL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "BSSID", cur_network->network.Ssid.Ssid);
3180                 DBG_871X_SEL_NL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(cur_network->network.MacAddress));
3181
3182                 DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
3183                 for (i = 0; i < 8; i++)
3184                 {
3185                         if (pmlmeext->cur_wireless_mode & BIT(i))
3186                         {
3187                                 switch (BIT(i))
3188                                 {
3189                                         case WIRELESS_11B:
3190                                                 DBG_871X_SEL_NL(m, "%4s", "11B ");
3191                                                 break;
3192                                         case WIRELESS_11G:
3193                                                 DBG_871X_SEL_NL(m, "%4s", "11G ");
3194                                                 break;
3195                                         case WIRELESS_11A:
3196                                                 DBG_871X_SEL_NL(m, "%4s", "11A ");
3197                                                 break;
3198                                         case WIRELESS_11_24N:
3199                                                 DBG_871X_SEL_NL(m, "%7s", "11_24N ");
3200                                                 break;
3201                                         case WIRELESS_11_5N:
3202                                                 DBG_871X_SEL_NL(m, "%6s", "11_5N ");
3203                                                 break;
3204                                         case WIRELESS_AUTO:
3205                                                 DBG_871X_SEL_NL(m, "%5s", "AUTO ");
3206                                                 break;
3207                                         case WIRELESS_11AC:
3208                                                 DBG_871X_SEL_NL(m, "%5s", "11AC ");
3209                                                 break;
3210                                 }
3211                         }
3212                 }
3213                 DBG_871X_SEL_NL(m, "\n");
3214
3215                 DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
3216                 switch (padapter->securitypriv.dot11PrivacyAlgrthm)
3217                 {
3218                         case _NO_PRIVACY_:
3219                                 DBG_871X_SEL_NL(m, "%s\n", "NO PRIVACY");
3220                                 break;
3221                         case _WEP40_:
3222                                 DBG_871X_SEL_NL(m, "%s\n", "WEP 40");
3223                                 break;
3224                         case _TKIP_:
3225                                 DBG_871X_SEL_NL(m, "%s\n", "TKIP");
3226                                 break;
3227                         case _TKIP_WTMIC_:
3228                                 DBG_871X_SEL_NL(m, "%s\n", "TKIP WTMIC");
3229                                 break;
3230                         case _AES_:
3231                                 DBG_871X_SEL_NL(m, "%s\n", "AES");
3232                                 break;
3233                         case _WEP104_:
3234                                 DBG_871X_SEL_NL(m, "%s\n", "WEP 104");
3235                                 break;
3236                         case _WEP_WPA_MIXED_:
3237                                 DBG_871X_SEL_NL(m, "%s\n", "WEP/WPA Mixed");
3238                                 break;
3239                         case _SMS4_:
3240                                 DBG_871X_SEL_NL(m, "%s\n", "SMS4");
3241                                 break;
3242 #ifdef CONFIG_IEEE80211W
3243                         case _BIP_:
3244                                 DBG_871X_SEL_NL(m, "%s\n", "BIP");
3245                                 break;
3246 #endif //CONFIG_IEEE80211W
3247                 }
3248
3249                 DBG_871X_SEL_NL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "Channel", pmlmeext->cur_channel);
3250                 DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Channel Offset");
3251                 switch (pmlmeext->cur_ch_offset)
3252                 {
3253                         case HAL_PRIME_CHNL_OFFSET_DONT_CARE:
3254                                 DBG_871X_SEL_NL(m, "%s\n", "N/A");
3255                                 break;
3256                         case HAL_PRIME_CHNL_OFFSET_LOWER:
3257                                 DBG_871X_SEL_NL(m, "%s\n", "Lower");
3258                                 break;
3259                         case HAL_PRIME_CHNL_OFFSET_UPPER:
3260                                 DBG_871X_SEL_NL(m, "%s\n", "Upper");
3261                                 break;
3262                 }
3263
3264                 DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
3265                 switch (pmlmeext->cur_bwmode)
3266                 {
3267                         case CHANNEL_WIDTH_20:
3268                                 DBG_871X_SEL_NL(m, "%s\n", "20MHz");
3269                                 break;
3270                         case CHANNEL_WIDTH_40:
3271                                 DBG_871X_SEL_NL(m, "%s\n", "40MHz");
3272                                 break;
3273                         case CHANNEL_WIDTH_80:
3274                                 DBG_871X_SEL_NL(m, "%s\n", "80MHz");
3275                                 break;
3276                         case CHANNEL_WIDTH_160:
3277                                 DBG_871X_SEL_NL(m, "%s\n", "160MHz");
3278                                 break;
3279                         case CHANNEL_WIDTH_80_80:
3280                                 DBG_871X_SEL_NL(m, "%s\n", "80MHz + 80MHz");
3281                                 break;
3282                 }
3283         }
3284         else
3285         {
3286                 DBG_871X_SEL_NL(m, "No association with AP/GO exists!\n");
3287         }
3288
3289         return 0;
3290 }
3291
3292 static int proc_tdls_display_tdls_sta_info(struct seq_file *m)
3293 {
3294         struct net_device *dev = m->private;
3295         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3296         struct sta_priv *pstapriv = &padapter->stapriv;
3297         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3298         struct sta_info *psta;
3299         int i = 0, j = 0;
3300         _irqL irqL;
3301         _list   *plist, *phead;
3302         u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
3303         u8 SpaceBtwnItemAndValueTmp = 0;
3304         u8 NumOfTdlsStaToShow = 0;
3305         BOOLEAN FirstMatchFound = _FALSE;
3306
3307         /* Search for TDLS sta info to display */
3308         _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3309         for (i=0; i< NUM_STA; i++)
3310         {
3311                 phead = &(pstapriv->sta_hash[i]);
3312                 plist = get_next(phead);
3313                 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
3314                 {
3315                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
3316                                 plist = get_next(plist);
3317                                 if (psta->tdls_sta_state != TDLS_STATE_NONE)
3318                                 {
3319                                         /* We got one TDLS sta info to show */
3320                                         DBG_871X_SEL_NL(m, "============[TDLS Peer STA Info: STA %d]============\n", ++NumOfTdlsStaToShow);
3321                                         DBG_871X_SEL_NL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(psta->hwaddr));
3322                                         DBG_871X_SEL_NL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS STA State");
3323                                         SpaceBtwnItemAndValueTmp = 0;
3324                                         FirstMatchFound = _FALSE;
3325                                         for (j = 0; j < 32; j++)
3326                                         {
3327                                                 if (psta->tdls_sta_state & BIT(j))
3328                                                 {
3329                                                         if (FirstMatchFound ==  _FALSE)
3330                                                         {
3331                                                                 SpaceBtwnItemAndValueTmp = 1;
3332                                                                 FirstMatchFound = _TRUE;
3333                                                         }
3334                                                         else
3335                                                         {
3336                                                                 SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
3337                                                         }
3338                                                         switch (BIT(j))
3339                                                         {
3340                                                                 case TDLS_INITIATOR_STATE:
3341                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
3342                                                                         break;
3343                                                                 case TDLS_RESPONDER_STATE:
3344                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
3345                                                                         break;
3346                                                                 case TDLS_LINKED_STATE:
3347                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
3348                                                                         break;
3349                                                                 case TDLS_WAIT_PTR_STATE:
3350                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
3351                                                                         break;
3352                                                                 case TDLS_ALIVE_STATE:
3353                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
3354                                                                         break;
3355                                                                 case TDLS_CH_SWITCH_ON_STATE:
3356                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
3357                                                                         break;
3358                                                                 case TDLS_PEER_AT_OFF_STATE:
3359                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
3360                                                                         break;
3361                                                                 case TDLS_CH_SW_INITIATOR_STATE:
3362                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
3363                                                                         break;
3364                                                                 case TDLS_WAIT_CH_RSP_STATE:
3365                                                                         DBG_871X_SEL_NL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
3366                                                                         break;
3367                                                                 default:
3368                                                                         DBG_871X_SEL_NL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
3369                                                                         break;
3370                                                         }
3371                                                 }
3372                                         }
3373
3374                                         DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
3375                                         for (j = 0; j < 8; j++)
3376                                         {
3377                                                 if (psta->wireless_mode & BIT(j))
3378                                                 {
3379                                                         switch (BIT(j))
3380                                                         {
3381                                                                 case WIRELESS_11B:
3382                                                                         DBG_871X_SEL_NL(m, "%4s", "11B ");
3383                                                                         break;
3384                                                                 case WIRELESS_11G:
3385                                                                         DBG_871X_SEL_NL(m, "%4s", "11G ");
3386                                                                         break;
3387                                                                 case WIRELESS_11A:
3388                                                                         DBG_871X_SEL_NL(m, "%4s", "11A ");
3389                                                                         break;
3390                                                                 case WIRELESS_11_24N:
3391                                                                         DBG_871X_SEL_NL(m, "%7s", "11_24N ");
3392                                                                         break;
3393                                                                 case WIRELESS_11_5N:
3394                                                                         DBG_871X_SEL_NL(m, "%6s", "11_5N ");
3395                                                                         break;
3396                                                                 case WIRELESS_AUTO:
3397                                                                         DBG_871X_SEL_NL(m, "%5s", "AUTO ");
3398                                                                         break;
3399                                                                 case WIRELESS_11AC:
3400                                                                         DBG_871X_SEL_NL(m, "%5s", "11AC ");
3401                                                                         break;
3402                                                         }
3403                                                 }
3404                                         }
3405                                         DBG_871X_SEL_NL(m, "\n");
3406
3407                                         DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
3408                                         switch (psta->bw_mode)
3409                                         {
3410                                                 case CHANNEL_WIDTH_20:
3411                                                         DBG_871X_SEL_NL(m, "%s\n", "20MHz");
3412                                                         break;
3413                                                 case CHANNEL_WIDTH_40:
3414                                                         DBG_871X_SEL_NL(m, "%s\n", "40MHz");
3415                                                         break;
3416                                                 case CHANNEL_WIDTH_80:
3417                                                         DBG_871X_SEL_NL(m, "%s\n", "80MHz");
3418                                                         break;
3419                                                 case CHANNEL_WIDTH_160:
3420                                                         DBG_871X_SEL_NL(m, "%s\n", "160MHz");
3421                                                         break;
3422                                                 case CHANNEL_WIDTH_80_80:
3423                                                         DBG_871X_SEL_NL(m, "%s\n", "80MHz + 80MHz");
3424                                                         break;
3425                                         }
3426
3427                                         DBG_871X_SEL_NL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
3428                                         switch (psta->dot118021XPrivacy)
3429                                         {
3430                                                 case _NO_PRIVACY_:
3431                                                         DBG_871X_SEL_NL(m, "%s\n", "NO PRIVACY");
3432                                                         break;
3433                                                 case _WEP40_:
3434                                                         DBG_871X_SEL_NL(m, "%s\n", "WEP 40");
3435                                                         break;
3436                                                 case _TKIP_:
3437                                                         DBG_871X_SEL_NL(m, "%s\n", "TKIP");
3438                                                         break;
3439                                                 case _TKIP_WTMIC_:
3440                                                         DBG_871X_SEL_NL(m, "%s\n", "TKIP WTMIC");
3441                                                         break;
3442                                                 case _AES_:
3443                                                         DBG_871X_SEL_NL(m, "%s\n", "AES");
3444                                                         break;
3445                                                 case _WEP104_:
3446                                                         DBG_871X_SEL_NL(m, "%s\n", "WEP 104");
3447                                                         break;
3448                                                 case _WEP_WPA_MIXED_:
3449                                                         DBG_871X_SEL_NL(m, "%s\n", "WEP/WPA Mixed");
3450                                                         break;
3451                                                 case _SMS4_:
3452                                                         DBG_871X_SEL_NL(m, "%s\n", "SMS4");
3453                                                         break;
3454 #ifdef CONFIG_IEEE80211W
3455                                                 case _BIP_:
3456                                                         DBG_871X_SEL_NL(m, "%s\n", "BIP");
3457                                                         break;
3458 #endif //CONFIG_IEEE80211W
3459                                         }
3460
3461                                         DBG_871X_SEL_NL(m, "%-*s = %d sec/%d sec\n", SpaceBtwnItemAndValue, "TPK Lifetime (Current/Expire)", psta->TPK_count, psta->TDLS_PeerKey_Lifetime);
3462                                         DBG_871X_SEL_NL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Tx Packets Over Direct Link", psta->sta_stats.tx_pkts);
3463                                         DBG_871X_SEL_NL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Rx Packets Over Direct Link", psta->sta_stats.rx_data_pkts);
3464                                 }
3465                 }
3466         }
3467         _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3468         if (NumOfTdlsStaToShow == 0)
3469         {
3470                 DBG_871X_SEL_NL(m, "============[TDLS Peer STA Info]============\n");
3471                 DBG_871X_SEL_NL(m, "No TDLS direct link exists!\n");
3472         }
3473
3474         return 0;
3475 }
3476
3477 int proc_get_tdls_info(struct seq_file *m, void *v)
3478 {
3479         struct net_device *dev = m->private;
3480         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3481         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3482         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3483         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
3484         struct sta_priv *pstapriv = &padapter->stapriv;
3485         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
3486         struct sta_info *psta;
3487         int i = 0, j = 0;
3488         _irqL irqL;
3489         _list   *plist, *phead;
3490         u8 SpaceBtwnItemAndValue = 41;
3491         u8 SpaceBtwnItemAndValueTmp = 0;
3492         u8 NumOfTdlsStaToShow = 0;
3493         BOOLEAN FirstMatchFound = _FALSE;
3494
3495         if (hal_chk_wl_func(padapter, WL_FUNC_TDLS) == _FALSE) {
3496                 DBG_871X_SEL_NL(m, "No tdls info can be shown since hal doesn't support tdls\n");
3497                 return 0;
3498         }
3499
3500         proc_tdls_display_tdls_function_info(m);
3501         proc_tdls_display_network_info(m);
3502         proc_tdls_display_tdls_sta_info(m);
3503
3504         return 0;
3505 }
3506 #endif
3507
3508 int proc_get_monitor(struct seq_file *m, void *v)
3509 {
3510         struct net_device *dev = m->private;
3511         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3512         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3513         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3514
3515         if (WIFI_MONITOR_STATE == get_fwstate(pmlmepriv)) {
3516                 DBG_871X_SEL_NL(m, "Monitor mode : Enable\n");
3517
3518                 DBG_871X_SEL_NL(m, "ch=%d, ch_offset=%d, bw=%d\n",
3519                                                 rtw_get_oper_ch(padapter), rtw_get_oper_choffset(padapter), rtw_get_oper_bw(padapter));
3520         } else {
3521                 DBG_871X_SEL_NL(m, "Monitor mode : Disable\n");
3522         }
3523
3524         return 0;
3525 }
3526
3527 ssize_t proc_set_monitor(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3528 {
3529         char tmp[32];
3530         struct net_device *dev = data;
3531         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3532         u8 target_chan, target_offset, target_bw;
3533
3534         if (count < 3) {
3535                 DBG_871X("argument size is less than 3\n");
3536                 return -EFAULT;
3537         }
3538
3539         if (count > sizeof(tmp)) {
3540                 rtw_warn_on(1);
3541                 return -EFAULT;
3542         }
3543
3544         if (buffer && !copy_from_user(tmp, buffer, count)) {
3545                 int num = sscanf(tmp, "%hhu %hhu %hhu", &target_chan, &target_offset, &target_bw);
3546
3547                 if (num != 3) {
3548                         DBG_871X("invalid write_reg parameter!\n");
3549                         return count;
3550                 }
3551
3552                 padapter->mlmeextpriv.cur_channel  = target_chan;
3553                 set_channel_bwmode(padapter, target_chan, target_offset, target_bw);
3554         }
3555
3556         return count;
3557 }
3558
3559 #include <hal_data.h>
3560 int proc_get_efuse_map(struct seq_file *m, void *v)
3561 {
3562         struct net_device *dev = m->private;
3563         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3564         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
3565         struct pwrctrl_priv *pwrctrlpriv  = adapter_to_pwrctl(padapter);
3566         PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
3567         int i, j;
3568         u8 ips_mode = IPS_NUM;
3569         int mapLen = EFUSE_MAP_SIZE;
3570
3571         ips_mode = pwrctrlpriv->ips_mode;
3572         rtw_pm_set_ips(padapter, IPS_NONE);
3573         if (rtw_efuse_map_read(padapter, EFUSE_WIFI, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL)
3574                 DBG_871X_SEL_NL(m, "WARN - Read Realmap Failed\n");
3575
3576         DBG_871X_SEL_NL(m, "\n");
3577         for (i = 0; i < EFUSE_MAP_SIZE; i += 16) {
3578                 DBG_871X_SEL_NL(m, "0x%02x\t", i);
3579                 for (j = 0; j < 8; j++)
3580                         DBG_871X_SEL_NL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i+j]);
3581
3582                 DBG_871X_SEL_NL(m, "\t");
3583
3584                 for (; j < 16; j++)
3585                         DBG_871X_SEL_NL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i+j]);
3586
3587                 DBG_871X_SEL_NL(m, "\n");
3588
3589         }
3590         rtw_pm_set_ips(padapter, ips_mode);
3591         return 0;
3592 }
3593
3594 ssize_t proc_set_efuse_map(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3595 {
3596 #if 0
3597         char tmp[256] = {0};
3598         u32 addr, cnts;
3599         u8 efuse_data;
3600
3601         int jj, kk;
3602
3603         struct net_device *dev = data;
3604         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3605         struct pwrctrl_priv *pwrctrlpriv  = adapter_to_pwrctl(padapter);
3606         u8 ips_mode = IPS_NUM;
3607
3608         if (count < 3) {
3609                 DBG_871X("argument size is less than 3\n");
3610                 return -EFAULT;
3611         }
3612
3613         if (count > sizeof(tmp)) {
3614                 rtw_warn_on(1);
3615                 return -EFAULT;
3616         }
3617
3618         if (buffer && !copy_from_user(tmp, buffer, count)) {
3619
3620                 int num = sscanf(tmp, "%x %d %x", &addr, &cnts, &efuse_data);
3621
3622                 if (num != 3) {
3623                         DBG_871X("invalid write_reg parameter!\n");
3624                         return count;
3625                 }
3626         }
3627         ips_mode = pwrctrlpriv->ips_mode;
3628         rtw_pm_set_ips(padapter, IPS_NONE);
3629         if (rtw_efuse_map_write(padapter, addr, cnts, &efuse_data) == _FAIL)
3630                 DBG_871X("WARN - rtw_efuse_map_write error!!\n");
3631         rtw_pm_set_ips(padapter, ips_mode);
3632 #endif
3633         return count;
3634 }
3635
3636 #ifdef CONFIG_IEEE80211W
3637 ssize_t proc_set_tx_sa_query(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3638 {
3639         struct net_device *dev = data;
3640         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3641         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
3642         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
3643         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3644         struct  sta_priv *pstapriv = &padapter->stapriv;
3645         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3646         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
3647         struct sta_info *psta;
3648         _list   *plist, *phead;
3649         _irqL    irqL;
3650         char tmp[16];
3651         u8      mac_addr[NUM_STA][ETH_ALEN];
3652         u32 key_type;
3653         u8 index;
3654
3655         if (count > 2) {
3656                 DBG_871X("argument size is more than 2\n");
3657                 return -EFAULT;
3658         }
3659
3660         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
3661
3662                 int num = sscanf(tmp, "%x", &key_type);
3663
3664                 if (num !=  1) {
3665                         DBG_871X("invalid read_reg parameter!\n");
3666                         return count;
3667                 }
3668                 DBG_871X("0: set sa query request , key_type=%d\n", key_type);
3669         }
3670
3671         if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
3672                 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) && padapter->securitypriv.binstallBIPkey == _TRUE) {
3673                 DBG_871X("STA:"MAC_FMT"\n", MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
3674                 /* TX unicast sa_query to AP */
3675                 issue_action_SA_Query(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, 0, (u8)key_type);
3676         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && padapter->securitypriv.binstallBIPkey == _TRUE) {
3677                 /* TX unicast sa_query to every client STA */
3678                 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3679                 for (index = 0; index < NUM_STA; index++) {
3680                         psta = NULL;
3681
3682                         phead = &(pstapriv->sta_hash[index]);
3683                         plist = get_next(phead);
3684
3685                         while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
3686                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
3687                                 plist = get_next(plist);
3688                                 _rtw_memcpy(&mac_addr[psta->mac_id][0], psta->hwaddr, ETH_ALEN);
3689                         }
3690                 }
3691                 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3692
3693                 for (index = 0; index < macid_ctl->num && index < NUM_STA; index++) {
3694                         if (rtw_macid_is_used(macid_ctl, index) && !rtw_macid_is_bmc(macid_ctl, index)) {
3695                                 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)
3696                                         && !IS_MCAST(&mac_addr[index][0])) {
3697                                         issue_action_SA_Query(padapter, &mac_addr[index][0], 0, 0, (u8)key_type);
3698                                         DBG_871X("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
3699                                 }
3700                         }
3701                 }
3702         }
3703
3704         return count;
3705 }
3706
3707 int proc_get_tx_sa_query(struct seq_file *m, void *v)
3708 {
3709         struct net_device *dev = m->private;
3710         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3711
3712         DBG_871X_SEL_NL(m, "%s\n", __func__);
3713         return 0;
3714 }
3715
3716 ssize_t proc_set_tx_deauth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3717 {
3718         struct net_device *dev = data;
3719         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3720         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
3721         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
3722         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3723         struct  sta_priv *pstapriv = &padapter->stapriv;
3724         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3725         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
3726         struct sta_info *psta;
3727         _list   *plist, *phead;
3728         _irqL    irqL;
3729         char tmp[16];
3730         u8      mac_addr[NUM_STA][ETH_ALEN];
3731         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3732         u32 key_type;
3733         u8 index;
3734
3735
3736         if (count > 2) {
3737                 DBG_871X("argument size is more than 2\n");
3738                 return -EFAULT;
3739         }
3740
3741         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
3742
3743                 int num = sscanf(tmp, "%x", &key_type);
3744
3745                 if (num !=  1) {
3746                         DBG_871X("invalid read_reg parameter!\n");
3747                         return count;
3748                 }
3749                 DBG_871X("key_type=%d\n", key_type);
3750         }
3751         if (key_type < 0 || key_type > 4)
3752                 return count;
3753
3754         if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
3755                 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
3756                 if (key_type == 3) /* key_type 3 only for AP mode */
3757                         return count;
3758                 /* TX unicast deauth to AP */
3759                 issue_deauth_11w(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, (u8)key_type);
3760         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
3761
3762                 if (key_type == 3)
3763                         issue_deauth_11w(padapter, bc_addr, 0, IEEE80211W_RIGHT_KEY);
3764
3765                 /* TX unicast deauth to every client STA */
3766                 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3767                 for (index = 0; index < NUM_STA; index++) {
3768                         psta = NULL;
3769
3770                         phead = &(pstapriv->sta_hash[index]);
3771                         plist = get_next(phead);
3772
3773                         while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
3774                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
3775                                 plist = get_next(plist);
3776                                 _rtw_memcpy(&mac_addr[psta->mac_id][0], psta->hwaddr, ETH_ALEN);
3777                         }
3778                 }
3779                 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3780
3781                 for (index = 0; index < macid_ctl->num && index < NUM_STA; index++) {
3782                         if (rtw_macid_is_used(macid_ctl, index) && !rtw_macid_is_bmc(macid_ctl, index)) {
3783                                 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)) {
3784                                         if (key_type != 3)
3785                                                 issue_deauth_11w(padapter, &mac_addr[index][0], 0, (u8)key_type);
3786
3787                                         psta = rtw_get_stainfo(pstapriv, &mac_addr[index][0]);
3788                                         if (psta && key_type != IEEE80211W_WRONG_KEY && key_type != IEEE80211W_NO_KEY) {
3789                                                 u8 updated = _FALSE;
3790
3791                                                 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
3792                                                 if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
3793                                                         rtw_list_delete(&psta->asoc_list);
3794                                                         pstapriv->asoc_list_cnt--;
3795                                                         updated = ap_free_sta(padapter, psta, _FALSE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE);
3796
3797                                                 }
3798                                                 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
3799
3800                                                 associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
3801                                         }
3802
3803                                         DBG_871X("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
3804                                 }
3805                         }
3806                 }
3807         }
3808
3809         return count;
3810 }
3811
3812 int proc_get_tx_deauth(struct seq_file *m, void *v)
3813 {
3814         struct net_device *dev = m->private;
3815         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3816
3817         DBG_871X_SEL_NL(m, "%s\n", __func__);
3818         return 0;
3819 }
3820
3821 ssize_t proc_set_tx_auth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3822 {
3823         struct net_device *dev = data;
3824         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3825         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
3826         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
3827         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3828         struct  sta_priv *pstapriv = &padapter->stapriv;
3829         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3830         struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
3831         struct sta_info *psta;
3832         _list   *plist, *phead;
3833         _irqL    irqL;
3834         char tmp[16];
3835         u8      mac_addr[NUM_STA][ETH_ALEN];
3836         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3837         u32 tx_auth;
3838         u8 index;
3839
3840
3841         if (count > 2) {
3842                 DBG_871X("argument size is more than 2\n");
3843                 return -EFAULT;
3844         }
3845
3846         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
3847
3848                 int num = sscanf(tmp, "%x", &tx_auth);
3849
3850                 if (num !=  1) {
3851                         DBG_871X("invalid read_reg parameter!\n");
3852                         return count;
3853                 }
3854                 DBG_871X("1: setnd auth, 2: send assoc request. tx_auth=%d\n", tx_auth);
3855         }
3856
3857         if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
3858                 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
3859                 if (tx_auth == 1) {
3860                         /* TX unicast auth to AP */
3861                         issue_auth(padapter, NULL, 0);
3862                 } else if (tx_auth == 2) {
3863                         /* TX unicast auth to AP */
3864                         issue_assocreq(padapter);
3865                 }
3866         }
3867
3868         return count;
3869 }
3870
3871 int proc_get_tx_auth(struct seq_file *m, void *v)
3872 {
3873         struct net_device *dev = m->private;
3874         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3875
3876         DBG_871X_SEL_NL(m, "%s\n", __func__);
3877         return 0;
3878 }
3879 #endif /* CONFIG_IEEE80211W */
3880
3881 #endif /* CONFIG_PROC_DEBUG */
3882