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
 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 = clamp(signal_strength, 0, 100);
 598
 599                 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
 600                 padapter->recvpriv.signal_strength_dbg = signal_strength;
 601
 602                 if (is_signal_dbg)
 603                         DBG_88E("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
 604                 else
 605                         DBG_88E("set %s\n", "HW_SIGNAL_STRENGTH");
 606         }
 607         return count;
 608 }
 609
 610 int proc_get_ht_enable(char *page, char **start,
 611                           off_t offset, int count,
 612                           int *eof, void *data)
 613 {
 614         struct net_device *dev = data;
 615         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 616         struct registry_priv    *pregpriv = &padapter->registrypriv;
 617         int len = 0;
 618
 619         if (pregpriv)
 620                 len += snprintf(page + len, count - len,
 621                         "%d\n",
 622                         pregpriv->ht_enable
 623                         );
 624         *eof = 1;
 625         return len;
 626 }
 627
 628 int proc_set_ht_enable(struct file *file, const char __user *buffer,
 629                 unsigned long count, void *data)
 630 {
 631         struct net_device *dev = data;
 632         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 633         struct registry_priv    *pregpriv = &padapter->registrypriv;
 634         char tmp[32];
 635         s32 mode = 0;
 636
 637         if (count < 1)
 638                 return -EFAULT;
 639
 640         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 641                 if (pregpriv) {
 642                         pregpriv->ht_enable = mode;
 643                         pr_info("ht_enable=%d\n", pregpriv->ht_enable);
 644                 }
 645         }
 646
 647         return count;
 648 }
 649
 650 int proc_get_cbw40_enable(char *page, char **start,
 651                           off_t offset, int count,
 652                           int *eof, void *data)
 653 {
 654         struct net_device *dev = data;
 655         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 656         struct registry_priv    *pregpriv = &padapter->registrypriv;
 657
 658         int len = 0;
 659
 660         if (pregpriv)
 661                 len += snprintf(page + len, count - len,
 662                         "%d\n",
 663                         pregpriv->cbw40_enable
 664                         );
 665
 666         *eof = 1;
 667         return len;
 668 }
 669
 670 int proc_set_cbw40_enable(struct file *file, const char __user *buffer,
 671                 unsigned long count, void *data)
 672 {
 673         struct net_device *dev = data;
 674         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 675         struct registry_priv    *pregpriv = &padapter->registrypriv;
 676         char tmp[32];
 677         s32 mode = 0;
 678
 679         if (count < 1)
 680                 return -EFAULT;
 681
 682         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 683                 if (pregpriv) {
 684                         pregpriv->cbw40_enable = mode;
 685                         pr_info("cbw40_enable=%d\n", mode);
 686                 }
 687         }
 688         return count;
 689 }
 690
 691 int proc_get_ampdu_enable(char *page, char **start,
 692                           off_t offset, int count,
 693                           int *eof, void *data)
 694 {
 695         struct net_device *dev = data;
 696         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 697         struct registry_priv    *pregpriv = &padapter->registrypriv;
 698
 699         int len = 0;
 700
 701         if (pregpriv)
 702                 len += snprintf(page + len, count - len,
 703                         "%d\n",
 704                         pregpriv->ampdu_enable
 705                         );
 706
 707         *eof = 1;
 708         return len;
 709 }
 710
 711 int proc_set_ampdu_enable(struct file *file, const char __user *buffer,
 712                 unsigned long count, void *data)
 713 {
 714         struct net_device *dev = data;
 715         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 716         struct registry_priv    *pregpriv = &padapter->registrypriv;
 717         char tmp[32];
 718         s32 mode = 0;
 719
 720         if (count < 1)
 721                 return -EFAULT;
 722
 723         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 724                 if (pregpriv) {
 725                         pregpriv->ampdu_enable = mode;
 726                         pr_info("ampdu_enable=%d\n", mode);
 727                 }
 728         }
 729         return count;
 730 }
 731
 732 int proc_get_two_path_rssi(char *page, char **start,
 733                           off_t offset, int count,
 734                           int *eof, void *data)
 735 {
 736         struct net_device *dev = data;
 737         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 738
 739         int len = 0;
 740
 741         if (padapter)
 742                 len += snprintf(page + len, count - len,
 743                         "%d %d\n",
 744                         padapter->recvpriv.RxRssi[0],
 745                         padapter->recvpriv.RxRssi[1]
 746                         );
 747
 748         *eof = 1;
 749         return len;
 750 }
 751
 752 int proc_get_rx_stbc(char *page, char **start,
 753                           off_t offset, int count,
 754                           int *eof, void *data)
 755 {
 756         struct net_device *dev = data;
 757         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 758         struct registry_priv    *pregpriv = &padapter->registrypriv;
 759
 760         int len = 0;
 761
 762         if (pregpriv)
 763                 len += snprintf(page + len, count - len,
 764                         "%d\n",
 765                         pregpriv->rx_stbc
 766                         );
 767
 768         *eof = 1;
 769         return len;
 770 }
 771
 772 int proc_set_rx_stbc(struct file *file, const char __user *buffer,
 773                 unsigned long count, void *data)
 774 {
 775         struct net_device *dev = data;
 776         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 777         struct registry_priv    *pregpriv = &padapter->registrypriv;
 778         char tmp[32];
 779         u32 mode = 0;
 780
 781         if (count < 1)
 782                 return -EFAULT;
 783
 784         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 785                 if (pregpriv) {
 786                         pregpriv->rx_stbc = mode;
 787                         netdev_info(dev, "rx_stbc=%d\n", mode);
 788                 }
 789         }
 790         return count;
 791 }
 792
 793 int proc_get_rssi_disp(char *page, char **start,
 794                           off_t offset, int count,
 795                           int *eof, void *data)
 796 {
 797         *eof = 1;
 798         return 0;
 799 }
 800
 801 int proc_set_rssi_disp(struct file *file, const char __user *buffer,
 802                 unsigned long count, void *data)
 803 {
 804         struct net_device *dev = data;
 805         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 806         char tmp[32];
 807         u32 enable = 0;
 808
 809         if (count < 1) {
 810                 DBG_88E("argument size is less than 1\n");
 811                 return -EFAULT;
 812         }
 813
 814         if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
 815                 int num = sscanf(tmp, "%x", &enable);
 816
 817                 if (num !=  1) {
 818                         DBG_88E("invalid set_rssi_disp parameter!\n");
 819                         return count;
 820                 }
 821
 822                 if (enable) {
 823                         DBG_88E("Turn On Rx RSSI Display Function\n");
 824                         padapter->bRxRSSIDisplay = enable;
 825                 } else {
 826                         DBG_88E("Turn Off Rx RSSI Display Function\n");
 827                         padapter->bRxRSSIDisplay = 0;
 828                 }
 829         }
 830         return count;
 831 }
 832
 833 #ifdef CONFIG_88EU_AP_MODE
 834
 835 int proc_get_all_sta_info(char *page, char **start,
 836                           off_t offset, int count,
 837                           int *eof, void *data)
 838 {
 839         struct sta_info *psta;
 840         struct net_device *dev = data;
 841         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 842         struct sta_priv *pstapriv = &padapter->stapriv;
 843         int i, j;
 844         struct list_head *plist, *phead;
 845         struct recv_reorder_ctrl *preorder_ctrl;
 846         int len = 0;
 847
 848
 849         len += snprintf(page + len, count - len, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
 850
 851         spin_lock_bh(&pstapriv->sta_hash_lock);
 852
 853         for (i = 0; i < NUM_STA; i++) {
 854                 phead = &(pstapriv->sta_hash[i]);
 855                 plist = phead->next;
 856
 857                 while (phead != plist) {
 858                         psta = container_of(plist, struct sta_info, hash_list);
 859
 860                         plist = plist->next;
 861
 862                         len += snprintf(page + len, count - len, "sta's macaddr: %pM\n", psta->hwaddr);
 863                         len += snprintf(page + len, count - len, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
 864                         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);
 865                         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);
 866                         len += snprintf(page + len, count - len, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
 867                         len += snprintf(page + len, count - len, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
 868                         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);
 869                         len += snprintf(page + len, count - len, "sleepq_len=%d\n", psta->sleepq_len);
 870                         len += snprintf(page + len, count - len, "capability=0x%x\n", psta->capability);
 871                         len += snprintf(page + len, count - len, "flags=0x%x\n", psta->flags);
 872                         len += snprintf(page + len, count - len, "wpa_psk=0x%x\n", psta->wpa_psk);
 873                         len += snprintf(page + len, count - len, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
 874                         len += snprintf(page + len, count - len, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
 875                         len += snprintf(page + len, count - len, "qos_info=0x%x\n", psta->qos_info);
 876                         len += snprintf(page + len, count - len, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
 877
 878                         for (j = 0; j < 16; j++) {
 879                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
 880                                 if (preorder_ctrl->enable)
 881                                         len += snprintf(page + len, count - len, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
 882                         }
 883                 }
 884         }
 885         spin_unlock_bh(&pstapriv->sta_hash_lock);
 886
 887         *eof = 1;
 888         return len;
 889 }
 890 #endif
 891
 892 int proc_get_best_channel(char *page, char **start,
 893                           off_t offset, int count,
 894                           int *eof, void *data)
 895 {
 896         struct net_device *dev = data;
 897         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 898         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 899         int len = 0;
 900         u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
 901
 902         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 903                 if (pmlmeext->channel_set[i].ChannelNum == 1)
 904                         index_24G = i;
 905                 if (pmlmeext->channel_set[i].ChannelNum == 36)
 906                         index_5G = i;
 907         }
 908
 909         for (i = 0; pmlmeext->channel_set[i].ChannelNum != 0; i++) {
 910                 /*  2.4G */
 911                 if (pmlmeext->channel_set[i].ChannelNum == 6) {
 912                         if (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count) {
 913                                 index_24G = i;
 914                                 best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
 915                         }
 916                 }
 917
 918                 /*  5G */
 919                 if (pmlmeext->channel_set[i].ChannelNum >= 36 &&
 920                     pmlmeext->channel_set[i].ChannelNum < 140) {
 921                         /*  Find primary channel */
 922                         if (((pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0) &&
 923                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 924                                 index_5G = i;
 925                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 926                         }
 927                 }
 928
 929                 if (pmlmeext->channel_set[i].ChannelNum >= 149 &&
 930                     pmlmeext->channel_set[i].ChannelNum < 165) {
 931                         /*  find primary channel */
 932                         if (((pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0) &&
 933                             (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count)) {
 934                                 index_5G = i;
 935                                 best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
 936                         }
 937                 }
 938                 /*  debug */
 939                 len += snprintf(page + len, count - len, "The rx cnt of channel %3d = %d\n",
 940                                         pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
 941         }
 942
 943         len += snprintf(page + len, count - len, "best_channel_5G = %d\n", best_channel_5G);
 944         len += snprintf(page + len, count - len, "best_channel_24G = %d\n", best_channel_24G);
 945
 946         *eof = 1;
 947         return len;
 948 }