drivers/staging/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 <rtw_debug.h>
  23 #include <usb_ops_linux.h>
  24
  25 int proc_get_drv_version(char *page, char **start,
  26                           off_t offset, int count,
  27                           int *eof, void *data)
  28 {
  29         int len = 0;
  30
  31         len += snprintf(page + len, count - len, "%s\n", DRIVERVERSION);
  32
  33         *eof = 1;
  34         return len;
  35 }
  36
  37 int proc_get_write_reg(char *page, char **start,
  38                           off_t offset, int count,
  39                           int *eof, void *data)
  40 {
  41         *eof = 1;
  42         return 0;
  43 }
  44
  45 int proc_set_write_reg(struct file *file, const char __user *buffer,
  46                 unsigned long count, void *data)
  47 {
  48         struct net_device *dev = data;
  49         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
  50         char tmp[32];
  51         u32 addr, val, len;
  52
  53         if (count < 3) {
  54                 DBG_88E("argument size is less than 3\n");
  55                 return -EFAULT;
  56         }
  57
  58         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
  59                 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
  60
  61                 if (num !=  3) {
  62                         DBG_88E("invalid write_reg parameter!\n");
  63                         return count;
  64                 }
  65                 switch (len) {
  66                 case 1:
  67                         usb_write8(padapter, addr, (u8)val);
  68                         break;
  69                 case 2:
  70                         usb_write16(padapter, addr, (u16)val);
  71                         break;
  72                 case 4:
  73                         usb_write32(padapter, addr, val);
  74                         break;
  75                 default:
  76                         DBG_88E("error write length =%d", len);
  77                         break;
  78                 }
  79         }
  80         return count;
  81 }
  82
  83 static u32 proc_get_read_addr = 0xeeeeeeee;
  84 static u32 proc_get_read_len = 0x4;
  85
  86 int proc_get_read_reg(char *page, char **start,
  87                           off_t offset, int count,
  88                           int *eof, void *data)
  89 {
  90         struct net_device *dev = data;
  91         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
  92
  93         int len = 0;
  94
  95         if (proc_get_read_addr == 0xeeeeeeee) {
  96                 *eof = 1;
  97                 return len;
  98         }
  99
 100         switch (proc_get_read_len) {
 101         case 1:
 102                 len += snprintf(page + len, count - len, "usb_read8(0x%x)=0x%x\n", proc_get_read_addr, usb_read8(padapter, proc_get_read_addr));
 103                 break;
 104         case 2:
 105                 len += snprintf(page + len, count - len, "usb_read16(0x%x)=0x%x\n", proc_get_read_addr, usb_read16(padapter, proc_get_read_addr));
 106                 break;
 107         case 4:
 108                 len += snprintf(page + len, count - len, "usb_read32(0x%x)=0x%x\n", proc_get_read_addr, usb_read32(padapter, proc_get_read_addr));
 109                 break;
 110         default:
 111                 len += snprintf(page + len, count - len, "error read length=%d\n", proc_get_read_len);
 112                 break;
 113         }
 114
 115         *eof = 1;
 116         return len;
 117 }
 118
 119 int proc_set_read_reg(struct file *file, const char __user *buffer,
 120                 unsigned long count, void *data)
 121 {
 122         char tmp[16];
 123         u32 addr, len;
 124
 125         if (count < 2) {
 126                 DBG_88E("argument size is less than 2\n");
 127                 return -EFAULT;
 128         }
 129
 130         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 131                 int num = sscanf(tmp, "%x %x", &addr, &len);
 132
 133                 if (num !=  2) {
 134                         DBG_88E("invalid read_reg parameter!\n");
 135                         return count;
 136                 }
 137
 138                 proc_get_read_addr = addr;
 139
 140                 proc_get_read_len = len;
 141         }
 142
 143         return count;
 144 }
 145
 146 int proc_get_fwstate(char *page, char **start,
 147                           off_t offset, int count,
 148                           int *eof, void *data)
 149 {
 150         struct net_device *dev = data;
 151         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 152         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 153
 154         int len = 0;
 155
 156         len += snprintf(page + len, count - len, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
 157
 158         *eof = 1;
 159         return len;
 160 }
 161
 162 int proc_get_sec_info(char *page, char **start,
 163                           off_t offset, int count,
 164                           int *eof, void *data)
 165 {
 166         struct net_device *dev = data;
 167         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 168         struct security_priv *psecuritypriv = &padapter->securitypriv;
 169
 170         int len = 0;
 171
 172         len += snprintf(page + len, count - len, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
 173                                                 psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm,
 174                                                 psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus);
 175
 176         *eof = 1;
 177         return len;
 178 }
 179
 180 int proc_get_mlmext_state(char *page, char **start,
 181                           off_t offset, int count,
 182                           int *eof, void *data)
 183 {
 184         struct net_device *dev = data;
 185         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 186         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 187         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 188
 189         int len = 0;
 190
 191         len += snprintf(page + len, count - len, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
 192
 193         *eof = 1;
 194         return len;
 195 }
 196
 197 int proc_get_qos_option(char *page, char **start,
 198                           off_t offset, int count,
 199                           int *eof, void *data)
 200 {
 201         struct net_device *dev = data;
 202         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 203         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 204
 205         int len = 0;
 206
 207         len += snprintf(page + len, count - len, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
 208
 209         *eof = 1;
 210         return len;
 211 }
 212
 213 int proc_get_ht_option(char *page, char **start,
 214                           off_t offset, int count,
 215                           int *eof, void *data)
 216 {
 217         struct net_device *dev = data;
 218         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 219         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 220
 221         int len = 0;
 222
 223         len += snprintf(page + len, count - len, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
 224         *eof = 1;
 225         return len;
 226 }
 227
 228 int proc_get_rf_info(char *page, char **start,
 229                           off_t offset, int count,
 230                           int *eof, void *data)
 231 {
 232         struct net_device *dev = data;
 233         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 234         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 235         int len = 0;
 236
 237         len += snprintf(page + len, count - len, "cur_ch=%d, cur_bw=%d, cur_ch_offset=%d\n",
 238                                         pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 239         *eof = 1;
 240         return len;
 241 }
 242
 243 int proc_get_ap_info(char *page, char **start,
 244                           off_t offset, int count,
 245                           int *eof, void *data)
 246 {
 247         struct sta_info *psta;
 248         struct net_device *dev = data;
 249         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 250         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 251         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 252         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
 253         struct sta_priv *pstapriv = &padapter->stapriv;
 254         int len = 0;
 255
 256         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
 257         if (psta) {
 258                 int i;
 259                 struct recv_reorder_ctrl *preorder_ctrl;
 260
 261                 len += snprintf(page + len, count - len, "SSID=%s\n", cur_network->network.Ssid.Ssid);
 262                 len += snprintf(page + len, count - len, "sta's macaddr:%pM\n", psta->hwaddr);
 263                 len += snprintf(page + len, count - len, "cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 264                 len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
 265                 len += snprintf(page + len, count - len, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
 266                 len += snprintf(page + len, count - len, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
 267                 len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
 268                 len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 269                 len += snprintf(page + len, count - len, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
 270
 271                 for (i = 0; i < 16; i++) {
 272                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 273                         if (preorder_ctrl->enable)
 274                                 len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
 275                 }
 276         } else {
 277                 len += snprintf(page + len, count - len, "can't get sta's macaddr, cur_network's macaddr: %pM\n", cur_network->network.MacAddress);
 278         }
 279
 280         *eof = 1;
 281         return len;
 282 }
 283
 284 int proc_get_adapter_state(char *page, char **start,
 285                           off_t offset, int count,
 286                           int *eof, void *data)
 287 {
 288         struct net_device *dev = data;
 289         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 290         int len = 0;
 291
 292         len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
 293                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
 294
 295         *eof = 1;
 296         return len;
 297 }
 298
 299 int proc_get_trx_info(char *page, char **start,
 300                           off_t offset, int count,
 301                           int *eof, void *data)
 302 {
 303         struct net_device *dev = data;
 304         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 305         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 306         struct recv_priv  *precvpriv = &padapter->recvpriv;
 307         int len = 0;
 308
 309         len += snprintf(page + len, count - len, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d, free_ext_xmitbuf_cnt=%d, free_recvframe_cnt=%d\n",
 310                                 pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmit_extbuf_cnt, precvpriv->free_recvframe_cnt);
 311         len += snprintf(page + len, count - len, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
 312
 313         *eof = 1;
 314         return len;
 315 }
 316
 317 int proc_get_mac_reg_dump1(char *page, char **start,
 318                           off_t offset, int count,
 319                           int *eof, void *data)
 320 {
 321         struct net_device *dev = data;
 322         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 323         int len = 0;
 324         int i, j = 1;
 325
 326         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 327
 328         for (i = 0x0; i < 0x300; i += 4) {
 329                 if (j%4 == 1)
 330                         len += snprintf(page + len, count - len, "0x%02x", i);
 331                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 332                 if ((j++)%4 == 0)
 333                         len += snprintf(page + len, count - len, "\n");
 334         }
 335
 336         *eof = 1;
 337         return len;
 338 }
 339
 340 int proc_get_mac_reg_dump2(char *page, char **start,
 341                           off_t offset, int count,
 342                           int *eof, void *data)
 343 {
 344         struct net_device *dev = data;
 345         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 346         int len = 0;
 347         int i, j = 1;
 348
 349         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 350         memset(page, 0, count);
 351         for (i = 0x300; i < 0x600; i += 4) {
 352                 if (j%4 == 1)
 353                         len += snprintf(page + len, count - len, "0x%02x", i);
 354                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 355                 if ((j++)%4 == 0)
 356                         len += snprintf(page + len, count - len, "\n");
 357         }
 358
 359         *eof = 1;
 360         return len;
 361 }
 362
 363 int proc_get_mac_reg_dump3(char *page, char **start,
 364                           off_t offset, int count,
 365                           int *eof, void *data)
 366 {
 367         struct net_device *dev = data;
 368         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 369         int len = 0;
 370         int i, j = 1;
 371
 372         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 373
 374         for (i = 0x600; i < 0x800; i += 4) {
 375                 if (j%4 == 1)
 376                         len += snprintf(page + len, count - len, "0x%02x", i);
 377                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 378                 if ((j++)%4 == 0)
 379                         len += snprintf(page + len, count - len, "\n");
 380         }
 381
 382         *eof = 1;
 383         return len;
 384 }
 385
 386 int proc_get_bb_reg_dump1(char *page, char **start,
 387                           off_t offset, int count,
 388                           int *eof, void *data)
 389 {
 390         struct net_device *dev = data;
 391         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 392         int len = 0;
 393         int i, j = 1;
 394
 395         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 396         for (i = 0x800; i < 0xB00; i += 4) {
 397                 if (j%4 == 1)
 398                         len += snprintf(page + len, count - len, "0x%02x", i);
 399                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 400                 if ((j++)%4 == 0)
 401                         len += snprintf(page + len, count - len, "\n");
 402         }
 403         *eof = 1;
 404         return len;
 405 }
 406
 407 int proc_get_bb_reg_dump2(char *page, char **start,
 408                           off_t offset, int count,
 409                           int *eof, void *data)
 410 {
 411         struct net_device *dev = data;
 412         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 413         int len = 0;
 414         int i, j = 1;
 415
 416         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 417         for (i = 0xB00; i < 0xE00; i += 4) {
 418                 if (j%4 == 1)
 419                         len += snprintf(page + len, count - len, "0x%02x", i);
 420                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 421                 if ((j++)%4 == 0)
 422                         len += snprintf(page + len, count - len, "\n");
 423         }
 424         *eof = 1;
 425         return len;
 426 }
 427
 428 int proc_get_bb_reg_dump3(char *page, char **start,
 429                           off_t offset, int count,
 430                           int *eof, void *data)
 431 {
 432         struct net_device *dev = data;
 433         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 434         int len = 0;
 435         int i, j = 1;
 436
 437         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 438         for (i = 0xE00; i < 0x1000; i += 4) {
 439                 if (j%4 == 1)
 440                         len += snprintf(page + len, count - len, "0x%02x", i);
 441                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 442                 if ((j++)%4 == 0)
 443                         len += snprintf(page + len, count - len, "\n");
 444         }
 445         *eof = 1;
 446         return len;
 447 }
 448
 449 int proc_get_rf_reg_dump1(char *page, char **start,
 450                           off_t offset, int count,
 451                           int *eof, void *data)
 452 {
 453         struct net_device *dev = data;
 454         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 455         int len = 0;
 456         int i, j = 1, path;
 457         u32 value;
 458
 459         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 460         path = 1;
 461         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 462         for (i = 0; i < 0xC0; i++) {
 463                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 464                 if (j%4 == 1)
 465                         len += snprintf(page + len, count - len, "0x%02x ", i);
 466                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 467                 if ((j++)%4 == 0)
 468                         len += snprintf(page + len, count - len, "\n");
 469         }
 470         *eof = 1;
 471         return len;
 472 }
 473
 474 int proc_get_rf_reg_dump2(char *page, char **start,
 475                           off_t offset, int count,
 476                           int *eof, void *data)
 477 {
 478         struct net_device *dev = data;
 479         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 480         int len = 0;
 481         int i, j = 1, path;
 482         u32 value;
 483
 484         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 485         path = 1;
 486         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 487         for (i = 0xC0; i < 0x100; i++) {
 488                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 489                 if (j%4 == 1)
 490                         len += snprintf(page + len, count - len, "0x%02x ", i);
 491                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 492                 if ((j++)%4 == 0)
 493                         len += snprintf(page + len, count - len, "\n");
 494         }
 495         *eof = 1;
 496         return len;
 497 }
 498
 499 int proc_get_rf_reg_dump3(char *page, char **start,
 500                           off_t offset, int count,
 501                           int *eof, void *data)
 502 {
 503         struct net_device *dev = data;
 504         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 505         int len = 0;
 506         int i, j = 1, path;
 507         u32 value;
 508
 509         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 510         path = 2;
 511         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 512         for (i = 0; i < 0xC0; i++) {
 513                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 514                 if (j%4 == 1)
 515                         len += snprintf(page + len, count - len, "0x%02x ", i);
 516                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 517                 if ((j++)%4 == 0)
 518                         len += snprintf(page + len, count - len, "\n");
 519         }
 520
 521         *eof = 1;
 522         return len;
 523 }
 524
 525
 526 int proc_get_rf_reg_dump4(char *page, char **start,
 527                           off_t offset, int count,
 528                           int *eof, void *data)
 529 {
 530         struct net_device *dev = data;
 531         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 532         int len = 0;
 533         int i, j = 1, path;
 534         u32 value;
 535
 536         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 537         path = 2;
 538         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 539         for (i = 0xC0; i < 0x100; i++) {
 540                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 541                 if (j%4 == 1)
 542                         len += snprintf(page + len, count - len, "0x%02x ", i);
 543                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 544                 if ((j++)%4 == 0)
 545                         len += snprintf(page + len, count - len, "\n");
 546         }
 547         *eof = 1;
 548         return len;
 549 }
 550
 551
 552
 553 int proc_get_rx_signal(char *page, char **start,
 554                           off_t offset, int count,
 555                           int *eof, void *data)
 556 {
 557         struct net_device *dev = data;
 558         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 559         int len = 0;
 560
 561         len = snprintf(page + len, count,
 562                 "rssi:%d\n"
 563                 "rxpwdb:%d\n"
 564                 "signal_strength:%u\n"
 565                 "signal_qual:%u\n"
 566                 "noise:%u\n",
 567                 padapter->recvpriv.rssi,
 568                 padapter->recvpriv.rxpwdb,
 569                 padapter->recvpriv.signal_strength,
 570                 padapter->recvpriv.signal_qual,
 571                 padapter->recvpriv.noise
 572                 );
 573
 574         *eof = 1;
 575         return len;
 576 }
 577
 578 int proc_set_rx_signal(struct file *file, const char __user *buffer,
 579                 unsigned long count, void *data)
 580 {
 581         struct net_device *dev = data;
 582         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 583         char tmp[32];
 584         u32 is_signal_dbg;
 585         s32 signal_strength;
 586
 587         if (count < 1)
 588                 return -EFAULT;
 589
 590         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 591                 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
 592
 593                 is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
 594                 if (is_signal_dbg && num != 2)
 595                         return count;
 596
 597                 signal_strength = signal_strength > 100 ? 100 : signal_strength;
 598                 signal_strength = signal_strength < 0 ? 0 : signal_strength;
 599
 600                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
 601                 padapter->recvpriv.signal_strength_dbg = signal_strength;
 602
 603                 if (is_signal_dbg)
 604                         DBG_88E("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
 605                 else
 606                         DBG_88E("set %s\n", "HW_SIGNAL_STRENGTH");
 607         }
 608         return count;
 609 }
 610
 611 int proc_get_ht_enable(char *page, char **start,
 612                           off_t offset, int count,
 613                           int *eof, void *data)
 614 {
 615         struct net_device *dev = data;
 616         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 617         struct registry_priv    *pregpriv = &padapter->registrypriv;
 618         int len = 0;
 619
 620         if (pregpriv)
 621                 len += snprintf(page + len, count - len,
 622                         "%d\n",
 623                         pregpriv->ht_enable
 624                         );
 625         *eof = 1;
 626         return len;
 627 }
 628
 629 int proc_set_ht_enable(struct file *file, const char __user *buffer,
 630                 unsigned long count, void *data)
 631 {
 632         struct net_device *dev = data;
 633         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 634         struct registry_priv    *pregpriv = &padapter->registrypriv;
 635         char tmp[32];
 636         s32 mode = 0;
 637
 638         if (count < 1)
 639                 return -EFAULT;
 640
 641         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 642                 if (pregpriv) {
 643                         pregpriv->ht_enable = mode;
 644                         pr_info("ht_enable=%d\n", pregpriv->ht_enable);
 645                 }
 646         }
 647
 648         return count;
 649 }
 650
 651 int proc_get_cbw40_enable(char *page, char **start,
 652                           off_t offset, int count,
 653                           int *eof, void *data)
 654 {
 655         struct net_device *dev = data;
 656         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 657         struct registry_priv    *pregpriv = &padapter->registrypriv;
 658
 659         int len = 0;
 660
 661         if (pregpriv)
 662                 len += snprintf(page + len, count - len,
 663                         "%d\n",
 664                         pregpriv->cbw40_enable
 665                         );
 666
 667         *eof = 1;
 668         return len;
 669 }
 670
 671 int proc_set_cbw40_enable(struct file *file, const char __user *buffer,
 672                 unsigned long count, void *data)
 673 {
 674         struct net_device *dev = data;
 675         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 676         struct registry_priv    *pregpriv = &padapter->registrypriv;
 677         char tmp[32];
 678         s32 mode = 0;
 679
 680         if (count < 1)
 681                 return -EFAULT;
 682
 683         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 684                 if (pregpriv) {
 685                         pregpriv->cbw40_enable = mode;
 686                         pr_info("cbw40_enable=%d\n", mode);
 687                 }
 688         }
 689         return count;
 690 }
 691
 692 int proc_get_ampdu_enable(char *page, char **start,
 693                           off_t offset, int count,
 694                           int *eof, void *data)
 695 {
 696         struct net_device *dev = data;
 697         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 698         struct registry_priv    *pregpriv = &padapter->registrypriv;
 699
 700         int len = 0;
 701
 702         if (pregpriv)
 703                 len += snprintf(page + len, count - len,
 704                         "%d\n",
 705                         pregpriv->ampdu_enable
 706                         );
 707
 708         *eof = 1;
 709         return len;
 710 }
 711
 712 int proc_set_ampdu_enable(struct file *file, const char __user *buffer,
 713                 unsigned long count, void *data)
 714 {
 715         struct net_device *dev = data;
 716         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 717         struct registry_priv    *pregpriv = &padapter->registrypriv;
 718         char tmp[32];
 719         s32 mode = 0;
 720
 721         if (count < 1)
 722                 return -EFAULT;
 723
 724         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 725                 if (pregpriv) {
 726                         pregpriv->ampdu_enable = mode;
 727                         pr_info("ampdu_enable=%d\n", mode);
 728                 }
 729         }
 730         return count;
 731 }
 732
 733 int proc_get_two_path_rssi(char *page, char **start,
 734                           off_t offset, int count,
 735                           int *eof, void *data)
 736 {
 737         struct net_device *dev = data;
 738         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 739
 740         int len = 0;
 741
 742         if (padapter)
 743                 len += snprintf(page + len, count - len,
 744                         "%d %d\n",
 745                         padapter->recvpriv.RxRssi[0],
 746                         padapter->recvpriv.RxRssi[1]
 747                         );
 748
 749         *eof = 1;
 750         return len;
 751 }
 752
 753 int proc_get_rx_stbc(char *page, char **start,
 754                           off_t offset, int count,
 755                           int *eof, void *data)
 756 {
 757         struct net_device *dev = data;
 758         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 759         struct registry_priv    *pregpriv = &padapter->registrypriv;
 760
 761         int len = 0;
 762
 763         if (pregpriv)
 764                 len += snprintf(page + len, count - len,
 765                         "%d\n",
 766                         pregpriv->rx_stbc
 767                         );
 768
 769         *eof = 1;
 770         return len;
 771 }
 772
 773 int proc_set_rx_stbc(struct file *file, const char __user *buffer,
 774                 unsigned long count, void *data)
 775 {
 776         struct net_device *dev = data;
 777         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 778         struct registry_priv    *pregpriv = &padapter->registrypriv;
 779         char tmp[32];
 780         u32 mode = 0;
 781
 782         if (count < 1)
 783                 return -EFAULT;
 784
 785         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 786                 if (pregpriv) {
 787                         pregpriv->rx_stbc = mode;
 788                         netdev_info(dev, "rx_stbc=%d\n", mode);
 789                 }
 790         }
 791         return count;
 792 }
 793
 794 int proc_get_rssi_disp(char *page, char **start,
 795                           off_t offset, int count,
 796                           int *eof, void *data)
 797 {
 798         *eof = 1;
 799         return 0;
 800 }
 801
 802 int proc_set_rssi_disp(struct file *file, const char __user *buffer,
 803                 unsigned long count, void *data)
 804 {
 805         struct net_device *dev = data;
 806         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 807         char tmp[32];
 808         u32 enable = 0;
 809
 810         if (count < 1) {
 811                 DBG_88E("argument size is less than 1\n");
 812                 return -EFAULT;
 813         }
 814
 815         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 816                 int num = sscanf(tmp, "%x", &enable);
 817
 818                 if (num !=  1) {
 819                         DBG_88E("invalid set_rssi_disp parameter!\n");
 820                         return count;
 821                 }
 822
 823                 if (enable) {
 824                         DBG_88E("Turn On Rx RSSI Display Function\n");
 825                         padapter->bRxRSSIDisplay = enable;
 826                 } else {
 827                         DBG_88E("Turn Off Rx RSSI Display Function\n");
 828                         padapter->bRxRSSIDisplay = 0;
 829                 }
 830         }
 831         return count;
 832 }
 833
 834 #ifdef CONFIG_88EU_AP_MODE
 835
 836 int proc_get_all_sta_info(char *page, char **start,
 837                           off_t offset, int count,
 838                           int *eof, void *data)
 839 {
 840         struct sta_info *psta;
 841         struct net_device *dev = data;
 842         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 843         struct sta_priv *pstapriv = &padapter->stapriv;
 844         int i, j;
 845         struct list_head *plist, *phead;
 846         struct recv_reorder_ctrl *preorder_ctrl;
 847         int len = 0;
 848
 849
 850         len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
 851
 852         spin_lock_bh(&pstapriv->sta_hash_lock);
 853
 854         for (i = 0; i < NUM_STA; i++) {
 855                 phead = &(pstapriv->sta_hash[i]);
 856                 plist = phead->next;
 857
 858                 while (phead != plist) {
 859                         psta = container_of(plist, struct sta_info, hash_list);
 860
 861                         plist = plist->next;
 862
 863                         len += snprintf(page + len, count - len, "sta's macaddr: %pM\n", psta->hwaddr);
 864                         len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
 865                         len += snprintf(page + len, count - len, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
 866                         len += snprintf(page + len, count - len, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
 867                         len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
 868                         len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 869                         len += snprintf(page + len, count - len, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
 870                         len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len);
 871                         len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability);
 872                         len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags);
 873                         len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk);
 874                         len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
 875                         len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
 876                         len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info);
 877                         len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
 878
 879                         for (j = 0; j < 16; j++) {
 880                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
 881                                 if (preorder_ctrl->enable)
 882                                         len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
 883                         }
 884                 }
 885         }
 886         spin_unlock_bh(&pstapriv->sta_hash_lock);
 887
 888         *eof = 1;
 889         return len;
 890 }
 891 #endif
 892
 893 int proc_get_best_channel(char *page, char **start,
 894                           off_t offset, int count,
 895                           int *eof, void *data)
 896 {
 897         struct net_device *dev = data;
 898         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 899         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 900         int len = 0;
 901         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
 902
 903         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 904                 if (pmlmeext->channel_set[i].ChannelNum == 1)
 905                         index_24G = i;
 906                 if (pmlmeext->channel_set[i].ChannelNum == 36)
 907                         index_5G = i;
 908         }
 909
 910         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 911                 /*  2.4G */
 912                 if (pmlmeext->channel_set[i].ChannelNum == 6) {
 913                         if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
 914                                 index_24G = i;
 915                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
 916                         }
 917                 }
 918
 919                 /*  5G */
 920                 if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
 921                     pmlmeext->channel_set[i].ChannelNum < 140) {
 922                         /*  Find primary channel */
 923                         if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
 924                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 925                                 index_5G = i;
 926                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 927                         }
 928                 }
 929
 930                 if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
 931                     pmlmeext->channel_set[i].ChannelNum < 165) {
 932                         /*  find primary channel */
 933                         if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
 934                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 935                                 index_5G = i;
 936                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 937                         }
 938                 }
 939                 /*  debug */
 940                 len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
 941                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
 942         }
 943
 944         len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
 945         len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);
 946
 947         *eof = 1;
 948         return len;
 949 }