drivers/net/wireless/rockchip_wlan/rtl8723ds/os_dep/linux/ioctl_mp.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 #if defined(CONFIG_MP_INCLUDED)
  21
  22 #include <drv_types.h>
  23 #include <rtw_mp.h>
  24 #include <rtw_mp_ioctl.h>
  25 #include "../../hal/phydm/phydm_precomp.h"
  26
  27
  28 #if defined(CONFIG_RTL8723B)
  29         #include <rtw_bt_mp.h>
  30 #endif
  31
  32 /*
  33  * Input Format: %s,%d,%d
  34  *      %s is width, could be
  35  *              "b" for 1 byte
  36  *              "w" for WORD (2 bytes)
  37  *              "dw" for DWORD (4 bytes)
  38  *      1st %d is address(offset)
  39  *      2st %d is data to write
  40  */
  41 int rtw_mp_write_reg(struct net_device *dev,
  42                      struct iw_request_info *info,
  43                      struct iw_point *wrqu, char *extra)
  44 {
  45         char *pch, *pnext, *ptmp;
  46         char *width_str;
  47         char width, buf[5];
  48         u32 addr, data;
  49         int ret;
  50         PADAPTER padapter = rtw_netdev_priv(dev);
  51         char input[wrqu->length];
  52
  53         if (copy_from_user(input, wrqu->pointer, wrqu->length))
  54                 return -EFAULT;
  55
  56         _rtw_memset(extra, 0, wrqu->length);
  57
  58         pch = input;
  59
  60         pnext = strpbrk(pch, " ,.-");
  61         if (pnext == NULL)
  62                 return -EINVAL;
  63         *pnext = 0;
  64         width_str = pch;
  65
  66         pch = pnext + 1;
  67         pnext = strpbrk(pch, " ,.-");
  68         if (pnext == NULL)
  69                 return -EINVAL;
  70         *pnext = 0;
  71         /*addr = simple_strtoul(pch, &ptmp, 16);
  72         _rtw_memset(buf, '\0', sizeof(buf));
  73         _rtw_memcpy(buf, pch, pnext-pch);
  74         ret = kstrtoul(buf, 16, &addr);*/
  75         ret = sscanf(pch, "%x", &addr);
  76         if (addr > 0x3FFF)
  77                 return -EINVAL;
  78
  79         pch = pnext + 1;
  80         pnext = strpbrk(pch, " ,.-");
  81         if ((pch - input) >= wrqu->length)
  82                 return -EINVAL;
  83         /*data = simple_strtoul(pch, &ptmp, 16);*/
  84         ret = sscanf(pch, "%x", &data);
  85         RTW_INFO("data=%x,addr=%x\n", (u32)data, (u32)addr);
  86         ret = 0;
  87         width = width_str[0];
  88         switch (width) {
  89         case 'b':
  90                 /* 1 byte*/
  91                 if (data > 0xFF) {
  92                         ret = -EINVAL;
  93                         break;
  94                 }
  95                 rtw_write8(padapter, addr, data);
  96                 break;
  97         case 'w':
  98                 /* 2 bytes*/
  99                 if (data > 0xFFFF) {
 100                         ret = -EINVAL;
 101                         break;
 102                 }
 103                 rtw_write16(padapter, addr, data);
 104                 break;
 105         case 'd':
 106                 /* 4 bytes*/
 107                 rtw_write32(padapter, addr, data);
 108                 break;
 109         default:
 110                 ret = -EINVAL;
 111                 break;
 112         }
 113
 114         return ret;
 115 }
 116
 117
 118 /*
 119  * Input Format: %s,%d
 120  *      %s is width, could be
 121  *              "b" for 1 byte
 122  *              "w" for WORD (2 bytes)
 123  *              "dw" for DWORD (4 bytes)
 124  *      %d is address(offset)
 125  *
 126  * Return:
 127  *      %d for data readed
 128  */
 129 int rtw_mp_read_reg(struct net_device *dev,
 130                     struct iw_request_info *info,
 131                     struct iw_point *wrqu, char *extra)
 132 {
 133         char input[wrqu->length];
 134         char *pch, *pnext, *ptmp;
 135         char *width_str;
 136         char width;
 137         char data[20], tmp[20], buf[3];
 138         u32 addr = 0, strtout = 0;
 139         u32 i = 0, j = 0, ret = 0, data32 = 0;
 140         PADAPTER padapter = rtw_netdev_priv(dev);
 141
 142
 143         if (wrqu->length > 128)
 144                 return -EFAULT;
 145
 146         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 147                 return -EFAULT;
 148
 149         _rtw_memset(extra, 0, wrqu->length);
 150         _rtw_memset(data, '\0', sizeof(data));
 151         _rtw_memset(tmp, '\0', sizeof(tmp));
 152         pch = input;
 153         pnext = strpbrk(pch, " ,.-");
 154         if (pnext == NULL)
 155                 return -EINVAL;
 156         *pnext = 0;
 157         width_str = pch;
 158
 159         pch = pnext + 1;
 160
 161         ret = sscanf(pch, "%x", &addr);
 162         if (addr > 0x3FFF)
 163                 return -EINVAL;
 164
 165         ret = 0;
 166         width = width_str[0];
 167
 168         switch (width) {
 169         case 'b':
 170                 data32 = rtw_read8(padapter, addr);
 171                 RTW_INFO("%x\n", data32);
 172                 sprintf(extra, "%d", data32);
 173                 wrqu->length = strlen(extra);
 174                 break;
 175         case 'w':
 176                 /* 2 bytes*/
 177                 sprintf(data, "%04x\n", rtw_read16(padapter, addr));
 178
 179                 for (i = 0 ; i <= strlen(data) ; i++) {
 180                         if (i % 2 == 0) {
 181                                 tmp[j] = ' ';
 182                                 j++;
 183                         }
 184                         if (data[i] != '\0')
 185                                 tmp[j] = data[i];
 186
 187                         j++;
 188                 }
 189                 pch = tmp;
 190                 RTW_INFO("pch=%s", pch);
 191
 192                 while (*pch != '\0') {
 193                         pnext = strpbrk(pch, " ");
 194                         if (!pnext || ((pnext - tmp) > 4))
 195                                 break;
 196
 197                         pnext++;
 198                         if (*pnext != '\0') {
 199                                 /*strtout = simple_strtoul(pnext , &ptmp, 16);*/
 200                                 ret = sscanf(pnext, "%x", &strtout);
 201                                 sprintf(extra, "%s %d" , extra , strtout);
 202                         } else
 203                                 break;
 204                         pch = pnext;
 205                 }
 206                 wrqu->length = strlen(extra);
 207                 break;
 208         case 'd':
 209                 /* 4 bytes */
 210                 sprintf(data, "%08x", rtw_read32(padapter, addr));
 211                 /*add read data format blank*/
 212                 for (i = 0 ; i <= strlen(data) ; i++) {
 213                         if (i % 2 == 0) {
 214                                 tmp[j] = ' ';
 215                                 j++;
 216                         }
 217                         if (data[i] != '\0')
 218                                 tmp[j] = data[i];
 219
 220                         j++;
 221                 }
 222                 pch = tmp;
 223                 RTW_INFO("pch=%s", pch);
 224
 225                 while (*pch != '\0') {
 226                         pnext = strpbrk(pch, " ");
 227                         if (!pnext)
 228                                 break;
 229
 230                         pnext++;
 231                         if (*pnext != '\0') {
 232                                 ret = sscanf(pnext, "%x", &strtout);
 233                                 sprintf(extra, "%s %d" , extra , strtout);
 234                         } else
 235                                 break;
 236                         pch = pnext;
 237                 }
 238                 wrqu->length = strlen(extra);
 239                 break;
 240
 241         default:
 242                 wrqu->length = 0;
 243                 ret = -EINVAL;
 244                 break;
 245         }
 246
 247         return ret;
 248 }
 249
 250
 251 /*
 252  * Input Format: %d,%x,%x
 253  *      %d is RF path, should be smaller than MAX_RF_PATH_NUMS
 254  *      1st %x is address(offset)
 255  *      2st %x is data to write
 256  */
 257 int rtw_mp_write_rf(struct net_device *dev,
 258                     struct iw_request_info *info,
 259                     struct iw_point *wrqu, char *extra)
 260 {
 261
 262         u32 path, addr, data;
 263         int ret;
 264         PADAPTER padapter = rtw_netdev_priv(dev);
 265         char input[wrqu->length];
 266
 267
 268         _rtw_memset(input, 0, wrqu->length);
 269         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 270                 return -EFAULT;
 271
 272
 273         ret = sscanf(input, "%d,%x,%x", &path, &addr, &data);
 274         if (ret < 3)
 275                 return -EINVAL;
 276
 277         if (path >= GET_HAL_RFPATH_NUM(padapter))
 278                 return -EINVAL;
 279         if (addr > 0xFF)
 280                 return -EINVAL;
 281         if (data > 0xFFFFF)
 282                 return -EINVAL;
 283
 284         _rtw_memset(extra, 0, wrqu->length);
 285
 286         write_rfreg(padapter, path, addr, data);
 287
 288         sprintf(extra, "write_rf completed\n");
 289         wrqu->length = strlen(extra);
 290
 291         return 0;
 292 }
 293
 294
 295 /*
 296  * Input Format: %d,%x
 297  *      %d is RF path, should be smaller than MAX_RF_PATH_NUMS
 298  *      %x is address(offset)
 299  *
 300  * Return:
 301  *      %d for data readed
 302  */
 303 int rtw_mp_read_rf(struct net_device *dev,
 304                    struct iw_request_info *info,
 305                    struct iw_point *wrqu, char *extra)
 306 {
 307         char input[wrqu->length];
 308         char *pch, *pnext, *ptmp;
 309         char data[20], tmp[20], buf[3];
 310         u32 path, addr, strtou;
 311         u32 ret, i = 0 , j = 0;
 312         PADAPTER padapter = rtw_netdev_priv(dev);
 313
 314         if (wrqu->length > 128)
 315                 return -EFAULT;
 316         _rtw_memset(input, 0, wrqu->length);
 317         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 318                 return -EFAULT;
 319
 320         ret = sscanf(input, "%d,%x", &path, &addr);
 321         if (ret < 2)
 322                 return -EINVAL;
 323
 324         if (path >= GET_HAL_RFPATH_NUM(padapter))
 325                 return -EINVAL;
 326         if (addr > 0xFF)
 327                 return -EINVAL;
 328
 329         _rtw_memset(extra, 0, wrqu->length);
 330
 331         sprintf(data, "%08x", read_rfreg(padapter, path, addr));
 332         /*add read data format blank*/
 333         for (i = 0 ; i <= strlen(data) ; i++) {
 334                 if (i % 2 == 0) {
 335                         tmp[j] = ' ';
 336                         j++;
 337                 }
 338                 tmp[j] = data[i];
 339                 j++;
 340         }
 341         pch = tmp;
 342         RTW_INFO("pch=%s", pch);
 343
 344         while (*pch != '\0') {
 345                 pnext = strpbrk(pch, " ");
 346                 if (!pnext)
 347                         break;
 348                 pnext++;
 349                 if (*pnext != '\0') {
 350                         /*strtou =simple_strtoul(pnext , &ptmp, 16);*/
 351                         ret = sscanf(pnext, "%x", &strtou);
 352                         sprintf(extra, "%s %d" , extra , strtou);
 353                 } else
 354                         break;
 355                 pch = pnext;
 356         }
 357         wrqu->length = strlen(extra);
 358
 359         return 0;
 360 }
 361
 362
 363 int rtw_mp_start(struct net_device *dev,
 364                  struct iw_request_info *info,
 365                  struct iw_point *wrqu, char *extra)
 366 {
 367         u8 val8;
 368         PADAPTER padapter = rtw_netdev_priv(dev);
 369         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 370         struct hal_ops *pHalFunc = &padapter->HalFunc;
 371
 372         rtw_pm_set_ips(padapter, IPS_NONE);
 373         LeaveAllPowerSaveMode(padapter);
 374
 375         if (rtw_mi_check_fwstate(padapter, _FW_UNDER_SURVEY))
 376                 rtw_mi_scan_abort(padapter, _FALSE);
 377
 378         if (padapter->registrypriv.mp_mode == 0) {
 379                 rtw_hal_deinit(padapter);
 380                 padapter->registrypriv.mp_mode = 1;
 381 #ifdef CONFIG_RF_POWER_TRIM
 382                 if (!IS_HARDWARE_TYPE_8814A(padapter) && !IS_HARDWARE_TYPE_8822B(padapter)) {
 383                         padapter->registrypriv.RegPwrTrimEnable = 1;
 384                         rtw_hal_read_chip_info(padapter);
 385                 }
 386 #endif /*CONFIG_RF_POWER_TRIM*/
 387                 rtw_hal_init(padapter);
 388         }
 389
 390         if (padapter->registrypriv.mp_mode == 0)
 391                 return -EPERM;
 392
 393         if (padapter->mppriv.mode == MP_OFF) {
 394                 if (mp_start_test(padapter) == _FAIL)
 395                         return -EPERM;
 396                 padapter->mppriv.mode = MP_ON;
 397                 MPT_PwrCtlDM(padapter, 0);
 398         }
 399         padapter->mppriv.bmac_filter = _FALSE;
 400 #ifdef CONFIG_RTL8723B
 401 #ifdef CONFIG_USB_HCI
 402         rtw_write32(padapter, 0x765, 0x0000);
 403         rtw_write32(padapter, 0x948, 0x0280);
 404 #else
 405         rtw_write32(padapter, 0x765, 0x0000);
 406         rtw_write32(padapter, 0x948, 0x0000);
 407 #endif
 408 #ifdef CONFIG_FOR_RTL8723BS_VQ0
 409         rtw_write32(padapter, 0x765, 0x0000);
 410         rtw_write32(padapter, 0x948, 0x0280);
 411 #endif
 412         rtw_write8(padapter, 0x66, 0x27); /*Open BT uart Log*/
 413         rtw_write8(padapter, 0xc50, 0x20); /*for RX init Gain*/
 414 #endif
 415         ODM_Write_DIG(&pHalData->odmpriv, 0x20);
 416
 417         _rtw_memset(extra, 0, wrqu->length);
 418         sprintf(extra, "mp_start ok\n");
 419         wrqu->length = strlen(extra);
 420
 421         return 0;
 422 }
 423
 424
 425
 426 int rtw_mp_stop(struct net_device *dev,
 427                 struct iw_request_info *info,
 428                 struct iw_point *wrqu, char *extra)
 429 {
 430         PADAPTER padapter = rtw_netdev_priv(dev);
 431         struct hal_ops *pHalFunc = &padapter->HalFunc;
 432
 433         if (padapter->registrypriv.mp_mode == 1) {
 434
 435                 MPT_DeInitAdapter(padapter);
 436                 pHalFunc->hal_deinit(padapter);
 437                 padapter->registrypriv.mp_mode = 0;
 438                 pHalFunc->hal_init(padapter);
 439         }
 440
 441         if (padapter->mppriv.mode != MP_OFF) {
 442                 mp_stop_test(padapter);
 443                 padapter->mppriv.mode = MP_OFF;
 444         }
 445         _rtw_memset(extra, 0, wrqu->length);
 446         sprintf(extra, "mp_stop ok\n");
 447         wrqu->length = strlen(extra);
 448
 449         return 0;
 450 }
 451
 452
 453 int rtw_mp_rate(struct net_device *dev,
 454                 struct iw_request_info *info,
 455                 struct iw_point *wrqu, char *extra)
 456 {
 457         u32 rate = MPT_RATE_1M;
 458         u8              input[wrqu->length];
 459         PADAPTER padapter = rtw_netdev_priv(dev);
 460         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
 461
 462         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 463                 return -EFAULT;
 464
 465         rate = rtw_mpRateParseFunc(padapter, input);
 466         padapter->mppriv.rateidx = rate;
 467
 468         if (rate == 0 && strcmp(input, "1M") != 0) {
 469                 rate = rtw_atoi(input);
 470                 padapter->mppriv.rateidx = MRateToHwRate(rate);
 471                 /*if (rate <= 0x7f)
 472                         rate = wifirate2_ratetbl_inx((u8)rate);
 473                 else if (rate < 0xC8)
 474                         rate = (rate - 0x79 + MPT_RATE_MCS0);
 475                 HT  rate 0x80(MCS0)  ~ 0x8F(MCS15) ~ 0x9F(MCS31) 128~159
 476                 VHT1SS~2SS rate 0xA0 (VHT1SS_MCS0 44) ~ 0xB3 (VHT2SS_MCS9 #63) 160~179
 477                 VHT rate 0xB4 (VHT3SS_MCS0 64) ~ 0xC7 (VHT2SS_MCS9 #83) 180~199
 478                 else
 479                 VHT rate 0x90(VHT1SS_MCS0) ~ 0x99(VHT1SS_MCS9) 144~153
 480                 rate =(rate - MPT_RATE_VHT1SS_MCS0);
 481                 */
 482         }
 483         _rtw_memset(extra, 0, wrqu->length);
 484
 485         sprintf(extra, "Set data rate to %s index %d" , input, padapter->mppriv.rateidx);
 486         RTW_INFO("%s: %s rate index=%d\n", __func__, input, padapter->mppriv.rateidx);
 487
 488         if (padapter->mppriv.rateidx >= DESC_RATEVHTSS4MCS9)
 489                 return -EINVAL;
 490
 491         pMptCtx->MptRateIndex = HwRateToMPTRate(padapter->mppriv.rateidx);
 492         SetDataRate(padapter);
 493
 494         wrqu->length = strlen(extra);
 495         return 0;
 496 }
 497
 498
 499 int rtw_mp_channel(struct net_device *dev,
 500                    struct iw_request_info *info,
 501                    struct iw_point *wrqu, char *extra)
 502 {
 503
 504         PADAPTER padapter = rtw_netdev_priv(dev);
 505         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
 506         u8              input[wrqu->length];
 507         u32     channel = 1;
 508         int cur_ch_offset;
 509
 510         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 511                 return -EFAULT;
 512
 513         channel = rtw_atoi(input);
 514         /*RTW_INFO("%s: channel=%d\n", __func__, channel);*/
 515         _rtw_memset(extra, 0, wrqu->length);
 516         sprintf(extra, "Change channel %d to channel %d", padapter->mppriv.channel , channel);
 517         padapter->mppriv.channel = channel;
 518         SetChannel(padapter);
 519         pHalData->CurrentChannel = channel;
 520
 521         wrqu->length = strlen(extra);
 522         return 0;
 523 }
 524
 525
 526 int rtw_mp_bandwidth(struct net_device *dev,
 527                      struct iw_request_info *info,
 528                      struct iw_point *wrqu, char *extra)
 529 {
 530         u32 bandwidth = 0, sg = 0;
 531         int cur_ch_offset;
 532         PADAPTER padapter = rtw_netdev_priv(dev);
 533         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
 534         u8              input[wrqu->length];
 535
 536         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 537                 return -EFAULT;
 538
 539         if (sscanf(input, "40M=%d,shortGI=%d", &bandwidth, &sg) > 0)
 540                 RTW_INFO("%s: bw=%d sg=%d\n", __func__, bandwidth , sg);
 541
 542         if (bandwidth == 1)
 543                 bandwidth = CHANNEL_WIDTH_40;
 544         else if (bandwidth == 2)
 545                 bandwidth = CHANNEL_WIDTH_80;
 546
 547         padapter->mppriv.bandwidth = (u8)bandwidth;
 548         padapter->mppriv.preamble = sg;
 549         _rtw_memset(extra, 0, wrqu->length);
 550         sprintf(extra, "Change BW %d to BW %d\n", pHalData->CurrentChannelBW , bandwidth);
 551
 552         SetBandwidth(padapter);
 553         pHalData->CurrentChannelBW = bandwidth;
 554         /*cur_ch_offset =  rtw_get_offset_by_ch(padapter->mppriv.channel);*/
 555         /*set_channel_bwmode(padapter, padapter->mppriv.channel, cur_ch_offset, bandwidth);*/
 556         wrqu->length = strlen(extra);
 557
 558         return 0;
 559 }
 560
 561
 562 int rtw_mp_txpower_index(struct net_device *dev,
 563                          struct iw_request_info *info,
 564                          struct iw_point *wrqu, char *extra)
 565 {
 566         PADAPTER padapter = rtw_netdev_priv(dev);
 567         char input[wrqu->length];
 568         u32 rfpath;
 569         u32 txpower_inx;
 570
 571         if (wrqu->length > 128)
 572                 return -EFAULT;
 573
 574         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 575                 return -EFAULT;
 576
 577         rfpath = rtw_atoi(input);
 578         txpower_inx = mpt_ProQueryCalTxPower(padapter, rfpath);
 579         sprintf(extra, " %d", txpower_inx);
 580         wrqu->length = strlen(extra);
 581
 582         return 0;
 583 }
 584
 585
 586 int rtw_mp_txpower(struct net_device *dev,
 587                    struct iw_request_info *info,
 588                    struct iw_point *wrqu, char *extra)
 589 {
 590         u32 idx_a = 0, idx_b = 0, idx_c = 0, idx_d = 0, status = 0;
 591         int MsetPower = 1;
 592         u8              input[wrqu->length];
 593
 594         PADAPTER padapter = rtw_netdev_priv(dev);
 595         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
 596
 597         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 598                 return -EFAULT;
 599
 600         MsetPower = strncmp(input, "off", 3);
 601         if (MsetPower == 0) {
 602                 padapter->mppriv.bSetTxPower = 0;
 603                 sprintf(extra, "MP Set power off");
 604         } else {
 605                 if (sscanf(input, "patha=%d,pathb=%d,pathc=%d,pathd=%d", &idx_a, &idx_b, &idx_c, &idx_d) < 3)
 606                         RTW_INFO("Invalid format on line %s ,patha=%d,pathb=%d,pathc=%d,pathd=%d\n", input , idx_a , idx_b , idx_c , idx_d);
 607
 608                 sprintf(extra, "Set power level path_A:%d path_B:%d path_C:%d path_D:%d", idx_a , idx_b , idx_c , idx_d);
 609                 padapter->mppriv.txpoweridx = (u8)idx_a;
 610
 611                 pMptCtx->TxPwrLevel[ODM_RF_PATH_A] = (u8)idx_a;
 612                 pMptCtx->TxPwrLevel[ODM_RF_PATH_B] = (u8)idx_b;
 613                 pMptCtx->TxPwrLevel[ODM_RF_PATH_C] = (u8)idx_c;
 614                 pMptCtx->TxPwrLevel[ODM_RF_PATH_D]  = (u8)idx_d;
 615                 padapter->mppriv.bSetTxPower = 1;
 616
 617                 SetTxPower(padapter);
 618         }
 619
 620         wrqu->length = strlen(extra);
 621         return 0;
 622 }
 623
 624
 625 int rtw_mp_ant_tx(struct net_device *dev,
 626                   struct iw_request_info *info,
 627                   struct iw_point *wrqu, char *extra)
 628 {
 629         u8 i;
 630         u8              input[wrqu->length];
 631         u16 antenna = 0;
 632         PADAPTER padapter = rtw_netdev_priv(dev);
 633         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 634
 635         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 636                 return -EFAULT;
 637
 638         sprintf(extra, "switch Tx antenna to %s", input);
 639
 640         for (i = 0; i < strlen(input); i++) {
 641                 switch (input[i]) {
 642                 case 'a':
 643                         antenna |= ANTENNA_A;
 644                         break;
 645                 case 'b':
 646                         antenna |= ANTENNA_B;
 647                         break;
 648                 case 'c':
 649                         antenna |= ANTENNA_C;
 650                         break;
 651                 case 'd':
 652                         antenna |= ANTENNA_D;
 653                         break;
 654                 }
 655         }
 656         /*antenna |= BIT(extra[i]-'a');*/
 657         RTW_INFO("%s: antenna=0x%x\n", __func__, antenna);
 658         padapter->mppriv.antenna_tx = antenna;
 659         padapter->mppriv.antenna_rx = antenna;
 660         /*RTW_INFO("%s:mppriv.antenna_rx=%d\n", __func__, padapter->mppriv.antenna_tx);*/
 661         pHalData->AntennaTxPath = antenna;
 662
 663         SetAntenna(padapter);
 664
 665         wrqu->length = strlen(extra);
 666         return 0;
 667 }
 668
 669
 670 int rtw_mp_ant_rx(struct net_device *dev,
 671                   struct iw_request_info *info,
 672                   struct iw_point *wrqu, char *extra)
 673 {
 674         u8 i;
 675         u16 antenna = 0;
 676         u8              input[wrqu->length];
 677         PADAPTER padapter = rtw_netdev_priv(dev);
 678         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 679
 680         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 681                 return -EFAULT;
 682         /*RTW_INFO("%s: input=%s\n", __func__, input);*/
 683         _rtw_memset(extra, 0, wrqu->length);
 684
 685         sprintf(extra, "switch Rx antenna to %s", input);
 686
 687         for (i = 0; i < strlen(input); i++) {
 688                 switch (input[i]) {
 689                 case 'a':
 690                         antenna |= ANTENNA_A;
 691                         break;
 692                 case 'b':
 693                         antenna |= ANTENNA_B;
 694                         break;
 695                 case 'c':
 696                         antenna |= ANTENNA_C;
 697                         break;
 698                 case 'd':
 699                         antenna |= ANTENNA_D;
 700                         break;
 701                 }
 702         }
 703
 704         RTW_INFO("%s: antenna=0x%x\n", __func__, antenna);
 705         padapter->mppriv.antenna_tx = antenna;
 706         padapter->mppriv.antenna_rx = antenna;
 707         pHalData->AntennaRxPath = antenna;
 708         /*RTW_INFO("%s:mppriv.antenna_rx=%d\n", __func__, padapter->mppriv.antenna_rx);*/
 709         SetAntenna(padapter);
 710         wrqu->length = strlen(extra);
 711
 712         return 0;
 713 }
 714
 715
 716 int rtw_set_ctx_destAddr(struct net_device *dev,
 717                          struct iw_request_info *info,
 718                          struct iw_point *wrqu, char *extra)
 719 {
 720         int jj, kk = 0;
 721
 722         struct pkt_attrib *pattrib;
 723         struct mp_priv *pmp_priv;
 724         PADAPTER padapter = rtw_netdev_priv(dev);
 725
 726         pmp_priv = &padapter->mppriv;
 727         pattrib = &pmp_priv->tx.attrib;
 728
 729         if (strlen(extra) < 5)
 730                 return _FAIL;
 731
 732         RTW_INFO("%s: in=%s\n", __func__, extra);
 733         for (jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3)
 734                 pattrib->dst[jj] = key_2char2num(extra[kk], extra[kk + 1]);
 735
 736         RTW_INFO("pattrib->dst:%x %x %x %x %x %x\n", pattrib->dst[0], pattrib->dst[1], pattrib->dst[2], pattrib->dst[3], pattrib->dst[4], pattrib->dst[5]);
 737         return 0;
 738 }
 739
 740
 741
 742 int rtw_mp_ctx(struct net_device *dev,
 743                struct iw_request_info *info,
 744                struct iw_point *wrqu, char *extra)
 745 {
 746         u32 pkTx = 1;
 747         int countPkTx = 1, cotuTx = 1, CarrSprTx = 1, scTx = 1, sgleTx = 1, stop = 1;
 748         u32 bStartTest = 1;
 749         u32 count = 0, pktinterval = 0, pktlen = 0;
 750         u8 status;
 751         struct mp_priv *pmp_priv;
 752         struct pkt_attrib *pattrib;
 753         PADAPTER padapter = rtw_netdev_priv(dev);
 754         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 755
 756         pmp_priv = &padapter->mppriv;
 757         pattrib = &pmp_priv->tx.attrib;
 758
 759         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
 760                 return -EFAULT;
 761
 762         RTW_INFO("%s: in=%s\n", __func__, extra);
 763 #ifdef CONFIG_CONCURRENT_MODE
 764         if (!is_primary_adapter(padapter)) {
 765                 sprintf(extra, "Error: MP mode can't support Virtual Adapter, Please to use main Adapter.\n");
 766                 wrqu->length = strlen(extra);
 767                 return 0;
 768         }
 769 #endif
 770         countPkTx = strncmp(extra, "count=", 5); /* strncmp TRUE is 0*/
 771         cotuTx = strncmp(extra, "background", 20);
 772         CarrSprTx = strncmp(extra, "background,cs", 20);
 773         scTx = strncmp(extra, "background,sc", 20);
 774         sgleTx = strncmp(extra, "background,stone", 20);
 775         pkTx = strncmp(extra, "background,pkt", 20);
 776         stop = strncmp(extra, "stop", 4);
 777         if (sscanf(extra, "count=%d,pkt", &count) > 0)
 778                 RTW_INFO("count= %d\n", count);
 779         if (sscanf(extra, "pktinterval=%d", &pktinterval) > 0)
 780                 RTW_INFO("pktinterval= %d\n", pktinterval);
 781
 782         if (sscanf(extra, "pktlen=%d", &pktlen) > 0)
 783                 RTW_INFO("pktlen= %d\n", pktlen);
 784
 785         if (_rtw_memcmp(extra, "destmac=", 8)) {
 786                 wrqu->length -= 8;
 787                 rtw_set_ctx_destAddr(dev, info, wrqu, &extra[8]);
 788                 sprintf(extra, "Set dest mac OK !\n");
 789                 return 0;
 790         }
 791
 792         /*RTW_INFO("%s: count=%d countPkTx=%d cotuTx=%d CarrSprTx=%d scTx=%d sgleTx=%d pkTx=%d stop=%d\n", __func__, count, countPkTx, cotuTx, CarrSprTx, pkTx, sgleTx, scTx, stop);*/
 793         _rtw_memset(extra, '\0', strlen(extra));
 794
 795         if (pktinterval != 0) {
 796                 sprintf(extra, "Pkt Interval = %d", pktinterval);
 797                 padapter->mppriv.pktInterval = pktinterval;
 798                 wrqu->length = strlen(extra);
 799                 return 0;
 800         }
 801         if (pktlen != 0) {
 802                 sprintf(extra, "Pkt len = %d", pktlen);
 803                 pattrib->pktlen = pktlen;
 804                 wrqu->length = strlen(extra);
 805                 return 0;
 806         }
 807         if (stop == 0) {
 808                 bStartTest = 0; /* To set Stop*/
 809                 pmp_priv->tx.stop = 1;
 810                 sprintf(extra, "Stop continuous Tx");
 811                 ODM_Write_DIG(&pHalData->odmpriv, 0x20);
 812         } else {
 813                 bStartTest = 1;
 814                 ODM_Write_DIG(&pHalData->odmpriv, 0x7f);
 815                 if (pmp_priv->mode != MP_ON) {
 816                         if (pmp_priv->tx.stop != 1) {
 817                                 RTW_INFO("%s: MP_MODE != ON %d\n", __func__, pmp_priv->mode);
 818                                 return  -EFAULT;
 819                         }
 820                 }
 821         }
 822
 823         pmp_priv->tx.count = count;
 824
 825         if (pkTx == 0 || countPkTx == 0)
 826                 pmp_priv->mode = MP_PACKET_TX;
 827         if (sgleTx == 0)
 828                 pmp_priv->mode = MP_SINGLE_TONE_TX;
 829         if (cotuTx == 0)
 830                 pmp_priv->mode = MP_CONTINUOUS_TX;
 831         if (CarrSprTx == 0)
 832                 pmp_priv->mode = MP_CARRIER_SUPPRISSION_TX;
 833         if (scTx == 0)
 834                 pmp_priv->mode = MP_SINGLE_CARRIER_TX;
 835
 836         status = rtw_mp_pretx_proc(padapter, bStartTest, extra);
 837
 838         wrqu->length = strlen(extra);
 839         return status;
 840 }
 841
 842
 843
 844 int rtw_mp_disable_bt_coexist(struct net_device *dev,
 845                               struct iw_request_info *info,
 846                               union iwreq_data *wrqu, char *extra)
 847 {
 848         PADAPTER padapter = (PADAPTER)rtw_netdev_priv(dev);
 849         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 850         struct hal_ops *pHalFunc = &padapter->HalFunc;
 851
 852         u8 input[wrqu->data.length];
 853         u32 bt_coexist;
 854
 855         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
 856                 return -EFAULT;
 857
 858         bt_coexist = rtw_atoi(input);
 859
 860         if (bt_coexist == 0) {
 861                 RTW_INFO("Set OID_RT_SET_DISABLE_BT_COEXIST: disable BT_COEXIST\n");
 862 #ifdef CONFIG_BT_COEXIST
 863                 rtw_btcoex_HaltNotify(padapter);
 864                 rtw_btcoex_SetManualControl(padapter, _TRUE);
 865                 /* Force to switch Antenna to WiFi*/
 866                 rtw_write16(padapter, 0x870, 0x300);
 867                 rtw_write16(padapter, 0x860, 0x110);
 868 #endif
 869                 /* CONFIG_BT_COEXIST */
 870         } else {
 871 #ifdef CONFIG_BT_COEXIST
 872                 rtw_btcoex_SetManualControl(padapter, _FALSE);
 873 #endif
 874         }
 875
 876         return 0;
 877 }
 878
 879
 880 int rtw_mp_arx(struct net_device *dev,
 881                struct iw_request_info *info,
 882                struct iw_point *wrqu, char *extra)
 883 {
 884         int bStartRx = 0, bStopRx = 0, bQueryPhy = 0, bQueryMac = 0, bSetBssid = 0;
 885         int bmac_filter = 0, bfilter_init = 0, bmon = 0, bSmpCfg = 0, bloopbk = 0;
 886         u8              input[wrqu->length];
 887         char *pch, *ptmp, *token, *tmp[2] = {0x00, 0x00};
 888         u32 i = 0, ii = 0, jj = 0, kk = 0, cnts = 0, ret;
 889         PADAPTER padapter = rtw_netdev_priv(dev);
 890         struct mp_priv *pmppriv = &padapter->mppriv;
 891         struct dbg_rx_counter rx_counter;
 892
 893         if (copy_from_user(input, wrqu->pointer, wrqu->length))
 894                 return -EFAULT;
 895
 896         RTW_INFO("%s: %s\n", __func__, input);
 897 #ifdef CONFIG_CONCURRENT_MODE
 898         if (!is_primary_adapter(padapter)) {
 899                 sprintf(extra, "Error: MP mode can't support Virtual Adapter, Please to use main Adapter.\n");
 900                 wrqu->length = strlen(extra);
 901                 return 0;
 902         }
 903 #endif
 904         bStartRx = (strncmp(input, "start", 5) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 905         bStopRx = (strncmp(input, "stop", 5) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 906         bQueryPhy = (strncmp(input, "phy", 3) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 907         bQueryMac = (strncmp(input, "mac", 3) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 908         bSetBssid = (strncmp(input, "setbssid=", 8) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 909         /*bfilter_init = (strncmp(input, "filter_init",11)==0)?1:0;*/
 910         bmac_filter = (strncmp(input, "accept_mac", 10) == 0) ? 1 : 0;
 911         bmon = (strncmp(input, "mon=", 4) == 0) ? 1 : 0;
 912         bSmpCfg = (strncmp(input , "smpcfg=" , 7) == 0) ? 1 : 0;
 913         pmppriv->bloopback = (strncmp(input, "loopbk", 6) == 0) ? 1 : 0; /* strncmp TRUE is 0*/
 914
 915         if (bSetBssid == 1) {
 916                 pch = input;
 917                 while ((token = strsep(&pch, "=")) != NULL) {
 918                         if (i > 1)
 919                                 break;
 920                         tmp[i] = token;
 921                         i++;
 922                 }
 923                 if ((tmp[0] != NULL) && (tmp[1] != NULL)) {
 924                         cnts = strlen(tmp[1]) / 2;
 925                         if (cnts < 1)
 926                                 return -EFAULT;
 927                         RTW_INFO("%s: cnts=%d\n", __func__, cnts);
 928                         RTW_INFO("%s: data=%s\n", __func__, tmp[1]);
 929                         for (jj = 0, kk = 0; jj < cnts ; jj++, kk += 2) {
 930                                 pmppriv->network_macaddr[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]);
 931                                 RTW_INFO("network_macaddr[%d]=%x\n", jj, pmppriv->network_macaddr[jj]);
 932                         }
 933                 } else
 934                         return -EFAULT;
 935
 936                 pmppriv->bSetRxBssid = _TRUE;
 937         }
 938
 939         if (bmac_filter) {
 940                 pmppriv->bmac_filter = bmac_filter;
 941                 pch = input;
 942                 while ((token = strsep(&pch, "=")) != NULL) {
 943                         if (i > 1)
 944                                 break;
 945                         tmp[i] = token;
 946                         i++;
 947                 }
 948                 if ((tmp[0] != NULL) && (tmp[1] != NULL)) {
 949                         cnts = strlen(tmp[1]) / 2;
 950                         if (cnts < 1)
 951                                 return -EFAULT;
 952                         RTW_INFO("%s: cnts=%d\n", __func__, cnts);
 953                         RTW_INFO("%s: data=%s\n", __func__, tmp[1]);
 954                         for (jj = 0, kk = 0; jj < cnts ; jj++, kk += 2) {
 955                                 pmppriv->mac_filter[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]);
 956                                 RTW_INFO("%s mac_filter[%d]=%x\n", __func__, jj, pmppriv->mac_filter[jj]);
 957                         }
 958                 } else
 959                         return -EFAULT;
 960
 961         }
 962
 963         if (bStartRx) {
 964                 sprintf(extra, "start");
 965                 SetPacketRx(padapter, bStartRx, _FALSE);
 966         } else if (bStopRx) {
 967                 SetPacketRx(padapter, bStartRx, _FALSE);
 968                 pmppriv->bmac_filter = _FALSE;
 969                 pmppriv->bSetRxBssid = _FALSE;
 970                 sprintf(extra, "Received packet OK:%d CRC error:%d ,Filter out:%d", padapter->mppriv.rx_pktcount, padapter->mppriv.rx_crcerrpktcount, padapter->mppriv.rx_pktcount_filter_out);
 971         } else if (bQueryPhy) {
 972                 _rtw_memset(&rx_counter, 0, sizeof(struct dbg_rx_counter));
 973                 rtw_dump_phy_rx_counters(padapter, &rx_counter);
 974
 975                 RTW_INFO("%s: OFDM_FA =%d\n", __func__, rx_counter.rx_ofdm_fa);
 976                 RTW_INFO("%s: CCK_FA =%d\n", __func__, rx_counter.rx_cck_fa);
 977                 sprintf(extra, "Phy Received packet OK:%d CRC error:%d FA Counter: %d", rx_counter.rx_pkt_ok, rx_counter.rx_pkt_crc_error, rx_counter.rx_cck_fa + rx_counter.rx_ofdm_fa);
 978
 979
 980         } else if (bQueryMac) {
 981                 _rtw_memset(&rx_counter, 0, sizeof(struct dbg_rx_counter));
 982                 rtw_dump_mac_rx_counters(padapter, &rx_counter);
 983                 sprintf(extra, "Mac Received packet OK: %d , CRC error: %d , Drop Packets: %d\n",
 984                         rx_counter.rx_pkt_ok, rx_counter.rx_pkt_crc_error, rx_counter.rx_pkt_drop);
 985
 986         }
 987
 988         if (bmon == 1) {
 989                 ret = sscanf(input, "mon=%d", &bmon);
 990
 991                 if (bmon == 1) {
 992                         pmppriv->rx_bindicatePkt = _TRUE;
 993                         sprintf(extra, "Indicating Receive Packet to network start\n");
 994                 } else {
 995                         pmppriv->rx_bindicatePkt = _FALSE;
 996                         sprintf(extra, "Indicating Receive Packet to network Stop\n");
 997                 }
 998         }
 999         if (bSmpCfg == 1) {
1000                 ret = sscanf(input, "smpcfg=%d", &bSmpCfg);
1001
1002                 if (bSmpCfg == 1) {
1003                         pmppriv->bRTWSmbCfg = _TRUE;
1004                         sprintf(extra , "Indicate By Simple Config Format\n");
1005                         SetPacketRx(padapter, _TRUE, _TRUE);
1006                 } else {
1007                         pmppriv->bRTWSmbCfg = _FALSE;
1008                         sprintf(extra , "Indicate By Normal Format\n");
1009                         SetPacketRx(padapter, _TRUE, _FALSE);
1010                 }
1011         }
1012
1013         if (pmppriv->bloopback == _TRUE) {
1014                 sprintf(extra , "Enter MAC LoopBack mode\n");
1015                 _rtw_write32(padapter, 0x100, 0xB0106FF);
1016                 RTW_INFO("0x100 :0x%x" , _rtw_read32(padapter, 0x100));
1017                 _rtw_write16(padapter, 0x608, 0x30c);
1018                 RTW_INFO("0x100 :0x%x" , _rtw_read32(padapter, 0x608));
1019         }
1020
1021         wrqu->length = strlen(extra) + 1;
1022
1023         return 0;
1024 }
1025
1026
1027 int rtw_mp_trx_query(struct net_device *dev,
1028                      struct iw_request_info *info,
1029                      struct iw_point *wrqu, char *extra)
1030 {
1031         u32 txok, txfail, rxok, rxfail, rxfilterout;
1032         PADAPTER padapter = rtw_netdev_priv(dev);
1033         PMPT_CONTEXT    pMptCtx         =       &(padapter->mppriv.MptCtx);
1034         RT_PMAC_TX_INFO PMacTxInfo      =       pMptCtx->PMacTxInfo;
1035
1036         if (PMacTxInfo.bEnPMacTx == TRUE)
1037                 txok = hal_mpt_query_phytxok(padapter);
1038         else
1039                 txok = padapter->mppriv.tx.sended;
1040
1041         txfail = 0;
1042         rxok = padapter->mppriv.rx_pktcount;
1043         rxfail = padapter->mppriv.rx_crcerrpktcount;
1044         rxfilterout = padapter->mppriv.rx_pktcount_filter_out;
1045
1046         _rtw_memset(extra, '\0', 128);
1047
1048         sprintf(extra, "Tx OK:%d, Tx Fail:%d, Rx OK:%d, CRC error:%d ,Rx Filter out:%d\n", txok, txfail, rxok, rxfail, rxfilterout);
1049
1050         wrqu->length = strlen(extra) + 1;
1051
1052         return 0;
1053 }
1054
1055
1056 int rtw_mp_pwrtrk(struct net_device *dev,
1057                   struct iw_request_info *info,
1058                   struct iw_point *wrqu, char *extra)
1059 {
1060         u8 enable;
1061         u32 thermal;
1062         s32 ret;
1063         PADAPTER padapter = rtw_netdev_priv(dev);
1064         HAL_DATA_TYPE                   *pHalData = GET_HAL_DATA(padapter);
1065         u8              input[wrqu->length];
1066
1067         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1068                 return -EFAULT;
1069
1070         _rtw_memset(extra, 0, wrqu->length);
1071
1072         enable = 1;
1073         if (wrqu->length > 1) {
1074                 /* not empty string*/
1075                 if (strncmp(input, "stop", 4) == 0) {
1076                         enable = 0;
1077                         sprintf(extra, "mp tx power tracking stop");
1078                 } else if (sscanf(input, "ther=%d", &thermal) == 1) {
1079                         ret = SetThermalMeter(padapter, (u8)thermal);
1080                         if (ret == _FAIL)
1081                                 return -EPERM;
1082                         sprintf(extra, "mp tx power tracking start,target value=%d ok", thermal);
1083                 } else
1084                         return -EINVAL;
1085         }
1086
1087         ret = SetPowerTracking(padapter, enable);
1088         if (ret == _FAIL)
1089                 return -EPERM;
1090
1091         wrqu->length = strlen(extra);
1092
1093         return 0;
1094 }
1095
1096
1097
1098 int rtw_mp_psd(struct net_device *dev,
1099                struct iw_request_info *info,
1100                struct iw_point *wrqu, char *extra)
1101 {
1102         PADAPTER padapter = rtw_netdev_priv(dev);
1103         u8              input[wrqu->length];
1104
1105         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1106                 return -EFAULT;
1107
1108         strcpy(extra, input);
1109
1110         wrqu->length = mp_query_psd(padapter, extra);
1111
1112         return 0;
1113 }
1114
1115
1116 int rtw_mp_thermal(struct net_device *dev,
1117                    struct iw_request_info *info,
1118                    struct iw_point *wrqu, char *extra)
1119 {
1120         u8 val;
1121         int bwrite = 1;
1122
1123 #ifdef CONFIG_RTL8188E
1124         u16 addr = EEPROM_THERMAL_METER_88E;
1125 #endif
1126 #if defined(CONFIG_RTL8812A) || defined(CONFIG_RTL8821A) || defined(CONFIG_RTL8814A)
1127         u16 addr = EEPROM_THERMAL_METER_8812;
1128 #endif
1129 #ifdef CONFIG_RTL8192E
1130         u16 addr = EEPROM_THERMAL_METER_8192E;
1131 #endif
1132 #ifdef CONFIG_RTL8723B
1133         u16 addr = EEPROM_THERMAL_METER_8723B;
1134 #endif
1135 #ifdef CONFIG_RTL8703B
1136         u16 addr = EEPROM_THERMAL_METER_8703B;
1137 #endif
1138 #ifdef CONFIG_RTL8723D
1139         u16 addr = EEPROM_THERMAL_METER_8723D;
1140 #endif
1141 #ifdef CONFIG_RTL8188F
1142         u16 addr = EEPROM_THERMAL_METER_8188F;
1143 #endif
1144 #ifdef CONFIG_RTL8822B
1145         u16 addr = EEPROM_THERMAL_METER_8822B;
1146 #endif
1147 #ifdef CONFIG_RTL8821C
1148         u16 addr = EEPROM_THERMAL_METER_8821C;
1149 #endif
1150         u16 cnt = 1;
1151         u16 max_available_size = 0;
1152         PADAPTER padapter = rtw_netdev_priv(dev);
1153
1154         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
1155                 return -EFAULT;
1156
1157         bwrite = strncmp(extra, "write", 6);/* strncmp TRUE is 0*/
1158
1159         GetThermalMeter(padapter, &val);
1160
1161         if (bwrite == 0) {
1162                 /*RTW_INFO("to write val:%d",val);*/
1163                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
1164                 if (2 > max_available_size) {
1165                         RTW_INFO("no available efuse!\n");
1166                         return -EFAULT;
1167                 }
1168                 if (rtw_efuse_map_write(padapter, addr, cnt, &val) == _FAIL) {
1169                         RTW_INFO("rtw_efuse_map_write error\n");
1170                         return -EFAULT;
1171                 }
1172                 sprintf(extra, " efuse write ok :%d", val);
1173         } else
1174                 sprintf(extra, "%d", val);
1175         wrqu->length = strlen(extra);
1176
1177         return 0;
1178 }
1179
1180
1181
1182 int rtw_mp_reset_stats(struct net_device *dev,
1183                        struct iw_request_info *info,
1184                        struct iw_point *wrqu, char *extra)
1185 {
1186         struct mp_priv *pmp_priv;
1187         struct pkt_attrib *pattrib;
1188         PADAPTER padapter = rtw_netdev_priv(dev);
1189
1190         pmp_priv = &padapter->mppriv;
1191
1192         pmp_priv->tx.sended = 0;
1193         pmp_priv->tx_pktcount = 0;
1194         pmp_priv->rx_pktcount = 0;
1195         pmp_priv->rx_pktcount_filter_out = 0;
1196         pmp_priv->rx_crcerrpktcount = 0;
1197
1198         rtw_reset_phy_rx_counters(padapter);
1199         rtw_reset_mac_rx_counters(padapter);
1200
1201         _rtw_memset(extra, 0, wrqu->length);
1202         sprintf(extra, "mp_reset_stats ok\n");
1203         wrqu->length = strlen(extra);
1204
1205         return 0;
1206 }
1207
1208
1209 int rtw_mp_dump(struct net_device *dev,
1210                 struct iw_request_info *info,
1211                 struct iw_point *wrqu, char *extra)
1212 {
1213         struct mp_priv *pmp_priv;
1214         struct pkt_attrib *pattrib;
1215         u32 value;
1216         u8              input[wrqu->length];
1217         u8 rf_type, path_nums = 0;
1218         u32 i, j = 1, path;
1219         PADAPTER padapter = rtw_netdev_priv(dev);
1220
1221         pmp_priv = &padapter->mppriv;
1222
1223         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1224                 return -EFAULT;
1225
1226         if (strncmp(input, "all", 4) == 0) {
1227                 mac_reg_dump(RTW_DBGDUMP, padapter);
1228                 bb_reg_dump(RTW_DBGDUMP, padapter);
1229                 rf_reg_dump(RTW_DBGDUMP, padapter);
1230         }
1231         return 0;
1232 }
1233
1234
1235 int rtw_mp_phypara(struct net_device *dev,
1236                    struct iw_request_info *info,
1237                    struct iw_point *wrqu, char *extra)
1238 {
1239
1240         PADAPTER padapter = rtw_netdev_priv(dev);
1241         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
1242         char    input[wrqu->length];
1243         u32             valxcap, ret;
1244
1245         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1246                 return -EFAULT;
1247
1248         RTW_INFO("%s:iwpriv in=%s\n", __func__, input);
1249
1250         ret = sscanf(input, "xcap=%d", &valxcap);
1251
1252         pHalData->CrystalCap = (u8)valxcap;
1253         hal_set_crystal_cap(padapter , valxcap);
1254
1255         sprintf(extra, "Set xcap=%d", valxcap);
1256         wrqu->length = strlen(extra) + 1;
1257
1258         return 0;
1259
1260 }
1261
1262
1263 int rtw_mp_SetRFPath(struct net_device *dev,
1264                      struct iw_request_info *info,
1265                      struct iw_point *wrqu, char *extra)
1266 {
1267         PADAPTER padapter = rtw_netdev_priv(dev);
1268         char    input[wrqu->length];
1269         int             bMain = 1, bTurnoff = 1;
1270
1271         RTW_INFO("%s:iwpriv in=%s\n", __func__, input);
1272
1273         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1274                 return -EFAULT;
1275
1276         bMain = strncmp(input, "1", 2); /* strncmp TRUE is 0*/
1277         bTurnoff = strncmp(input, "0", 3); /* strncmp TRUE is 0*/
1278
1279         _rtw_memset(extra, 0, wrqu->length);
1280
1281         if (bMain == 0) {
1282                 MP_PHY_SetRFPathSwitch(padapter, _TRUE);
1283                 RTW_INFO("%s:PHY_SetRFPathSwitch=TRUE\n", __func__);
1284                 sprintf(extra, "mp_setrfpath Main\n");
1285
1286         } else if (bTurnoff == 0) {
1287                 MP_PHY_SetRFPathSwitch(padapter, _FALSE);
1288                 RTW_INFO("%s:PHY_SetRFPathSwitch=FALSE\n", __func__);
1289                 sprintf(extra, "mp_setrfpath Aux\n");
1290         }
1291
1292         wrqu->length = strlen(extra);
1293
1294         return 0;
1295 }
1296
1297
1298 int rtw_mp_QueryDrv(struct net_device *dev,
1299                     struct iw_request_info *info,
1300                     union iwreq_data *wrqu, char *extra)
1301 {
1302         PADAPTER padapter = rtw_netdev_priv(dev);
1303         char    input[wrqu->data.length];
1304         int     qAutoLoad = 1;
1305
1306         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
1307
1308         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
1309                 return -EFAULT;
1310         RTW_INFO("%s:iwpriv in=%s\n", __func__, input);
1311
1312         qAutoLoad = strncmp(input, "autoload", 8); /* strncmp TRUE is 0*/
1313
1314         if (qAutoLoad == 0) {
1315                 RTW_INFO("%s:qAutoLoad\n", __func__);
1316
1317                 if (pHalData->bautoload_fail_flag)
1318                         sprintf(extra, "fail");
1319                 else
1320                         sprintf(extra, "ok");
1321         }
1322         wrqu->data.length = strlen(extra) + 1;
1323         return 0;
1324 }
1325
1326
1327 int rtw_mp_PwrCtlDM(struct net_device *dev,
1328                     struct iw_request_info *info,
1329                     struct iw_point *wrqu, char *extra)
1330 {
1331         PADAPTER padapter = rtw_netdev_priv(dev);
1332         u8              input[wrqu->length];
1333         int             bstart = 1;
1334
1335         if (copy_from_user(input, wrqu->pointer, wrqu->length))
1336                 return -EFAULT;
1337
1338         bstart = strncmp(input, "start", 5); /* strncmp TRUE is 0*/
1339         if (bstart == 0) {
1340                 sprintf(extra, "PwrCtlDM start\n");
1341                 MPT_PwrCtlDM(padapter, 1);
1342         } else {
1343                 sprintf(extra, "PwrCtlDM stop\n");
1344                 MPT_PwrCtlDM(padapter, 0);
1345         }
1346         wrqu->length = strlen(extra);
1347
1348         return 0;
1349 }
1350
1351 int rtw_mp_iqk(struct net_device *dev,
1352                  struct iw_request_info *info,
1353                  struct iw_point *wrqu, char *extra)
1354 {
1355         PADAPTER padapter = rtw_netdev_priv(dev);
1356
1357         rtw_mp_trigger_iqk(padapter);
1358
1359         return 0;
1360 }
1361
1362 int rtw_mp_lck(struct net_device *dev,
1363                  struct iw_request_info *info,
1364                  struct iw_point *wrqu, char *extra)
1365 {
1366         PADAPTER padapter = rtw_netdev_priv(dev);
1367
1368         rtw_mp_trigger_lck(padapter);
1369
1370         return 0;
1371 }
1372
1373 int rtw_mp_getver(struct net_device *dev,
1374                   struct iw_request_info *info,
1375                   union iwreq_data *wrqu, char *extra)
1376 {
1377         PADAPTER padapter = rtw_netdev_priv(dev);
1378         struct mp_priv *pmp_priv;
1379
1380         pmp_priv = &padapter->mppriv;
1381
1382         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1383                 return -EFAULT;
1384
1385         sprintf(extra, "rtwpriv=%d\n", RTWPRIV_VER_INFO);
1386         wrqu->data.length = strlen(extra);
1387         return 0;
1388 }
1389
1390
1391 int rtw_mp_mon(struct net_device *dev,
1392                struct iw_request_info *info,
1393                union iwreq_data *wrqu, char *extra)
1394 {
1395         PADAPTER padapter = rtw_netdev_priv(dev);
1396         struct mp_priv *pmp_priv = &padapter->mppriv;
1397         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1398         struct hal_ops *pHalFunc = &padapter->HalFunc;
1399         NDIS_802_11_NETWORK_INFRASTRUCTURE networkType;
1400         int bstart = 1, bstop = 1;
1401
1402         networkType = Ndis802_11Infrastructure;
1403         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1404                 return -EFAULT;
1405
1406         rtw_pm_set_ips(padapter, IPS_NONE);
1407         LeaveAllPowerSaveMode(padapter);
1408
1409 #ifdef CONFIG_MP_INCLUDED
1410         if (init_mp_priv(padapter) == _FAIL)
1411                 RTW_INFO("%s: initialize MP private data Fail!\n", __func__);
1412         padapter->mppriv.channel = 6;
1413
1414         bstart = strncmp(extra, "start", 5); /* strncmp TRUE is 0*/
1415         bstop = strncmp(extra, "stop", 4); /* strncmp TRUE is 0*/
1416         if (bstart == 0) {
1417                 mp_join(padapter, WIFI_FW_ADHOC_STATE);
1418                 SetPacketRx(padapter, _TRUE, _FALSE);
1419                 SetChannel(padapter);
1420                 pmp_priv->rx_bindicatePkt = _TRUE;
1421                 pmp_priv->bRTWSmbCfg = _TRUE;
1422                 sprintf(extra, "monitor mode start\n");
1423         } else if (bstop == 0) {
1424                 SetPacketRx(padapter, _FALSE, _FALSE);
1425                 pmp_priv->rx_bindicatePkt = _FALSE;
1426                 pmp_priv->bRTWSmbCfg = _FALSE;
1427                 padapter->registrypriv.mp_mode = 1;
1428                 pHalFunc->hal_deinit(padapter);
1429                 padapter->registrypriv.mp_mode = 0;
1430                 pHalFunc->hal_init(padapter);
1431                 /*rtw_disassoc_cmd(padapter, 0, _TRUE);*/
1432                 if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1433                         rtw_disassoc_cmd(padapter, 500, _TRUE);
1434                         rtw_indicate_disconnect(padapter, 0, _FALSE);
1435                         /*rtw_free_assoc_resources(padapter, 1);*/
1436                 }
1437                 rtw_pm_set_ips(padapter, IPS_NORMAL);
1438                 sprintf(extra, "monitor mode Stop\n");
1439         }
1440 #endif
1441         wrqu->data.length = strlen(extra);
1442         return 0;
1443 }
1444
1445 int rtw_mp_pretx_proc(PADAPTER padapter, u8 bStartTest, char *extra)
1446 {
1447         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
1448         struct mp_priv *pmp_priv = &padapter->mppriv;
1449         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
1450
1451         switch (pmp_priv->mode) {
1452
1453         case MP_PACKET_TX:
1454                 if (bStartTest == 0) {
1455                         pmp_priv->tx.stop = 1;
1456                         pmp_priv->mode = MP_ON;
1457                         sprintf(extra, "Stop continuous Tx");
1458                 } else if (pmp_priv->tx.stop == 1) {
1459                         sprintf(extra, "%s\nStart continuous DA=ffffffffffff len=1500 count=%u\n", extra, pmp_priv->tx.count);
1460                         pmp_priv->tx.stop = 0;
1461                         SetPacketTx(padapter);
1462                 } else
1463                         return -EFAULT;
1464                 return 0;
1465         case MP_SINGLE_TONE_TX:
1466                 if (bStartTest != 0)
1467                         sprintf(extra, "%s\nStart continuous DA=ffffffffffff len=1500\n infinite=yes.", extra);
1468                 SetSingleToneTx(padapter, (u8)bStartTest);
1469                 break;
1470         case MP_CONTINUOUS_TX:
1471                 if (bStartTest != 0)
1472                         sprintf(extra, "%s\nStart continuous DA=ffffffffffff len=1500\n infinite=yes.", extra);
1473                 SetContinuousTx(padapter, (u8)bStartTest);
1474                 break;
1475         case MP_CARRIER_SUPPRISSION_TX:
1476                 if (bStartTest != 0) {
1477                         if (HwRateToMPTRate(pmp_priv->rateidx) <= MPT_RATE_11M)
1478                                 sprintf(extra, "%s\nStart continuous DA=ffffffffffff len=1500\n infinite=yes.", extra);
1479                         else
1480                                 sprintf(extra, "%s\nSpecify carrier suppression but not CCK rate", extra);
1481                 }
1482                 SetCarrierSuppressionTx(padapter, (u8)bStartTest);
1483                 break;
1484         case MP_SINGLE_CARRIER_TX:
1485                 if (bStartTest != 0)
1486                         sprintf(extra, "%s\nStart continuous DA=ffffffffffff len=1500\n infinite=yes.", extra);
1487                 SetSingleCarrierTx(padapter, (u8)bStartTest);
1488                 break;
1489
1490         default:
1491                 sprintf(extra, "Error! Continuous-Tx is not on-going.");
1492                 return -EFAULT;
1493         }
1494
1495         if (bStartTest == 1 && pmp_priv->mode != MP_ON) {
1496                 struct mp_priv *pmp_priv = &padapter->mppriv;
1497
1498                 if (pmp_priv->tx.stop == 0) {
1499                         pmp_priv->tx.stop = 1;
1500                         rtw_msleep_os(5);
1501                 }
1502 #ifdef CONFIG_80211N_HT
1503                 pmp_priv->tx.attrib.ht_en = 1;
1504 #endif
1505                 pmp_priv->tx.stop = 0;
1506                 pmp_priv->tx.count = 1;
1507                 SetPacketTx(padapter);
1508         } else
1509                 pmp_priv->mode = MP_ON;
1510
1511 #if defined(CONFIG_RTL8812A)
1512         if (IS_HARDWARE_TYPE_8812AU(padapter)) {
1513                 /* <20130425, Kordan> Turn off OFDM Rx to prevent from CCA causing Tx hang.*/
1514                 if (pmp_priv->mode == MP_PACKET_TX)
1515                         PHY_SetBBReg(padapter, rCCAonSec_Jaguar, BIT3, 1);
1516                 else
1517                         PHY_SetBBReg(padapter, rCCAonSec_Jaguar, BIT3, 0);
1518         }
1519 #endif
1520
1521         return 0;
1522 }
1523
1524
1525 int rtw_mp_tx(struct net_device *dev,
1526               struct iw_request_info *info,
1527               union iwreq_data *wrqu, char *extra)
1528 {
1529         PADAPTER padapter = rtw_netdev_priv(dev);
1530         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
1531         struct mp_priv *pmp_priv = &padapter->mppriv;
1532         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
1533         struct registry_priv    *pregistrypriv = &padapter->registrypriv;
1534
1535         u32 bandwidth = 0, sg = 0, channel = 6, txpower = 40, rate = 108, ant = 0, txmode = 1, count = 0;
1536         u8 i = 0, j = 0, bStartTest = 1, status = 0, Idx = 0, tmpU1B = 0;
1537         u16 antenna = 0;
1538
1539         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1540                 return -EFAULT;
1541         RTW_INFO("extra = %s\n", extra);
1542 #ifdef CONFIG_CONCURRENT_MODE
1543         if (!is_primary_adapter(padapter)) {
1544                 sprintf(extra, "Error: MP mode can't support Virtual Adapter, Please to use main Adapter.\n");
1545                 wrqu->data.length = strlen(extra);
1546                 return 0;
1547         }
1548 #endif
1549
1550         if (strncmp(extra, "stop", 3) == 0) {
1551                 bStartTest = 0; /* To set Stop*/
1552                 pmp_priv->tx.stop = 1;
1553                 sprintf(extra, "Stop continuous Tx");
1554                 status = rtw_mp_pretx_proc(padapter, bStartTest, extra);
1555                 wrqu->data.length = strlen(extra);
1556                 return status;
1557         } else if (strncmp(extra, "count", 5) == 0) {
1558                 if (sscanf(extra, "count=%d", &count) < 1)
1559                         RTW_INFO("Got Count=%d]\n", count);
1560                 pmp_priv->tx.count = count;
1561                 return 0;
1562         } else if (strncmp(extra, "setting", 7) == 0) {
1563                 _rtw_memset(extra, 0, wrqu->data.length);
1564                 sprintf(extra, "Current Setting :\n Channel:%d", pmp_priv->channel);
1565                 sprintf(extra, "%s\n Bandwidth:%d", extra, pmp_priv->bandwidth);
1566                 sprintf(extra, "%s\n Rate index:%d", extra, pmp_priv->rateidx);
1567                 sprintf(extra, "%s\n TxPower index:%d", extra, pmp_priv->txpoweridx);
1568                 sprintf(extra, "%s\n Antenna TxPath:%d", extra, pmp_priv->antenna_tx);
1569                 sprintf(extra, "%s\n Antenna RxPath:%d", extra, pmp_priv->antenna_rx);
1570                 sprintf(extra, "%s\n MP Mode:%d", extra, pmp_priv->mode);
1571                 wrqu->data.length = strlen(extra);
1572                 return 0;
1573 #ifdef CONFIG_MP_VHT_HW_TX_MODE
1574         } else if (strncmp(extra, "pmact", 5) == 0) {
1575                 if (strncmp(extra, "pmact=", 6) == 0) {
1576                         _rtw_memset(&pMptCtx->PMacTxInfo, 0, sizeof(pMptCtx->PMacTxInfo));
1577                         if (strncmp(extra, "pmact=start", 11) == 0) {
1578                                 pMptCtx->PMacTxInfo.bEnPMacTx = _TRUE;
1579                                 sprintf(extra, "Set PMac Tx Mode start\n");
1580                         } else {
1581                                 pMptCtx->PMacTxInfo.bEnPMacTx = _FALSE;
1582                                 sprintf(extra, "Set PMac Tx Mode Stop\n");
1583                         }
1584                         if (pMptCtx->bldpc == TRUE)
1585                                 pMptCtx->PMacTxInfo.bLDPC = _TRUE;
1586
1587                         if (pMptCtx->bstbc == TRUE)
1588                                 pMptCtx->PMacTxInfo.bSTBC = _TRUE;
1589
1590                         pMptCtx->PMacTxInfo.bSPreamble = pmp_priv->preamble;
1591                         pMptCtx->PMacTxInfo.bSGI = pmp_priv->preamble;
1592                         pMptCtx->PMacTxInfo.BandWidth = pmp_priv->bandwidth;
1593                         pMptCtx->PMacTxInfo.TX_RATE = HwRateToMPTRate(pmp_priv->rateidx);
1594
1595                         pMptCtx->PMacTxInfo.Mode = pMptCtx->HWTxmode;
1596
1597                         pMptCtx->PMacTxInfo.NDP_sound = FALSE;/*(Adapter.PacketType == NDP_PKT)?TRUE:FALSE;*/
1598
1599                         if (padapter->mppriv.pktInterval == 0)
1600                                 pMptCtx->PMacTxInfo.PacketPeriod = 100;
1601                         else
1602                                 pMptCtx->PMacTxInfo.PacketPeriod = padapter->mppriv.pktInterval;
1603
1604                         if (padapter->mppriv.pktLength < 1000)
1605                                 pMptCtx->PMacTxInfo.PacketLength = 1000;
1606                         else
1607                                 pMptCtx->PMacTxInfo.PacketLength = padapter->mppriv.pktLength;
1608
1609                         pMptCtx->PMacTxInfo.PacketPattern  = rtw_random32() % 0xFF;
1610
1611                         if (padapter->mppriv.tx_pktcount != 0)
1612                                 pMptCtx->PMacTxInfo.PacketCount = padapter->mppriv.tx_pktcount;
1613
1614                         pMptCtx->PMacTxInfo.Ntx = 0;
1615                         for (Idx = 16; Idx < 20; Idx++) {
1616                                 tmpU1B = (padapter->mppriv.antenna_tx >> Idx) & 1;
1617                                 if (tmpU1B)
1618                                         pMptCtx->PMacTxInfo.Ntx++;
1619                         }
1620
1621                         _rtw_memset(pMptCtx->PMacTxInfo.MacAddress, 0xFF, ETH_ALEN);
1622
1623                         PMAC_Get_Pkt_Param(&pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1624
1625                         if (MPT_IS_CCK_RATE(pMptCtx->PMacTxInfo.TX_RATE))
1626
1627                                 CCK_generator(&pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1628                         else {
1629                                 PMAC_Nsym_generator(&pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1630                                 /* 24 BIT*/
1631                                 L_SIG_generator(pMptCtx->PMacPktInfo.N_sym, &pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1632                         }
1633                         /*      48BIT*/
1634                         if (MPT_IS_HT_RATE(pMptCtx->PMacTxInfo.TX_RATE))
1635                                 HT_SIG_generator(&pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1636                         else if (MPT_IS_VHT_RATE(pMptCtx->PMacTxInfo.TX_RATE)) {
1637                                 /*      48BIT*/
1638                                 VHT_SIG_A_generator(&pMptCtx->PMacTxInfo, &pMptCtx->PMacPktInfo);
1639
1640                                 /*      26/27/29 BIT  & CRC 8 BIT*/
1641                                 VHT_SIG_B_generator(&pMptCtx->PMacTxInfo);
1642
1643                                 /* 32 BIT*/
1644                                 VHT_Delimiter_generator(&pMptCtx->PMacTxInfo);
1645                         }
1646
1647                         mpt_ProSetPMacTx(padapter);
1648
1649                 } else if (strncmp(extra, "pmact,mode=", 11) == 0) {
1650                         int txmode = 0;
1651
1652                         if (sscanf(extra, "pmact,mode=%d", &txmode) > 0) {
1653                                 if (txmode == 1) {
1654                                         pMptCtx->HWTxmode = CONTINUOUS_TX;
1655                                         sprintf(extra, "\t Config HW Tx mode = CONTINUOUS_TX\n");
1656                                 } else if (txmode == 2) {
1657                                         pMptCtx->HWTxmode = OFDM_Single_Tone_TX;
1658                                         sprintf(extra, "\t Config HW Tx mode = OFDM_Single_Tone_TX\n");
1659                                 } else {
1660                                         pMptCtx->HWTxmode = PACKETS_TX;
1661                                         sprintf(extra, "\t Config HW Tx mode = PACKETS_TX\n");
1662                                 }
1663                         } else {
1664                                 pMptCtx->HWTxmode = PACKETS_TX;
1665                                 sprintf(extra, "\t Config HW Tx mode=\n 0 = PACKETS_TX\n 1 = CONTINUOUS_TX\n 2 = OFDM_Single_Tone_TX");
1666                         }
1667                 } else if (strncmp(extra, "pmact,", 6) == 0) {
1668                         int PacketPeriod = 0, PacketLength = 0, PacketCout = 0;
1669                         int bldpc = 0, bstbc = 0;
1670
1671                         if (sscanf(extra, "pmact,period=%d", &PacketPeriod) > 0) {
1672                                 padapter->mppriv.pktInterval = PacketPeriod;
1673                                 RTW_INFO("PacketPeriod=%d\n", padapter->mppriv.pktInterval);
1674                                 sprintf(extra, "PacketPeriod [1~255]= %d\n", padapter->mppriv.pktInterval);
1675
1676                         } else if (sscanf(extra, "pmact,length=%d", &PacketLength) > 0) {
1677                                 padapter->mppriv.pktLength = PacketLength;
1678                                 RTW_INFO("PacketPeriod=%d\n", padapter->mppriv.pktLength);
1679                                 sprintf(extra, "PacketLength[~65535]=%d\n", padapter->mppriv.pktLength);
1680
1681                         } else if (sscanf(extra, "pmact,count=%d", &PacketCout) > 0) {
1682                                 padapter->mppriv.tx_pktcount = PacketCout;
1683                                 RTW_INFO("Packet Cout =%d\n", padapter->mppriv.tx_pktcount);
1684                                 sprintf(extra, "Packet Cout =%d\n", padapter->mppriv.tx_pktcount);
1685
1686                         } else if (sscanf(extra, "pmact,ldpc=%d", &bldpc) > 0) {
1687                                 pMptCtx->bldpc = bldpc;
1688                                 RTW_INFO("Set LDPC =%d\n", pMptCtx->bldpc);
1689                                 sprintf(extra, "Set LDPC =%d\n", pMptCtx->bldpc);
1690
1691                         } else if (sscanf(extra, "pmact,stbc=%d", &bstbc) > 0) {
1692                                 pMptCtx->bstbc = bstbc;
1693                                 RTW_INFO("Set STBC =%d\n", pMptCtx->bstbc);
1694                                 sprintf(extra, "Set STBC =%d\n", pMptCtx->bstbc);
1695                         } else
1696                                 sprintf(extra, "\n period={1~255}\n length={1000~65535}\n count={0~}\n ldpc={0/1}\n stbc={0/1}");
1697
1698                 }
1699
1700                 wrqu->data.length = strlen(extra);
1701                 return 0;
1702 #endif
1703         } else {
1704
1705                 if (sscanf(extra, "ch=%d,bw=%d,rate=%d,pwr=%d,ant=%d,tx=%d", &channel, &bandwidth, &rate, &txpower, &ant, &txmode) < 6) {
1706                         RTW_INFO("Invalid format [ch=%d,bw=%d,rate=%d,pwr=%d,ant=%d,tx=%d]\n", channel, bandwidth, rate, txpower, ant, txmode);
1707                         _rtw_memset(extra, 0, wrqu->data.length);
1708                         sprintf(extra, "\n Please input correct format as bleow:\n");
1709                         sprintf(extra, "%s\t ch=%d,bw=%d,rate=%d,pwr=%d,ant=%d,tx=%d\n", extra, channel, bandwidth, rate, txpower, ant, txmode);
1710                         sprintf(extra, "%s\n [ ch : BGN = <1~14> , A or AC = <36~165> ]", extra);
1711                         sprintf(extra, "%s\n [ bw : Bandwidth: 0 = 20M, 1 = 40M, 2 = 80M ]", extra);
1712                         sprintf(extra, "%s\n [ rate :   CCK: 1 2 5.5 11M X 2 = < 2 4 11 22 >]", extra);
1713                         sprintf(extra, "%s\n [          OFDM: 6 9 12 18 24 36 48 54M X 2 = < 12 18 24 36 48 72 96 108>", extra);
1714                         sprintf(extra, "%s\n [          HT 1S2SS MCS0 ~ MCS15 : < [MCS0]=128 ~ [MCS7]=135 ~ [MCS15]=143 >", extra);
1715                         sprintf(extra, "%s\n [          HT 3SS MCS16 ~ MCS32 : < [MCS16]=144 ~ [MCS23]=151 ~ [MCS32]=159 >", extra);
1716                         sprintf(extra, "%s\n [          VHT 1SS MCS0 ~ MCS9 : < [MCS0]=160 ~ [MCS9]=169 >", extra);
1717                         sprintf(extra, "%s\n [ txpower : 1~63 power index", extra);
1718                         sprintf(extra, "%s\n [ ant : <A = 1, B = 2, C = 4, D = 8> ,2T ex: AB=3 BC=6 CD=12", extra);
1719                         sprintf(extra, "%s\n [ txmode : < 0 = CONTINUOUS_TX, 1 = PACKET_TX, 2 = SINGLE_TONE_TX, 3 = CARRIER_SUPPRISSION_TX, 4 = SINGLE_CARRIER_TX>\n", extra);
1720                         wrqu->data.length = strlen(extra);
1721                         return status;
1722
1723                 } else {
1724                         RTW_INFO("Got format [ch=%d,bw=%d,rate=%d,pwr=%d,ant=%d,tx=%d]\n", channel, bandwidth, rate, txpower, ant, txmode);
1725                         _rtw_memset(extra, 0, wrqu->data.length);
1726                         sprintf(extra, "Change Current channel %d to channel %d", padapter->mppriv.channel , channel);
1727                         padapter->mppriv.channel = channel;
1728                         SetChannel(padapter);
1729                         pHalData->CurrentChannel = channel;
1730
1731                         if (bandwidth == 1)
1732                                 bandwidth = CHANNEL_WIDTH_40;
1733                         else if (bandwidth == 2)
1734                                 bandwidth = CHANNEL_WIDTH_80;
1735                         sprintf(extra, "%s\nChange Current Bandwidth %d to Bandwidth %d", extra, padapter->mppriv.bandwidth , bandwidth);
1736                         padapter->mppriv.bandwidth = (u8)bandwidth;
1737                         padapter->mppriv.preamble = sg;
1738                         SetBandwidth(padapter);
1739                         pHalData->CurrentChannelBW = bandwidth;
1740
1741                         sprintf(extra, "%s\nSet power level :%d", extra, txpower);
1742                         padapter->mppriv.txpoweridx = (u8)txpower;
1743                         pMptCtx->TxPwrLevel[ODM_RF_PATH_A] = (u8)txpower;
1744                         pMptCtx->TxPwrLevel[ODM_RF_PATH_B] = (u8)txpower;
1745                         pMptCtx->TxPwrLevel[ODM_RF_PATH_C] = (u8)txpower;
1746                         pMptCtx->TxPwrLevel[ODM_RF_PATH_D]  = (u8)txpower;
1747
1748                         RTW_INFO("%s: bw=%d sg=%d\n", __func__, bandwidth, sg);
1749
1750                         if (rate <= 0x7f)
1751                                 rate = wifirate2_ratetbl_inx((u8)rate);
1752                         else if (rate < 0xC8)
1753                                 rate = (rate - 0x80 + MPT_RATE_MCS0);
1754                         /*HT  rate 0x80(MCS0)  ~ 0x8F(MCS15) ~ 0x9F(MCS31) 128~159
1755                         VHT1SS~2SS rate 0xA0 (VHT1SS_MCS0 44) ~ 0xB3 (VHT2SS_MCS9 #63) 160~179
1756                         VHT rate 0xB4 (VHT3SS_MCS0 64) ~ 0xC7 (VHT2SS_MCS9 #83) 180~199
1757                         else
1758                         VHT rate 0x90(VHT1SS_MCS0) ~ 0x99(VHT1SS_MCS9) 144~153
1759                         rate =(rate - MPT_RATE_VHT1SS_MCS0);
1760                         */
1761                         RTW_INFO("%s: rate index=%d\n", __func__, rate);
1762                         if (rate >= MPT_RATE_LAST)
1763                                 return -EINVAL;
1764                         sprintf(extra, "%s\nSet data rate to %d index %d", extra, padapter->mppriv.rateidx, rate);
1765
1766                         padapter->mppriv.rateidx = rate;
1767                         pMptCtx->MptRateIndex = rate;
1768                         SetDataRate(padapter);
1769
1770                         sprintf(extra, "%s\nSet Antenna Path :%d",  extra, ant);
1771                         switch (ant) {
1772                         case 1:
1773                                 antenna = ANTENNA_A;
1774                                 break;
1775                         case 2:
1776                                 antenna = ANTENNA_B;
1777                                 break;
1778                         case 4:
1779                                 antenna = ANTENNA_C;
1780                                 break;
1781                         case 8:
1782                                 antenna = ANTENNA_D;
1783                                 break;
1784                         case 3:
1785                                 antenna = ANTENNA_AB;
1786                                 break;
1787                         case 5:
1788                                 antenna = ANTENNA_AC;
1789                                 break;
1790                         case 9:
1791                                 antenna = ANTENNA_AD;
1792                                 break;
1793                         case 6:
1794                                 antenna = ANTENNA_BC;
1795                                 break;
1796                         case 10:
1797                                 antenna = ANTENNA_BD;
1798                                 break;
1799                         case 12:
1800                                 antenna = ANTENNA_CD;
1801                                 break;
1802                         case 7:
1803                                 antenna = ANTENNA_ABC;
1804                                 break;
1805                         case 14:
1806                                 antenna = ANTENNA_BCD;
1807                                 break;
1808                         case 11:
1809                                 antenna = ANTENNA_ABD;
1810                                 break;
1811                         case 15:
1812                                 antenna = ANTENNA_ABCD;
1813                                 break;
1814                         }
1815                         RTW_INFO("%s: antenna=0x%x\n", __func__, antenna);
1816                         padapter->mppriv.antenna_tx = antenna;
1817                         padapter->mppriv.antenna_rx = antenna;
1818                         pHalData->AntennaTxPath = antenna;
1819                         SetAntenna(padapter);
1820
1821                         if (txmode == 0)
1822                                 pmp_priv->mode = MP_CONTINUOUS_TX;
1823                         else if (txmode == 1) {
1824                                 pmp_priv->mode = MP_PACKET_TX;
1825                                 pmp_priv->tx.count = count;
1826                         } else if (txmode == 2)
1827                                 pmp_priv->mode = MP_SINGLE_TONE_TX;
1828                         else if (txmode == 3)
1829                                 pmp_priv->mode = MP_CARRIER_SUPPRISSION_TX;
1830                         else if (txmode == 4)
1831                                 pmp_priv->mode = MP_SINGLE_CARRIER_TX;
1832
1833                         status = rtw_mp_pretx_proc(padapter, bStartTest, extra);
1834                 }
1835
1836         }
1837
1838         wrqu->data.length = strlen(extra);
1839         return status;
1840 }
1841
1842
1843 int rtw_mp_rx(struct net_device *dev,
1844               struct iw_request_info *info,
1845               union iwreq_data *wrqu, char *extra)
1846 {
1847         PADAPTER padapter = rtw_netdev_priv(dev);
1848         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
1849         struct mp_priv *pmp_priv = &padapter->mppriv;
1850         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
1851
1852         u32 bandwidth = 0, sg = 0, channel = 6, ant = 0;
1853         u16 antenna = 0;
1854         u8 bStartRx = 0;
1855
1856         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
1857                 return -EFAULT;
1858
1859 #ifdef CONFIG_CONCURRENT_MODE
1860         if (!is_primary_adapter(padapter)) {
1861                 sprintf(extra, "Error: MP mode can't support Virtual Adapter, Please to use main Adapter.\n");
1862                 wrqu->data.length = strlen(extra);
1863                 return 0;
1864         }
1865 #endif
1866
1867         if (strncmp(extra, "stop", 4) == 0) {
1868                 _rtw_memset(extra, 0, wrqu->data.length);
1869                 SetPacketRx(padapter, bStartRx, _FALSE);
1870                 pmp_priv->bmac_filter = _FALSE;
1871                 sprintf(extra, "Received packet OK:%d CRC error:%d ,Filter out:%d", padapter->mppriv.rx_pktcount, padapter->mppriv.rx_crcerrpktcount, padapter->mppriv.rx_pktcount_filter_out);
1872                 wrqu->data.length = strlen(extra);
1873                 return 0;
1874
1875         } else if (sscanf(extra, "ch=%d,bw=%d,ant=%d", &channel, &bandwidth, &ant) < 3) {
1876                 RTW_INFO("Invalid format [ch=%d,bw=%d,ant=%d]\n", channel, bandwidth, ant);
1877                 _rtw_memset(extra, 0, wrqu->data.length);
1878                 sprintf(extra, "\n Please input correct format as bleow:\n");
1879                 sprintf(extra, "%s\t ch=%d,bw=%d,ant=%d\n", extra, channel, bandwidth, ant);
1880                 sprintf(extra, "%s\n [ ch : BGN = <1~14> , A or AC = <36~165> ]", extra);
1881                 sprintf(extra, "%s\n [ bw : Bandwidth: 0 = 20M, 1 = 40M, 2 = 80M ]", extra);
1882                 sprintf(extra, "%s\n [ ant : <A = 1, B = 2, C = 4, D = 8> ,2T ex: AB=3 BC=6 CD=12", extra);
1883                 wrqu->data.length = strlen(extra);
1884                 return 0;
1885
1886         } else {
1887                 bStartRx = 1;
1888                 RTW_INFO("Got format [ch=%d,bw=%d,ant=%d]\n", channel, bandwidth, ant);
1889                 _rtw_memset(extra, 0, wrqu->data.length);
1890                 sprintf(extra, "Change Current channel %d to channel %d", padapter->mppriv.channel , channel);
1891                 padapter->mppriv.channel = channel;
1892                 SetChannel(padapter);
1893                 pHalData->CurrentChannel = channel;
1894
1895                 if (bandwidth == 1)
1896                         bandwidth = CHANNEL_WIDTH_40;
1897                 else if (bandwidth == 2)
1898                         bandwidth = CHANNEL_WIDTH_80;
1899                 sprintf(extra, "%s\nChange Current Bandwidth %d to Bandwidth %d", extra, padapter->mppriv.bandwidth , bandwidth);
1900                 padapter->mppriv.bandwidth = (u8)bandwidth;
1901                 padapter->mppriv.preamble = sg;
1902                 SetBandwidth(padapter);
1903                 pHalData->CurrentChannelBW = bandwidth;
1904
1905                 sprintf(extra, "%s\nSet Antenna Path :%d",  extra, ant);
1906                 switch (ant) {
1907                 case 1:
1908                         antenna = ANTENNA_A;
1909                         break;
1910                 case 2:
1911                         antenna = ANTENNA_B;
1912                         break;
1913                 case 4:
1914                         antenna = ANTENNA_C;
1915                         break;
1916                 case 8:
1917                         antenna = ANTENNA_D;
1918                         break;
1919                 case 3:
1920                         antenna = ANTENNA_AB;
1921                         break;
1922                 case 5:
1923                         antenna = ANTENNA_AC;
1924                         break;
1925                 case 9:
1926                         antenna = ANTENNA_AD;
1927                         break;
1928                 case 6:
1929                         antenna = ANTENNA_BC;
1930                         break;
1931                 case 10:
1932                         antenna = ANTENNA_BD;
1933                         break;
1934                 case 12:
1935                         antenna = ANTENNA_CD;
1936                         break;
1937                 case 7:
1938                         antenna = ANTENNA_ABC;
1939                         break;
1940                 case 14:
1941                         antenna = ANTENNA_BCD;
1942                         break;
1943                 case 11:
1944                         antenna = ANTENNA_ABD;
1945                         break;
1946                 case 15:
1947                         antenna = ANTENNA_ABCD;
1948                         break;
1949                 }
1950                 RTW_INFO("%s: antenna=0x%x\n", __func__, antenna);
1951                 padapter->mppriv.antenna_tx = antenna;
1952                 padapter->mppriv.antenna_rx = antenna;
1953                 pHalData->AntennaTxPath = antenna;
1954                 SetAntenna(padapter);
1955
1956                 sprintf(extra, "%s\nstart Rx", extra);
1957                 SetPacketRx(padapter, bStartRx, _FALSE);
1958         }
1959         wrqu->data.length = strlen(extra);
1960         return 0;
1961 }
1962
1963
1964 int rtw_mp_hwtx(struct net_device *dev,
1965                 struct iw_request_info *info,
1966                 union iwreq_data *wrqu, char *extra)
1967 {
1968         PADAPTER padapter = rtw_netdev_priv(dev);
1969         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
1970         struct mp_priv *pmp_priv = &padapter->mppriv;
1971         PMPT_CONTEXT            pMptCtx = &(padapter->mppriv.MptCtx);
1972
1973 #if defined(CONFIG_RTL8814A) || defined(CONFIG_RTL8821B) || defined(CONFIG_RTL8822B) || defined(CONFIG_RTL8821C)
1974         u8              input[wrqu->data.length];
1975
1976         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
1977                 return -EFAULT;
1978
1979         _rtw_memset(&pMptCtx->PMacTxInfo, 0, sizeof(RT_PMAC_TX_INFO));
1980         _rtw_memcpy((void *)&pMptCtx->PMacTxInfo, (void *)input, sizeof(RT_PMAC_TX_INFO));
1981
1982         mpt_ProSetPMacTx(padapter);
1983         sprintf(extra, "Set PMac Tx Mode start\n");
1984
1985         wrqu->data.length = strlen(extra);
1986 #endif
1987         return 0;
1988
1989 }
1990
1991 int rtw_efuse_mask_file(struct net_device *dev,
1992                         struct iw_request_info *info,
1993                         union iwreq_data *wrqu, char *extra)
1994 {
1995         char *rtw_efuse_mask_file_path;
1996         u8 Status;
1997         PADAPTER padapter = rtw_netdev_priv(dev);
1998
1999         _rtw_memset(maskfileBuffer, 0x00, sizeof(maskfileBuffer));
2000
2001         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
2002                 return -EFAULT;
2003
2004         if (strncmp(extra, "off", 3) == 0 && strlen(extra) < 4) {
2005                 padapter->registrypriv.boffefusemask = 1;
2006                 sprintf(extra, "Turn off Efuse Mask\n");
2007                 wrqu->data.length = strlen(extra);
2008                 return 0;
2009         }
2010         if (strncmp(extra, "on", 2) == 0 && strlen(extra) < 3) {
2011                 padapter->registrypriv.boffefusemask = 0;
2012                 sprintf(extra, "Turn on Efuse Mask\n");
2013                 wrqu->data.length = strlen(extra);
2014                 return 0;
2015         }
2016         rtw_efuse_mask_file_path = extra;
2017
2018         if (rtw_is_file_readable(rtw_efuse_mask_file_path) == _TRUE) {
2019                 RTW_INFO("%s do rtw_efuse_mask_file_read = %s! ,sizeof maskfileBuffer %zu\n", __func__, rtw_efuse_mask_file_path, sizeof(maskfileBuffer));
2020                 Status = rtw_efuse_file_read(padapter, rtw_efuse_mask_file_path, maskfileBuffer, sizeof(maskfileBuffer));
2021                 if (Status == _TRUE)
2022                         padapter->registrypriv.bFileMaskEfuse = _TRUE;
2023                 sprintf(extra, "efuse mask file read OK\n");
2024         } else {
2025                 padapter->registrypriv.bFileMaskEfuse = _FALSE;
2026                 sprintf(extra, "efuse mask file readable FAIL\n");
2027                 RTW_INFO("%s rtw_is_file_readable fail!\n", __func__);
2028         }
2029         wrqu->data.length = strlen(extra);
2030         return 0;
2031 }
2032
2033
2034 int rtw_efuse_file_map(struct net_device *dev,
2035                        struct iw_request_info *info,
2036                        union iwreq_data *wrqu, char *extra)
2037 {
2038         char *rtw_efuse_file_map_path;
2039         u8 Status;
2040         PEFUSE_HAL pEfuseHal;
2041         PADAPTER padapter = rtw_netdev_priv(dev);
2042         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
2043         struct mp_priv *pmp_priv = &padapter->mppriv;
2044
2045         pEfuseHal = &pHalData->EfuseHal;
2046         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
2047                 return -EFAULT;
2048
2049         rtw_efuse_file_map_path = extra;
2050
2051         _rtw_memset(pEfuseHal->fakeEfuseModifiedMap, 0xFF, EFUSE_MAX_MAP_LEN);
2052
2053         if (rtw_is_file_readable(rtw_efuse_file_map_path) == _TRUE) {
2054                 RTW_INFO("%s do rtw_efuse_mask_file_read = %s!\n", __func__, rtw_efuse_file_map_path);
2055                 Status = rtw_efuse_file_read(padapter, rtw_efuse_file_map_path, pEfuseHal->fakeEfuseModifiedMap, sizeof(pEfuseHal->fakeEfuseModifiedMap));
2056                 if (Status == _TRUE) {
2057                         pmp_priv->bloadefusemap = _TRUE;
2058                         sprintf(extra, "efuse file file_read OK\n");
2059                 } else {
2060                         pmp_priv->bloadefusemap = _FALSE;
2061                         sprintf(extra, "efuse file file_read FAIL\n");
2062                 }
2063         } else {
2064                 sprintf(extra, "efuse file readable FAIL\n");
2065                 RTW_INFO("%s rtw_is_file_readable fail!\n", __func__);
2066         }
2067         wrqu->data.length = strlen(extra);
2068         return 0;
2069 }
2070
2071 #if defined(CONFIG_RTL8723B)
2072 int rtw_mp_SetBT(struct net_device *dev,
2073                  struct iw_request_info *info,
2074                  union iwreq_data *wrqu, char *extra)
2075 {
2076         PADAPTER padapter = rtw_netdev_priv(dev);
2077         struct hal_ops *pHalFunc = &padapter->HalFunc;
2078         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
2079
2080         BT_REQ_CMD      BtReq;
2081         PMPT_CONTEXT    pMptCtx = &(padapter->mppriv.MptCtx);
2082         PBT_RSP_CMD     pBtRsp = (PBT_RSP_CMD)&pMptCtx->mptOutBuf[0];
2083         char    input[128];
2084         char *pch, *ptmp, *token, *tmp[2] = {0x00, 0x00};
2085         u8 setdata[100];
2086         u8 resetbt = 0x00;
2087         u8 tempval, BTStatus;
2088         u8 H2cSetbtmac[6];
2089         u8 u1H2CBtMpOperParm[4] = {0x01};
2090         int testmode = 1, ready = 1, trxparam = 1, setgen = 1, getgen = 1, testctrl = 1, testbt = 1, readtherm = 1, setbtmac = 1;
2091         u32 i = 0, ii = 0, jj = 0, kk = 0, cnts = 0, status = 0;
2092         PRT_MP_FIRMWARE pBTFirmware = NULL;
2093
2094         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
2095                 return -EFAULT;
2096         if (strlen(extra) < 1)
2097                 return -EFAULT;
2098
2099         RTW_INFO("%s:iwpriv in=%s\n", __func__, extra);
2100         ready = strncmp(extra, "ready", 5);
2101         testmode = strncmp(extra, "testmode", 8); /* strncmp TRUE is 0*/
2102         trxparam = strncmp(extra, "trxparam", 8);
2103         setgen = strncmp(extra, "setgen", 6);
2104         getgen = strncmp(extra, "getgen", 6);
2105         testctrl = strncmp(extra, "testctrl", 8);
2106         testbt = strncmp(extra, "testbt", 6);
2107         readtherm = strncmp(extra, "readtherm", 9);
2108         setbtmac = strncmp(extra, "setbtmac", 8);
2109
2110         if (strncmp(extra, "dlbt", 4) == 0) {
2111                 pHalData->LastHMEBoxNum = 0;
2112                 padapter->bBTFWReady = _FALSE;
2113                 rtw_write8(padapter, 0xa3, 0x05);
2114                 BTStatus = rtw_read8(padapter, 0xa0);
2115                 RTW_INFO("%s: btwmap before read 0xa0 BT Status =0x%x\n", __func__, BTStatus);
2116                 if (BTStatus != 0x04) {
2117                         sprintf(extra, "BT Status not Active DLFW FAIL\n");
2118                         goto exit;
2119                 }
2120
2121                 tempval = rtw_read8(padapter, 0x6B);
2122                 tempval |= BIT7;
2123                 rtw_write8(padapter, 0x6B, tempval);
2124
2125                 /* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay*/
2126                 /* So don't write 0x6A[14]=1 and 0x6A[15]=0 together!*/
2127                 rtw_usleep_os(100);
2128                 /* disable BT power cut*/
2129                 /* 0x6A[14] = 0*/
2130                 tempval = rtw_read8(padapter, 0x6B);
2131                 tempval &= ~BIT6;
2132                 rtw_write8(padapter, 0x6B, tempval);
2133                 rtw_usleep_os(100);
2134                 MPT_PwrCtlDM(padapter, 0);
2135                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) | 0x00000004));
2136                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) & 0xFFFFFFEF));
2137                 rtw_msleep_os(600);
2138                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) | 0x00000010));
2139                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) & 0xFFFFFFFB));
2140                 rtw_msleep_os(1200);
2141                 pBTFirmware = (PRT_MP_FIRMWARE)rtw_zmalloc(sizeof(RT_MP_FIRMWARE));
2142                 if (pBTFirmware == NULL)
2143                         goto exit;
2144                 padapter->bBTFWReady = _FALSE;
2145                 FirmwareDownloadBT(padapter, pBTFirmware);
2146                 if (pBTFirmware)
2147                         rtw_mfree((u8 *)pBTFirmware, sizeof(RT_MP_FIRMWARE));
2148
2149                 RTW_INFO("Wait for FirmwareDownloadBT fw boot!\n");
2150                 rtw_msleep_os(2000);
2151                 _rtw_memset(extra, '\0', wrqu->data.length);
2152                 BtReq.opCodeVer = 1;
2153                 BtReq.OpCode = 0;
2154                 BtReq.paraLength = 0;
2155                 mptbt_BtControlProcess(padapter, &BtReq);
2156                 rtw_msleep_os(100);
2157
2158                 RTW_INFO("FirmwareDownloadBT ready = 0x%x 0x%x", pMptCtx->mptOutBuf[4], pMptCtx->mptOutBuf[5]);
2159                 if ((pMptCtx->mptOutBuf[4] == 0x00) && (pMptCtx->mptOutBuf[5] == 0x00)) {
2160
2161                         if (padapter->mppriv.bTxBufCkFail == _TRUE)
2162                                 sprintf(extra, "check TxBuf Fail.\n");
2163                         else
2164                                 sprintf(extra, "download FW Fail.\n");
2165                 } else {
2166                         sprintf(extra, "download FW OK.\n");
2167                         goto exit;
2168                 }
2169                 goto exit;
2170         }
2171         if (strncmp(extra, "dlfw", 4) == 0) {
2172                 pHalData->LastHMEBoxNum = 0;
2173                 padapter->bBTFWReady = _FALSE;
2174                 rtw_write8(padapter, 0xa3, 0x05);
2175                 BTStatus = rtw_read8(padapter, 0xa0);
2176                 RTW_INFO("%s: btwmap before read 0xa0 BT Status =0x%x\n", __func__, BTStatus);
2177                 if (BTStatus != 0x04) {
2178                         sprintf(extra, "BT Status not Active DLFW FAIL\n");
2179                         goto exit;
2180                 }
2181
2182                 tempval = rtw_read8(padapter, 0x6B);
2183                 tempval |= BIT7;
2184                 rtw_write8(padapter, 0x6B, tempval);
2185
2186                 /* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay*/
2187                 /* So don't write 0x6A[14]=1 and 0x6A[15]=0 together!*/
2188                 rtw_usleep_os(100);
2189                 /* disable BT power cut*/
2190                 /* 0x6A[14] = 0*/
2191                 tempval = rtw_read8(padapter, 0x6B);
2192                 tempval &= ~BIT6;
2193                 rtw_write8(padapter, 0x6B, tempval);
2194                 rtw_usleep_os(100);
2195
2196                 MPT_PwrCtlDM(padapter, 0);
2197                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) | 0x00000004));
2198                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) & 0xFFFFFFEF));
2199                 rtw_msleep_os(600);
2200                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) | 0x00000010));
2201                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) & 0xFFFFFFFB));
2202                 rtw_msleep_os(1200);
2203
2204 #if defined(CONFIG_PLATFORM_SPRD) && (MP_DRIVER == 1)
2205                 /* Pull up BT reset pin.*/
2206                 RTW_INFO("%s: pull up BT reset pin when bt start mp test\n", __func__);
2207                 rtw_wifi_gpio_wlan_ctrl(WLAN_BT_PWDN_ON);
2208 #endif
2209                 RTW_INFO(" FirmwareDownload!\n");
2210
2211 #if defined(CONFIG_RTL8723B)
2212                 status = rtl8723b_FirmwareDownload(padapter, _FALSE);
2213 #endif
2214                 RTW_INFO("Wait for FirmwareDownloadBT fw boot!\n");
2215                 rtw_msleep_os(1000);
2216 #ifdef CONFIG_BT_COEXIST
2217                 rtw_btcoex_HaltNotify(padapter);
2218                 RTW_INFO("SetBT btcoex HaltNotify !\n");
2219                 /*hal_btcoex1ant_SetAntPath(padapter);*/
2220                 rtw_btcoex_SetManualControl(padapter, _TRUE);
2221 #endif
2222                 _rtw_memset(extra, '\0', wrqu->data.length);
2223                 BtReq.opCodeVer = 1;
2224                 BtReq.OpCode = 0;
2225                 BtReq.paraLength = 0;
2226                 mptbt_BtControlProcess(padapter, &BtReq);
2227                 rtw_msleep_os(200);
2228
2229                 RTW_INFO("FirmwareDownloadBT ready = 0x%x 0x%x", pMptCtx->mptOutBuf[4], pMptCtx->mptOutBuf[5]);
2230                 if ((pMptCtx->mptOutBuf[4] == 0x00) && (pMptCtx->mptOutBuf[5] == 0x00)) {
2231                         if (padapter->mppriv.bTxBufCkFail == _TRUE)
2232                                 sprintf(extra, "check TxBuf Fail.\n");
2233                         else
2234                                 sprintf(extra, "download FW Fail.\n");
2235                 } else {
2236 #ifdef CONFIG_BT_COEXIST
2237                         rtw_btcoex_SwitchBtTRxMask(padapter);
2238 #endif
2239                         rtw_msleep_os(200);
2240                         sprintf(extra, "download FW OK.\n");
2241                         goto exit;
2242                 }
2243                 goto exit;
2244         }
2245
2246         if (strncmp(extra, "down", 4) == 0) {
2247                 RTW_INFO("SetBT down for to hal_init !\n");
2248 #ifdef CONFIG_BT_COEXIST
2249                 rtw_btcoex_SetManualControl(padapter, _FALSE);
2250                 rtw_btcoex_Initialize(padapter);
2251 #endif
2252                 pHalFunc->read_adapter_info(padapter);
2253                 pHalFunc->hal_deinit(padapter);
2254                 pHalFunc->hal_init(padapter);
2255                 rtw_pm_set_ips(padapter, IPS_NONE);
2256                 LeaveAllPowerSaveMode(padapter);
2257                 MPT_PwrCtlDM(padapter, 0);
2258                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) | 0x00000004));
2259                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) & 0xFFFFFFEF));
2260                 rtw_msleep_os(600);
2261                 /*rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a)& 0xFFFFFFFE));*/
2262                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b) | 0x00000010));
2263                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc) & 0xFFFFFFFB));
2264                 rtw_msleep_os(1200);
2265                 goto exit;
2266         }
2267         if (strncmp(extra, "disable", 7) == 0) {
2268                 RTW_INFO("SetBT disable !\n");
2269                 rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a) & 0xFFFFFFFB));
2270                 rtw_msleep_os(500);
2271                 goto exit;
2272         }
2273         if (strncmp(extra, "enable", 6) == 0) {
2274                 RTW_INFO("SetBT enable !\n");
2275                 rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a) | 0x00000004));
2276                 rtw_msleep_os(500);
2277                 goto exit;
2278         }
2279         if (strncmp(extra, "h2c", 3) == 0) {
2280                 RTW_INFO("SetBT h2c !\n");
2281                 padapter->bBTFWReady = _TRUE;
2282                 rtw_hal_fill_h2c_cmd(padapter, 0x63, 1, u1H2CBtMpOperParm);
2283                 goto exit;
2284         }
2285         if (strncmp(extra, "2ant", 4) == 0) {
2286                 RTW_INFO("Set BT 2ant use!\n");
2287                 PHY_SetMacReg(padapter, 0x67, BIT5, 0x1);
2288                 rtw_write32(padapter, 0x948, 0000);
2289
2290                 goto exit;
2291         }
2292
2293         if (ready != 0 && testmode != 0 && trxparam != 0 && setgen != 0 && getgen != 0 && testctrl != 0 && testbt != 0 && readtherm != 0 && setbtmac != 0)
2294                 return -EFAULT;
2295
2296         if (testbt == 0) {
2297                 BtReq.opCodeVer = 1;
2298                 BtReq.OpCode = 6;
2299                 BtReq.paraLength = cnts / 2;
2300                 goto todo;
2301         }
2302         if (ready == 0) {
2303                 BtReq.opCodeVer = 1;
2304                 BtReq.OpCode = 0;
2305                 BtReq.paraLength = 0;
2306                 goto todo;
2307         }
2308
2309         pch = extra;
2310         i = 0;
2311         while ((token = strsep(&pch, ",")) != NULL) {
2312                 if (i > 1)
2313                         break;
2314                 tmp[i] = token;
2315                 i++;
2316         }
2317
2318         if ((tmp[0] != NULL) && (tmp[1] != NULL)) {
2319                 cnts = strlen(tmp[1]);
2320                 if (cnts < 1)
2321                         return -EFAULT;
2322
2323                 RTW_INFO("%s: cnts=%d\n", __func__, cnts);
2324                 RTW_INFO("%s: data=%s\n", __func__, tmp[1]);
2325
2326                 for (jj = 0, kk = 0; jj < cnts; jj++, kk += 2) {
2327                         BtReq.pParamStart[jj] = key_2char2num(tmp[1][kk], tmp[1][kk + 1]);
2328                         /*                      RTW_INFO("BtReq.pParamStart[%d]=0x%02x\n", jj, BtReq.pParamStart[jj]);*/
2329                 }
2330         } else
2331                 return -EFAULT;
2332
2333         if (testmode == 0) {
2334                 BtReq.opCodeVer = 1;
2335                 BtReq.OpCode = 1;
2336                 BtReq.paraLength = 1;
2337         }
2338         if (trxparam == 0) {
2339                 BtReq.opCodeVer = 1;
2340                 BtReq.OpCode = 2;
2341                 BtReq.paraLength = cnts / 2;
2342         }
2343         if (setgen == 0) {
2344                 RTW_INFO("%s: BT_SET_GENERAL\n", __func__);
2345                 BtReq.opCodeVer = 1;
2346                 BtReq.OpCode = 3;/*BT_SET_GENERAL       3*/
2347                 BtReq.paraLength = cnts / 2;
2348         }
2349         if (getgen == 0) {
2350                 RTW_INFO("%s: BT_GET_GENERAL\n", __func__);
2351                 BtReq.opCodeVer = 1;
2352                 BtReq.OpCode = 4;/*BT_GET_GENERAL       4*/
2353                 BtReq.paraLength = cnts / 2;
2354         }
2355         if (readtherm == 0) {
2356                 RTW_INFO("%s: BT_GET_GENERAL\n", __func__);
2357                 BtReq.opCodeVer = 1;
2358                 BtReq.OpCode = 4;/*BT_GET_GENERAL       4*/
2359                 BtReq.paraLength = cnts / 2;
2360         }
2361
2362         if (testctrl == 0) {
2363                 RTW_INFO("%s: BT_TEST_CTRL\n", __func__);
2364                 BtReq.opCodeVer = 1;
2365                 BtReq.OpCode = 5;/*BT_TEST_CTRL 5*/
2366                 BtReq.paraLength = cnts / 2;
2367         }
2368
2369         RTW_INFO("%s: Req opCodeVer=%d OpCode=%d paraLength=%d\n",
2370                  __func__, BtReq.opCodeVer, BtReq.OpCode, BtReq.paraLength);
2371
2372         if (BtReq.paraLength < 1)
2373                 goto todo;
2374         for (i = 0; i < BtReq.paraLength; i++) {
2375                 RTW_INFO("%s: BtReq.pParamStart[%d] = 0x%02x\n",
2376                          __func__, i, BtReq.pParamStart[i]);
2377         }
2378
2379 todo:
2380         _rtw_memset(extra, '\0', wrqu->data.length);
2381
2382         if (padapter->bBTFWReady == _FALSE) {
2383                 sprintf(extra, "BTFWReady = FALSE.\n");
2384                 goto exit;
2385         }
2386
2387         mptbt_BtControlProcess(padapter, &BtReq);
2388
2389         if (readtherm == 0) {
2390                 sprintf(extra, "BT thermal=");
2391                 for (i = 4; i < pMptCtx->mptOutLen; i++) {
2392                         if ((pMptCtx->mptOutBuf[i] == 0x00) && (pMptCtx->mptOutBuf[i + 1] == 0x00))
2393                                 goto exit;
2394
2395                         sprintf(extra, "%s %d ", extra, (pMptCtx->mptOutBuf[i] & 0x1f));
2396                 }
2397         } else {
2398                 for (i = 4; i < pMptCtx->mptOutLen; i++)
2399                         sprintf(extra, "%s 0x%x ", extra, pMptCtx->mptOutBuf[i]);
2400         }
2401
2402 exit:
2403         wrqu->data.length = strlen(extra) + 1;
2404         RTW_INFO("-%s: output len=%d data=%s\n", __func__, wrqu->data.length, extra);
2405
2406         return status;
2407 }
2408
2409 #endif /*#ifdef CONFIG_RTL8723B*/
2410
2411 #endif