kernel/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         len += snprintf(page + len, count - len, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
 223         *eof = 1;
 224         return len;
 225 }
 226
 227 int proc_get_rf_info(char *page, char **start,
 228                           off_t offset, int count,
 229                           int *eof, void *data)
 230 {
 231         struct net_device *dev = data;
 232         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 233         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 234         int len = 0;
 235
 236         len += snprintf(page + len, count - len, "cur_ch=%d, cur_bw=%d, cur_ch_offset=%d\n",
 237                                         pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
 238         *eof = 1;
 239         return len;
 240 }
 241
 242 int proc_get_ap_info(char *page, char **start,
 243                           off_t offset, int count,
 244                           int *eof, void *data)
 245 {
 246         struct sta_info *psta;
 247         struct net_device *dev = data;
 248         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 249         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 250         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 251         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
 252         struct sta_priv *pstapriv = &padapter->stapriv;
 253         int len = 0;
 254
 255         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
 256         if (psta) {
 257                 int i;
 258                 struct recv_reorder_ctrl *preorder_ctrl;
 259
 260                 len += snprintf(page + len, count - len, "SSID=%s\n", cur_network->network.Ssid.Ssid);
 261                 len += snprintf(page + len, count - len, "sta's macaddr:%pM\n", psta->hwaddr);
 262                 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);
 263                 len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
 264                 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);
 265                 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);
 266                 len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
 267                 len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 268                 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);
 269
 270                 for (i = 0; i < 16; i++) {
 271                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 272                         if (preorder_ctrl->enable)
 273                                 len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
 274                 }
 275         } else {
 276                 len += snprintf(page + len, count - len, "can't get sta's macaddr, cur_network's macaddr: %pM\n", cur_network->network.MacAddress);
 277         }
 278
 279         *eof = 1;
 280         return len;
 281 }
 282
 283 int proc_get_adapter_state(char *page, char **start,
 284                           off_t offset, int count,
 285                           int *eof, void *data)
 286 {
 287         struct net_device *dev = data;
 288         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 289         int len = 0;
 290
 291         len += snprintf(page + len, count - len, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
 292                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
 293
 294         *eof = 1;
 295         return len;
 296 }
 297
 298 int proc_get_trx_info(char *page, char **start,
 299                           off_t offset, int count,
 300                           int *eof, void *data)
 301 {
 302         struct net_device *dev = data;
 303         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 304         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 305         struct recv_priv  *precvpriv = &padapter->recvpriv;
 306         int len = 0;
 307
 308         len += snprintf(page + len, count - len, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d, free_ext_xmitbuf_cnt=%d, free_recvframe_cnt=%d\n",
 309                                 pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt, pxmitpriv->free_xmit_extbuf_cnt, precvpriv->free_recvframe_cnt);
 310         len += snprintf(page + len, count - len, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
 311
 312         *eof = 1;
 313         return len;
 314 }
 315
 316 int proc_get_mac_reg_dump1(char *page, char **start,
 317                           off_t offset, int count,
 318                           int *eof, void *data)
 319 {
 320         struct net_device *dev = data;
 321         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 322         int len = 0;
 323         int i, j = 1;
 324
 325         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 326
 327         for (i = 0x0; i < 0x300; i += 4) {
 328                 if (j%4 == 1)
 329                         len += snprintf(page + len, count - len, "0x%02x", i);
 330                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 331                 if ((j++)%4 == 0)
 332                         len += snprintf(page + len, count - len, "\n");
 333         }
 334
 335         *eof = 1;
 336         return len;
 337 }
 338
 339 int proc_get_mac_reg_dump2(char *page, char **start,
 340                           off_t offset, int count,
 341                           int *eof, void *data)
 342 {
 343         struct net_device *dev = data;
 344         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 345         int len = 0;
 346         int i, j = 1;
 347
 348         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 349         memset(page, 0, count);
 350         for (i = 0x300; i < 0x600; i += 4) {
 351                 if (j%4 == 1)
 352                         len += snprintf(page + len, count - len, "0x%02x", i);
 353                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 354                 if ((j++)%4 == 0)
 355                         len += snprintf(page + len, count - len, "\n");
 356         }
 357
 358         *eof = 1;
 359         return len;
 360 }
 361
 362 int proc_get_mac_reg_dump3(char *page, char **start,
 363                           off_t offset, int count,
 364                           int *eof, void *data)
 365 {
 366         struct net_device *dev = data;
 367         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 368         int len = 0;
 369         int i, j = 1;
 370
 371         len += snprintf(page + len, count - len, "\n======= MAC REG =======\n");
 372
 373         for (i = 0x600; i < 0x800; i += 4) {
 374                 if (j%4 == 1)
 375                         len += snprintf(page + len, count - len, "0x%02x", i);
 376                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 377                 if ((j++)%4 == 0)
 378                         len += snprintf(page + len, count - len, "\n");
 379         }
 380
 381         *eof = 1;
 382         return len;
 383 }
 384
 385 int proc_get_bb_reg_dump1(char *page, char **start,
 386                           off_t offset, int count,
 387                           int *eof, void *data)
 388 {
 389         struct net_device *dev = data;
 390         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 391         int len = 0;
 392         int i, j = 1;
 393
 394         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 395         for (i = 0x800; i < 0xB00; i += 4) {
 396                 if (j%4 == 1)
 397                         len += snprintf(page + len, count - len, "0x%02x", i);
 398                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 399                 if ((j++)%4 == 0)
 400                         len += snprintf(page + len, count - len, "\n");
 401         }
 402         *eof = 1;
 403         return len;
 404 }
 405
 406 int proc_get_bb_reg_dump2(char *page, char **start,
 407                           off_t offset, int count,
 408                           int *eof, void *data)
 409 {
 410         struct net_device *dev = data;
 411         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 412         int len = 0;
 413         int i, j = 1;
 414
 415         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 416         for (i = 0xB00; i < 0xE00; i += 4) {
 417                 if (j%4 == 1)
 418                         len += snprintf(page + len, count - len, "0x%02x", i);
 419                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 420                 if ((j++)%4 == 0)
 421                         len += snprintf(page + len, count - len, "\n");
 422         }
 423         *eof = 1;
 424         return len;
 425 }
 426
 427 int proc_get_bb_reg_dump3(char *page, char **start,
 428                           off_t offset, int count,
 429                           int *eof, void *data)
 430 {
 431         struct net_device *dev = data;
 432         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 433         int len = 0;
 434         int i, j = 1;
 435
 436         len += snprintf(page + len, count - len, "\n======= BB REG =======\n");
 437         for (i = 0xE00; i < 0x1000; i += 4) {
 438                 if (j%4 == 1)
 439                         len += snprintf(page + len, count - len, "0x%02x", i);
 440                 len += snprintf(page + len, count - len, " 0x%08x ", usb_read32(padapter, i));
 441                 if ((j++)%4 == 0)
 442                         len += snprintf(page + len, count - len, "\n");
 443         }
 444         *eof = 1;
 445         return len;
 446 }
 447
 448 int proc_get_rf_reg_dump1(char *page, char **start,
 449                           off_t offset, int count,
 450                           int *eof, void *data)
 451 {
 452         struct net_device *dev = data;
 453         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 454         int len = 0;
 455         int i, j = 1, path;
 456         u32 value;
 457
 458         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 459         path = 1;
 460         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 461         for (i = 0; i < 0xC0; i++) {
 462                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 463                 if (j%4 == 1)
 464                         len += snprintf(page + len, count - len, "0x%02x ", i);
 465                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 466                 if ((j++)%4 == 0)
 467                         len += snprintf(page + len, count - len, "\n");
 468         }
 469         *eof = 1;
 470         return len;
 471 }
 472
 473 int proc_get_rf_reg_dump2(char *page, char **start,
 474                           off_t offset, int count,
 475                           int *eof, void *data)
 476 {
 477         struct net_device *dev = data;
 478         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 479         int len = 0;
 480         int i, j = 1, path;
 481         u32 value;
 482
 483         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 484         path = 1;
 485         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 486         for (i = 0xC0; i < 0x100; i++) {
 487                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 488                 if (j%4 == 1)
 489                         len += snprintf(page + len, count - len, "0x%02x ", i);
 490                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 491                 if ((j++)%4 == 0)
 492                         len += snprintf(page + len, count - len, "\n");
 493         }
 494         *eof = 1;
 495         return len;
 496 }
 497
 498 int proc_get_rf_reg_dump3(char *page, char **start,
 499                           off_t offset, int count,
 500                           int *eof, void *data)
 501 {
 502         struct net_device *dev = data;
 503         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 504         int len = 0;
 505         int i, j = 1, path;
 506         u32 value;
 507
 508         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 509         path = 2;
 510         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 511         for (i = 0; i < 0xC0; i++) {
 512                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 513                 if (j%4 == 1)
 514                         len += snprintf(page + len, count - len, "0x%02x ", i);
 515                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 516                 if ((j++)%4 == 0)
 517                         len += snprintf(page + len, count - len, "\n");
 518         }
 519
 520         *eof = 1;
 521         return len;
 522 }
 523
 524
 525 int proc_get_rf_reg_dump4(char *page, char **start,
 526                           off_t offset, int count,
 527                           int *eof, void *data)
 528 {
 529         struct net_device *dev = data;
 530         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 531         int len = 0;
 532         int i, j = 1, path;
 533         u32 value;
 534
 535         len += snprintf(page + len, count - len, "\n======= RF REG =======\n");
 536         path = 2;
 537         len += snprintf(page + len, count - len, "\nRF_Path(%x)\n", path);
 538         for (i = 0xC0; i < 0x100; i++) {
 539                 value = rtw_hal_read_rfreg(padapter, path, i, 0xffffffff);
 540                 if (j%4 == 1)
 541                         len += snprintf(page + len, count - len, "0x%02x ", i);
 542                 len += snprintf(page + len, count - len, " 0x%08x ", value);
 543                 if ((j++)%4 == 0)
 544                         len += snprintf(page + len, count - len, "\n");
 545         }
 546         *eof = 1;
 547         return len;
 548 }
 549
 550
 551
 552 int proc_get_rx_signal(char *page, char **start,
 553                           off_t offset, int count,
 554                           int *eof, void *data)
 555 {
 556         struct net_device *dev = data;
 557         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 558         int len = 0;
 559
 560         len = snprintf(page + len, count,
 561                 "rssi:%d\n"
 562                 "rxpwdb:%d\n"
 563                 "signal_strength:%u\n"
 564                 "signal_qual:%u\n"
 565                 "noise:%u\n",
 566                 padapter->recvpriv.rssi,
 567                 padapter->recvpriv.rxpwdb,
 568                 padapter->recvpriv.signal_strength,
 569                 padapter->recvpriv.signal_qual,
 570                 padapter->recvpriv.noise
 571                 );
 572
 573         *eof = 1;
 574         return len;
 575 }
 576
 577 int proc_set_rx_signal(struct file *file, const char __user *buffer,
 578                 unsigned long count, void *data)
 579 {
 580         struct net_device *dev = data;
 581         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 582         char tmp[32];
 583         u32 is_signal_dbg;
 584         s32 signal_strength;
 585
 586         if (count < 1)
 587                 return -EFAULT;
 588
 589         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 590                 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
 591                 is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
 592                 if (is_signal_dbg && num != 2)
 593                         return count;
 594
 595                 signal_strength = signal_strength > 100 ? 100 : signal_strength;
 596                 signal_strength = signal_strength < 0 ? 0 : signal_strength;
 597
 598                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
 599                 padapter->recvpriv.signal_strength_dbg = signal_strength;
 600
 601                 if (is_signal_dbg)
 602                         DBG_88E("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
 603                 else
 604                         DBG_88E("set %s\n", "HW_SIGNAL_STRENGTH");
 605         }
 606         return count;
 607 }
 608
 609 int proc_get_ht_enable(char *page, char **start,
 610                           off_t offset, int count,
 611                           int *eof, void *data)
 612 {
 613         struct net_device *dev = data;
 614         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 615         struct registry_priv    *pregpriv = &padapter->registrypriv;
 616         int len = 0;
 617
 618         if (pregpriv)
 619                 len += snprintf(page + len, count - len,
 620                         "%d\n",
 621                         pregpriv->ht_enable
 622                         );
 623         *eof = 1;
 624         return len;
 625 }
 626
 627 int proc_set_ht_enable(struct file *file, const char __user *buffer,
 628                 unsigned long count, void *data)
 629 {
 630         struct net_device *dev = data;
 631         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 632         struct registry_priv    *pregpriv = &padapter->registrypriv;
 633         char tmp[32];
 634         s32 mode = 0;
 635
 636         if (count < 1)
 637                 return -EFAULT;
 638
 639         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 640                 if (pregpriv) {
 641                         pregpriv->ht_enable = mode;
 642                         pr_info("ht_enable=%d\n", pregpriv->ht_enable);
 643                 }
 644         }
 645
 646         return count;
 647 }
 648
 649 int proc_get_cbw40_enable(char *page, char **start,
 650                           off_t offset, int count,
 651                           int *eof, void *data)
 652 {
 653         struct net_device *dev = data;
 654         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 655         struct registry_priv    *pregpriv = &padapter->registrypriv;
 656
 657         int len = 0;
 658
 659         if (pregpriv)
 660                 len += snprintf(page + len, count - len,
 661                         "%d\n",
 662                         pregpriv->cbw40_enable
 663                         );
 664
 665         *eof = 1;
 666         return len;
 667 }
 668
 669 int proc_set_cbw40_enable(struct file *file, const char __user *buffer,
 670                 unsigned long count, void *data)
 671 {
 672         struct net_device *dev = data;
 673         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 674         struct registry_priv    *pregpriv = &padapter->registrypriv;
 675         char tmp[32];
 676         s32 mode = 0;
 677
 678         if (count < 1)
 679                 return -EFAULT;
 680
 681         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 682                 if (pregpriv) {
 683                         pregpriv->cbw40_enable = mode;
 684                         pr_info("cbw40_enable=%d\n", mode);
 685                 }
 686         }
 687         return count;
 688 }
 689
 690 int proc_get_ampdu_enable(char *page, char **start,
 691                           off_t offset, int count,
 692                           int *eof, void *data)
 693 {
 694         struct net_device *dev = data;
 695         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 696         struct registry_priv    *pregpriv = &padapter->registrypriv;
 697
 698         int len = 0;
 699
 700         if (pregpriv)
 701                 len += snprintf(page + len, count - len,
 702                         "%d\n",
 703                         pregpriv->ampdu_enable
 704                         );
 705
 706         *eof = 1;
 707         return len;
 708 }
 709
 710 int proc_set_ampdu_enable(struct file *file, const char __user *buffer,
 711                 unsigned long count, void *data)
 712 {
 713         struct net_device *dev = data;
 714         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 715         struct registry_priv    *pregpriv = &padapter->registrypriv;
 716         char tmp[32];
 717         s32 mode = 0;
 718
 719         if (count < 1)
 720                 return -EFAULT;
 721
 722         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 723                 if (pregpriv) {
 724                         pregpriv->ampdu_enable = mode;
 725                         pr_info("ampdu_enable=%d\n", mode);
 726                 }
 727         }
 728         return count;
 729 }
 730
 731 int proc_get_two_path_rssi(char *page, char **start,
 732                           off_t offset, int count,
 733                           int *eof, void *data)
 734 {
 735         struct net_device *dev = data;
 736         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 737
 738         int len = 0;
 739
 740         if (padapter)
 741                 len += snprintf(page + len, count - len,
 742                         "%d %d\n",
 743                         padapter->recvpriv.RxRssi[0],
 744                         padapter->recvpriv.RxRssi[1]
 745                         );
 746
 747         *eof = 1;
 748         return len;
 749 }
 750
 751 int proc_get_rx_stbc(char *page, char **start,
 752                           off_t offset, int count,
 753                           int *eof, void *data)
 754 {
 755         struct net_device *dev = data;
 756         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 757         struct registry_priv    *pregpriv = &padapter->registrypriv;
 758
 759         int len = 0;
 760
 761         if (pregpriv)
 762                 len += snprintf(page + len, count - len,
 763                         "%d\n",
 764                         pregpriv->rx_stbc
 765                         );
 766
 767         *eof = 1;
 768         return len;
 769 }
 770
 771 int proc_set_rx_stbc(struct file *file, const char __user *buffer,
 772                 unsigned long count, void *data)
 773 {
 774         struct net_device *dev = data;
 775         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 776         struct registry_priv    *pregpriv = &padapter->registrypriv;
 777         char tmp[32];
 778         u32 mode = 0;
 779
 780         if (count < 1)
 781                 return -EFAULT;
 782
 783         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 784                 if (pregpriv) {
 785                         pregpriv->rx_stbc = mode;
 786                         netdev_info(dev, "rx_stbc=%d\n", mode);
 787                 }
 788         }
 789         return count;
 790 }
 791
 792 int proc_get_rssi_disp(char *page, char **start,
 793                           off_t offset, int count,
 794                           int *eof, void *data)
 795 {
 796         *eof = 1;
 797         return 0;
 798 }
 799
 800 int proc_set_rssi_disp(struct file *file, const char __user *buffer,
 801                 unsigned long count, void *data)
 802 {
 803         struct net_device *dev = data;
 804         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 805         char tmp[32];
 806         u32 enable = 0;
 807
 808         if (count < 1) {
 809                 DBG_88E("argument size is less than 1\n");
 810                 return -EFAULT;
 811         }
 812
 813         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 814                 int num = sscanf(tmp, "%x", &enable);
 815
 816                 if (num !=  1) {
 817                         DBG_88E("invalid set_rssi_disp parameter!\n");
 818                         return count;
 819                 }
 820
 821                 if (enable) {
 822                         DBG_88E("Turn On Rx RSSI Display Function\n");
 823                         padapter->bRxRSSIDisplay = enable;
 824                 } else {
 825                         DBG_88E("Turn Off Rx RSSI Display Function\n");
 826                         padapter->bRxRSSIDisplay = 0;
 827                 }
 828         }
 829         return count;
 830 }
 831
 832 #ifdef CONFIG_88EU_AP_MODE
 833
 834 int proc_get_all_sta_info(char *page, char **start,
 835                           off_t offset, int count,
 836                           int *eof, void *data)
 837 {
 838         struct sta_info *psta;
 839         struct net_device *dev = data;
 840         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 841         struct sta_priv *pstapriv = &padapter->stapriv;
 842         int i, j;
 843         struct list_head *plist, *phead;
 844         struct recv_reorder_ctrl *preorder_ctrl;
 845         int len = 0;
 846
 847
 848         len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
 849
 850         spin_lock_bh(&pstapriv->sta_hash_lock);
 851
 852         for (i = 0; i < NUM_STA; i++) {
 853                 phead = &(pstapriv->sta_hash[i]);
 854                 plist = phead->next;
 855
 856                 while (phead != plist) {
 857                         psta = container_of(plist, struct sta_info, hash_list);
 858
 859                         plist = plist->next;
 860
 861                         len += snprintf(page + len, count - len, "sta's macaddr: %pM\n", psta->hwaddr);
 862                         len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
 863                         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);
 864                         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);
 865                         len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
 866                         len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 867                         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);
 868                         len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len);
 869                         len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability);
 870                         len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags);
 871                         len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk);
 872                         len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
 873                         len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
 874                         len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info);
 875                         len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
 876
 877                         for (j = 0; j < 16; j++) {
 878                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
 879                                 if (preorder_ctrl->enable)
 880                                         len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
 881                         }
 882                 }
 883         }
 884         spin_unlock_bh(&pstapriv->sta_hash_lock);
 885
 886         *eof = 1;
 887         return len;
 888 }
 889 #endif
 890
 891 int proc_get_best_channel(char *page, char **start,
 892                           off_t offset, int count,
 893                           int *eof, void *data)
 894 {
 895         struct net_device *dev = data;
 896         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 897         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 898         int len = 0;
 899         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
 900
 901         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 902                 if (pmlmeext->channel_set[i].ChannelNum == 1)
 903                         index_24G = i;
 904                 if (pmlmeext->channel_set[i].ChannelNum == 36)
 905                         index_5G = i;
 906         }
 907
 908         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 909                 /*  2.4G */
 910                 if (pmlmeext->channel_set[i].ChannelNum == 6) {
 911                         if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
 912                                 index_24G = i;
 913                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
 914                         }
 915                 }
 916
 917                 /*  5G */
 918                 if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
 919                     pmlmeext->channel_set[i].ChannelNum < 140) {
 920                          /*  Find primary channel */
 921                         if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
 922                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 923                                 index_5G = i;
 924                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 925                         }
 926                 }
 927
 928                 if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
 929                     pmlmeext->channel_set[i].ChannelNum < 165) {
 930                          /*  find primary channel */
 931                         if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
 932                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 933                                 index_5G = i;
 934                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 935                         }
 936                 }
 937                 /*  debug */
 938                 len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
 939                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
 940         }
 941
 942         len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
 943         len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);
 944
 945         *eof = 1;
 946         return len;
 947 }