drivers/staging/rtl8188eu/core/rtw_mp.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  *published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTW_MP_C_
  21
  22 #include <drv_types.h>
  23
  24 #include "rtl8188e_hal.h"
  25 #include <linux/vmalloc.h>
  26
  27 u32 read_macreg(struct adapter *padapter, u32 addr, u32 sz)
  28 {
  29         u32 val = 0;
  30
  31         switch (sz) {
  32         case 1:
  33                 val = rtw_read8(padapter, addr);
  34                 break;
  35         case 2:
  36                 val = rtw_read16(padapter, addr);
  37                 break;
  38         case 4:
  39                 val = rtw_read32(padapter, addr);
  40                 break;
  41         default:
  42                 val = 0xffffffff;
  43                 break;
  44         }
  45
  46         return val;
  47 }
  48
  49 void write_macreg(struct adapter *padapter, u32 addr, u32 val, u32 sz)
  50 {
  51         switch (sz) {
  52         case 1:
  53                 rtw_write8(padapter, addr, (u8)val);
  54                 break;
  55         case 2:
  56                 rtw_write16(padapter, addr, (u16)val);
  57                 break;
  58         case 4:
  59                 rtw_write32(padapter, addr, val);
  60                 break;
  61         default:
  62                 break;
  63         }
  64 }
  65
  66 u32 read_bbreg(struct adapter *padapter, u32 addr, u32 bitmask)
  67 {
  68         return rtw_hal_read_bbreg(padapter, addr, bitmask);
  69 }
  70
  71 void write_bbreg(struct adapter *padapter, u32 addr, u32 bitmask, u32 val)
  72 {
  73         rtw_hal_write_bbreg(padapter, addr, bitmask, val);
  74 }
  75
  76 u32 _read_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 bitmask)
  77 {
  78         return rtw_hal_read_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bitmask);
  79 }
  80
  81 void _write_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 bitmask, u32 val)
  82 {
  83         rtw_hal_write_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bitmask, val);
  84 }
  85
  86 u32 read_rfreg(struct adapter *padapter, u8 rfpath, u32 addr)
  87 {
  88         return _read_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bRFRegOffsetMask);
  89 }
  90
  91 void write_rfreg(struct adapter *padapter, u8 rfpath, u32 addr, u32 val)
  92 {
  93         _write_rfreg(padapter, (enum rf_radio_path)rfpath, addr, bRFRegOffsetMask, val);
  94 }
  95
  96 static void _init_mp_priv_(struct mp_priv *pmp_priv)
  97 {
  98         struct wlan_bssid_ex *pnetwork;
  99
 100         _rtw_memset(pmp_priv, 0, sizeof(struct mp_priv));
 101
 102         pmp_priv->mode = MP_OFF;
 103
 104         pmp_priv->channel = 1;
 105         pmp_priv->bandwidth = HT_CHANNEL_WIDTH_20;
 106         pmp_priv->prime_channel_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 107         pmp_priv->rateidx = MPT_RATE_1M;
 108         pmp_priv->txpoweridx = 0x2A;
 109
 110         pmp_priv->antenna_tx = ANTENNA_A;
 111         pmp_priv->antenna_rx = ANTENNA_AB;
 112
 113         pmp_priv->check_mp_pkt = 0;
 114
 115         pmp_priv->tx_pktcount = 0;
 116
 117         pmp_priv->rx_pktcount = 0;
 118         pmp_priv->rx_crcerrpktcount = 0;
 119
 120         pmp_priv->network_macaddr[0] = 0x00;
 121         pmp_priv->network_macaddr[1] = 0xE0;
 122         pmp_priv->network_macaddr[2] = 0x4C;
 123         pmp_priv->network_macaddr[3] = 0x87;
 124         pmp_priv->network_macaddr[4] = 0x66;
 125         pmp_priv->network_macaddr[5] = 0x55;
 126
 127         pnetwork = &pmp_priv->mp_network.network;
 128         memcpy(pnetwork->MacAddress, pmp_priv->network_macaddr, ETH_ALEN);
 129
 130         pnetwork->Ssid.SsidLength = 8;
 131         memcpy(pnetwork->Ssid.Ssid, "mp_871x", pnetwork->Ssid.SsidLength);
 132 }
 133
 134 static void mp_init_xmit_attrib(struct mp_tx *pmptx, struct adapter *padapter)
 135 {
 136         struct pkt_attrib *pattrib;
 137         struct tx_desc *desc;
 138
 139         /*  init xmitframe attribute */
 140         pattrib = &pmptx->attrib;
 141         _rtw_memset(pattrib, 0, sizeof(struct pkt_attrib));
 142         desc = &pmptx->desc;
 143         _rtw_memset(desc, 0, TXDESC_SIZE);
 144
 145         pattrib->ether_type = 0x8712;
 146         _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN);
 147         pattrib->ack_policy = 0;
 148         pattrib->hdrlen = WLAN_HDR_A3_LEN;
 149         pattrib->subtype = WIFI_DATA;
 150         pattrib->priority = 0;
 151         pattrib->qsel = pattrib->priority;
 152         pattrib->nr_frags = 1;
 153         pattrib->encrypt = 0;
 154         pattrib->bswenc = false;
 155         pattrib->qos_en = false;
 156 }
 157
 158 s32 init_mp_priv(struct adapter *padapter)
 159 {
 160         struct mp_priv *pmppriv = &padapter->mppriv;
 161
 162         _init_mp_priv_(pmppriv);
 163         pmppriv->papdater = padapter;
 164
 165         pmppriv->tx.stop = 1;
 166         mp_init_xmit_attrib(&pmppriv->tx, padapter);
 167
 168         switch (padapter->registrypriv.rf_config) {
 169         case RF_1T1R:
 170                 pmppriv->antenna_tx = ANTENNA_A;
 171                 pmppriv->antenna_rx = ANTENNA_A;
 172                 break;
 173         case RF_1T2R:
 174         default:
 175                 pmppriv->antenna_tx = ANTENNA_A;
 176                 pmppriv->antenna_rx = ANTENNA_AB;
 177                 break;
 178         case RF_2T2R:
 179         case RF_2T2R_GREEN:
 180                 pmppriv->antenna_tx = ANTENNA_AB;
 181                 pmppriv->antenna_rx = ANTENNA_AB;
 182                 break;
 183         case RF_2T4R:
 184                 pmppriv->antenna_tx = ANTENNA_AB;
 185                 pmppriv->antenna_rx = ANTENNA_ABCD;
 186                 break;
 187         }
 188
 189         return _SUCCESS;
 190 }
 191
 192 void free_mp_priv(struct mp_priv *pmp_priv)
 193 {
 194         kfree(pmp_priv->pallocated_mp_xmitframe_buf);
 195         pmp_priv->pallocated_mp_xmitframe_buf = NULL;
 196         pmp_priv->pmp_xmtframe_buf = NULL;
 197 }
 198
 199 #define PHY_IQCalibrate(a, b)   PHY_IQCalibrate_8188E(a, b)
 200 #define PHY_LCCalibrate(a)      PHY_LCCalibrate_8188E(a)
 201 #define PHY_SetRFPathSwitch(a, b) PHY_SetRFPathSwitch_8188E(a, b)
 202
 203 s32 MPT_InitializeAdapter(struct adapter *pAdapter, u8 Channel)
 204 {
 205         struct hal_data_8188e   *pHalData = GET_HAL_DATA(pAdapter);
 206         s32             rtStatus = _SUCCESS;
 207         struct mpt_context *pMptCtx = &pAdapter->mppriv.MptCtx;
 208         struct mlme_priv *pmlmepriv = &pAdapter->mlmepriv;
 209
 210         /*  HW Initialization for 8190 MPT. */
 211         /*  SW Initialization for 8190 MP. */
 212         pMptCtx->bMptDrvUnload = false;
 213         pMptCtx->bMassProdTest = false;
 214         pMptCtx->bMptIndexEven = true;  /* default gain index is -6.0db */
 215         pMptCtx->h2cReqNum = 0x0;
 216         /* Init mpt event. */
 217         /* init for BT MP */
 218
 219         pMptCtx->bMptWorkItemInProgress = false;
 220         pMptCtx->CurrMptAct = NULL;
 221         /*  */
 222
 223         /*  Don't accept any packets */
 224         rtw_write32(pAdapter, REG_RCR, 0);
 225
 226         PHY_IQCalibrate(pAdapter, false);
 227         dm_CheckTXPowerTracking(&pHalData->odmpriv);    /* trigger thermal meter */
 228         PHY_LCCalibrate(pAdapter);
 229
 230         pMptCtx->backup0xc50 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_XAAGCCore1, bMaskByte0);
 231         pMptCtx->backup0xc58 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_XBAGCCore1, bMaskByte0);
 232         pMptCtx->backup0xc30 = (u8)PHY_QueryBBReg(pAdapter, rOFDM0_RxDetector1, bMaskByte0);
 233         pMptCtx->backup0x52_RF_A = (u8)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
 234         pMptCtx->backup0x52_RF_B = (u8)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
 235
 236         /* set ant to wifi side in mp mode */
 237         rtw_write16(pAdapter, 0x870, 0x300);
 238         rtw_write16(pAdapter, 0x860, 0x110);
 239
 240         if (pAdapter->registrypriv.mp_mode == 1)
 241                 pmlmepriv->fw_state = WIFI_MP_STATE;
 242
 243         return  rtStatus;
 244 }
 245
 246 /*-----------------------------------------------------------------------------
 247  * Function:    MPT_DeInitAdapter()
 248  *
 249  * Overview:    Extra DeInitialization for Mass Production Test.
 250  *
 251  * Input:               struct adapter *        pAdapter
 252  *
 253  * Output:              NONE
 254  *
 255  * Return:              NONE
 256  *
 257  * Revised History:
 258  *      When            Who             Remark
 259  *      05/08/2007      MHC             Create Version 0.
 260  *      05/18/2007      MHC             Add normal driver MPHalt code.
 261  *
 262  *---------------------------------------------------------------------------*/
 263 void MPT_DeInitAdapter(struct adapter *pAdapter)
 264 {
 265         struct mpt_context *pMptCtx = &pAdapter->mppriv.MptCtx;
 266
 267         pMptCtx->bMptDrvUnload = true;
 268 }
 269
 270 static u8 mpt_ProStartTest(struct adapter *padapter)
 271 {
 272         struct mpt_context *pMptCtx = &padapter->mppriv.MptCtx;
 273
 274         pMptCtx->bMassProdTest = true;
 275         pMptCtx->bStartContTx = false;
 276         pMptCtx->bCckContTx = false;
 277         pMptCtx->bOfdmContTx = false;
 278         pMptCtx->bSingleCarrier = false;
 279         pMptCtx->bCarrierSuppression = false;
 280         pMptCtx->bSingleTone = false;
 281
 282         return _SUCCESS;
 283 }
 284
 285 /*
 286  * General use
 287  */
 288 s32 SetPowerTracking(struct adapter *padapter, u8 enable)
 289 {
 290         Hal_SetPowerTracking(padapter, enable);
 291         return 0;
 292 }
 293
 294 void GetPowerTracking(struct adapter *padapter, u8 *enable)
 295 {
 296         Hal_GetPowerTracking(padapter, enable);
 297 }
 298
 299 static void disable_dm(struct adapter *padapter)
 300 {
 301         u8 v8;
 302
 303         /* 3 1. disable firmware dynamic mechanism */
 304         /*  disable Power Training, Rate Adaptive */
 305         v8 = rtw_read8(padapter, REG_BCN_CTRL);
 306         v8 &= ~EN_BCN_FUNCTION;
 307         rtw_write8(padapter, REG_BCN_CTRL, v8);
 308
 309         /* 3 2. disable driver dynamic mechanism */
 310         /*  disable Dynamic Initial Gain */
 311         /*  disable High Power */
 312         /*  disable Power Tracking */
 313         Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false);
 314
 315         /*  enable APK, LCK and IQK but disable power tracking */
 316         Switch_DM_Func(padapter, DYNAMIC_RF_CALIBRATION, true);
 317 }
 318
 319 /* This function initializes the DUT to the MP test mode */
 320 s32 mp_start_test(struct adapter *padapter)
 321 {
 322         struct wlan_bssid_ex bssid;
 323         struct sta_info *psta;
 324         u32 length;
 325         u8 val8;
 326         s32 res = _SUCCESS;
 327         struct mp_priv *pmppriv = &padapter->mppriv;
 328         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 329         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
 330
 331         padapter->registrypriv.mp_mode = 1;
 332         pmppriv->bSetTxPower = 0;               /* for  manually set tx power */
 333
 334         /* 3 disable dynamic mechanism */
 335         disable_dm(padapter);
 336
 337         /* 3 0. update mp_priv */
 338
 339         if (padapter->registrypriv.rf_config == RF_819X_MAX_TYPE) {
 340                 switch (GET_RF_TYPE(padapter)) {
 341                 case RF_1T1R:
 342                         pmppriv->antenna_tx = ANTENNA_A;
 343                         pmppriv->antenna_rx = ANTENNA_A;
 344                         break;
 345                 case RF_1T2R:
 346                 default:
 347                         pmppriv->antenna_tx = ANTENNA_A;
 348                         pmppriv->antenna_rx = ANTENNA_AB;
 349                         break;
 350                 case RF_2T2R:
 351                 case RF_2T2R_GREEN:
 352                         pmppriv->antenna_tx = ANTENNA_AB;
 353                         pmppriv->antenna_rx = ANTENNA_AB;
 354                         break;
 355                 case RF_2T4R:
 356                         pmppriv->antenna_tx = ANTENNA_AB;
 357                         pmppriv->antenna_rx = ANTENNA_ABCD;
 358                         break;
 359                 }
 360         }
 361
 362         mpt_ProStartTest(padapter);
 363
 364         /* 3 1. initialize a new struct wlan_bssid_ex */
 365 /*      _rtw_memset(&bssid, 0, sizeof(struct wlan_bssid_ex)); */
 366         memcpy(bssid.MacAddress, pmppriv->network_macaddr, ETH_ALEN);
 367         bssid.Ssid.SsidLength = strlen("mp_pseudo_adhoc");
 368         memcpy(bssid.Ssid.Ssid, (u8 *)"mp_pseudo_adhoc", bssid.Ssid.SsidLength);
 369         bssid.InfrastructureMode = Ndis802_11IBSS;
 370         bssid.NetworkTypeInUse = Ndis802_11DS;
 371         bssid.IELength = 0;
 372
 373         length = get_wlan_bssid_ex_sz(&bssid);
 374         if (length % 4)
 375                 bssid.Length = ((length >> 2) + 1) << 2; /* round up to multiple of 4 bytes. */
 376         else
 377                 bssid.Length = length;
 378
 379         spin_lock_bh(&pmlmepriv->lock);
 380
 381         if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == true)
 382                 goto end_of_mp_start_test;
 383
 384         /* init mp_start_test status */
 385         if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
 386                 rtw_disassoc_cmd(padapter, 500, true);
 387                 rtw_indicate_disconnect(padapter);
 388                 rtw_free_assoc_resources(padapter, 1);
 389         }
 390         pmppriv->prev_fw_state = get_fwstate(pmlmepriv);
 391         if (padapter->registrypriv.mp_mode == 1)
 392                 pmlmepriv->fw_state = WIFI_MP_STATE;
 393         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 394
 395         /* 3 2. create a new psta for mp driver */
 396         /* clear psta in the cur_network, if any */
 397         psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
 398         if (psta)
 399                 rtw_free_stainfo(padapter, psta);
 400
 401         psta = rtw_alloc_stainfo(&padapter->stapriv, bssid.MacAddress);
 402         if (psta == NULL) {
 403                 RT_TRACE(_module_mp_, _drv_err_, ("mp_start_test: Can't alloc sta_info!\n"));
 404                 pmlmepriv->fw_state = pmppriv->prev_fw_state;
 405                 res = _FAIL;
 406                 goto end_of_mp_start_test;
 407         }
 408
 409         /* 3 3. join pseudo AdHoc */
 410         tgt_network->join_res = 1;
 411         tgt_network->aid = 1;
 412         psta->aid = 1;
 413         memcpy(&tgt_network->network, &bssid, length);
 414
 415         rtw_indicate_connect(padapter);
 416         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 417
 418 end_of_mp_start_test:
 419
 420         spin_unlock_bh(&pmlmepriv->lock);
 421
 422         if (res == _SUCCESS) {
 423                 /*  set MSR to WIFI_FW_ADHOC_STATE */
 424                 val8 = rtw_read8(padapter, MSR) & 0xFC; /*  0x0102 */
 425                 val8 |= WIFI_FW_ADHOC_STATE;
 426                 rtw_write8(padapter, MSR, val8); /*  Link in ad hoc network */
 427         }
 428         return res;
 429 }
 430 /*  */
 431 /* This function change the DUT from the MP test mode into normal mode */
 432 void mp_stop_test(struct adapter *padapter)
 433 {
 434         struct mp_priv *pmppriv = &padapter->mppriv;
 435         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 436         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
 437         struct sta_info *psta;
 438
 439         if (pmppriv->mode == MP_ON) {
 440                 pmppriv->bSetTxPower = 0;
 441                 spin_lock_bh(&pmlmepriv->lock);
 442                 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)
 443                         goto end_of_mp_stop_test;
 444
 445                 /* 3 1. disconnect pseudo AdHoc */
 446                 rtw_indicate_disconnect(padapter);
 447
 448                 /* 3 2. clear psta used in mp test mode. */
 449                 psta = rtw_get_stainfo(&padapter->stapriv, tgt_network->network.MacAddress);
 450                 if (psta)
 451                         rtw_free_stainfo(padapter, psta);
 452
 453                 /* 3 3. return to normal state (default:station mode) */
 454                 pmlmepriv->fw_state = pmppriv->prev_fw_state; /*  WIFI_STATION_STATE; */
 455
 456                 /* flush the cur_network */
 457                 _rtw_memset(tgt_network, 0, sizeof(struct wlan_network));
 458
 459                 _clr_fwstate_(pmlmepriv, WIFI_MP_STATE);
 460
 461 end_of_mp_stop_test:
 462
 463                 spin_unlock_bh(&pmlmepriv->lock);
 464         }
 465 }
 466
 467 /*---------------------------hal\rtl8192c\MPT_HelperFunc.c---------------------------*/
 468 /*
 469  * SetChannel
 470  * Description
 471  *      Use H2C command to change channel,
 472  *      not only modify rf register, but also other setting need to be done.
 473  */
 474 void SetChannel(struct adapter *pAdapter)
 475 {
 476         Hal_SetChannel(pAdapter);
 477 }
 478
 479 /*
 480  * Notice
 481  *      Switch bandwitdth may change center frequency(channel)
 482  */
 483 void SetBandwidth(struct adapter *pAdapter)
 484 {
 485         Hal_SetBandwidth(pAdapter);
 486 }
 487
 488 void SetAntenna(struct adapter *pAdapter)
 489 {
 490         Hal_SetAntenna(pAdapter);
 491 }
 492
 493 void    SetAntennaPathPower(struct adapter *pAdapter)
 494 {
 495         Hal_SetAntennaPathPower(pAdapter);
 496 }
 497
 498 void SetTxPower(struct adapter *pAdapter)
 499 {
 500         Hal_SetTxPower(pAdapter);
 501         }
 502
 503 void SetDataRate(struct adapter *pAdapter)
 504 {
 505         Hal_SetDataRate(pAdapter);
 506 }
 507
 508 void MP_PHY_SetRFPathSwitch(struct adapter *pAdapter , bool bMain)
 509 {
 510         PHY_SetRFPathSwitch(pAdapter, bMain);
 511 }
 512
 513 s32 SetThermalMeter(struct adapter *pAdapter, u8 target_ther)
 514 {
 515         return Hal_SetThermalMeter(pAdapter, target_ther);
 516 }
 517
 518 void GetThermalMeter(struct adapter *pAdapter, u8 *value)
 519 {
 520         Hal_GetThermalMeter(pAdapter, value);
 521 }
 522
 523 void SetSingleCarrierTx(struct adapter *pAdapter, u8 bStart)
 524 {
 525         PhySetTxPowerLevel(pAdapter);
 526         Hal_SetSingleCarrierTx(pAdapter, bStart);
 527 }
 528
 529 void SetSingleToneTx(struct adapter *pAdapter, u8 bStart)
 530 {
 531         PhySetTxPowerLevel(pAdapter);
 532         Hal_SetSingleToneTx(pAdapter, bStart);
 533 }
 534
 535 void SetCarrierSuppressionTx(struct adapter *pAdapter, u8 bStart)
 536 {
 537         PhySetTxPowerLevel(pAdapter);
 538         Hal_SetCarrierSuppressionTx(pAdapter, bStart);
 539 }
 540
 541 void SetContinuousTx(struct adapter *pAdapter, u8 bStart)
 542 {
 543         PhySetTxPowerLevel(pAdapter);
 544         Hal_SetContinuousTx(pAdapter, bStart);
 545 }
 546
 547
 548 void PhySetTxPowerLevel(struct adapter *pAdapter)
 549 {
 550         struct mp_priv *pmp_priv = &pAdapter->mppriv;
 551
 552         if (pmp_priv->bSetTxPower == 0) /*  for NO manually set power index */
 553                 PHY_SetTxPowerLevel8188E(pAdapter, pmp_priv->channel);
 554 }
 555
 556 /*  */
 557 static void dump_mpframe(struct adapter *padapter, struct xmit_frame *pmpframe)
 558 {
 559         rtw_hal_mgnt_xmit(padapter, pmpframe);
 560 }
 561
 562 static struct xmit_frame *alloc_mp_xmitframe(struct xmit_priv *pxmitpriv)
 563 {
 564         struct xmit_frame       *pmpframe;
 565         struct xmit_buf *pxmitbuf;
 566
 567         pmpframe = rtw_alloc_xmitframe(pxmitpriv);
 568         if (pmpframe == NULL)
 569                 return NULL;
 570
 571         pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
 572         if (pxmitbuf == NULL) {
 573                 rtw_free_xmitframe(pxmitpriv, pmpframe);
 574                 return NULL;
 575         }
 576
 577         pmpframe->frame_tag = MP_FRAMETAG;
 578
 579         pmpframe->pxmitbuf = pxmitbuf;
 580
 581         pmpframe->buf_addr = pxmitbuf->pbuf;
 582
 583         pxmitbuf->priv_data = pmpframe;
 584
 585         return pmpframe;
 586 }
 587
 588 static int mp_xmit_packet_thread(void *context)
 589 {
 590         struct xmit_frame       *pxmitframe;
 591         struct mp_tx            *pmptx;
 592         struct mp_priv  *pmp_priv;
 593         struct xmit_priv        *pxmitpriv;
 594         struct adapter *padapter;
 595
 596         pmp_priv = (struct mp_priv *)context;
 597         pmptx = &pmp_priv->tx;
 598         padapter = pmp_priv->papdater;
 599         pxmitpriv = &(padapter->xmitpriv);
 600
 601         thread_enter("RTW_MP_THREAD");
 602
 603         /* DBG_88E("%s:pkTx Start\n", __func__); */
 604         while (1) {
 605                 pxmitframe = alloc_mp_xmitframe(pxmitpriv);
 606                 if (pxmitframe == NULL) {
 607                         if (pmptx->stop ||
 608                             padapter->bSurpriseRemoved ||
 609                             padapter->bDriverStopped) {
 610                                 goto exit;
 611                         } else {
 612                                 msleep(1);
 613                                 continue;
 614                         }
 615                 }
 616
 617                 memcpy((u8 *)(pxmitframe->buf_addr+TXDESC_OFFSET), pmptx->buf, pmptx->write_size);
 618                 memcpy(&(pxmitframe->attrib), &(pmptx->attrib), sizeof(struct pkt_attrib));
 619
 620                 dump_mpframe(padapter, pxmitframe);
 621
 622                 pmptx->sended++;
 623                 pmp_priv->tx_pktcount++;
 624
 625                 if (pmptx->stop ||
 626                     padapter->bSurpriseRemoved ||
 627                     padapter->bDriverStopped)
 628                         goto exit;
 629                 if ((pmptx->count != 0) &&
 630                     (pmptx->count == pmptx->sended))
 631                         goto exit;
 632
 633                 flush_signals_thread();
 634         }
 635
 636 exit:
 637         kfree(pmptx->pallocated_buf);
 638         pmptx->pallocated_buf = NULL;
 639         pmptx->stop = 1;
 640
 641         complete_and_exit(NULL, 0);
 642 }
 643
 644 void fill_txdesc_for_mp(struct adapter *padapter, struct tx_desc *ptxdesc)
 645 {
 646         struct mp_priv *pmp_priv = &padapter->mppriv;
 647         memcpy(ptxdesc, &(pmp_priv->tx.desc), TXDESC_SIZE);
 648 }
 649
 650 void SetPacketTx(struct adapter *padapter)
 651 {
 652         u8 *ptr, *pkt_start, *pkt_end;
 653         u32 pkt_size;
 654         struct tx_desc *desc;
 655         struct rtw_ieee80211_hdr *hdr;
 656         u8 payload;
 657         s32 bmcast;
 658         struct pkt_attrib *pattrib;
 659         struct mp_priv *pmp_priv;
 660
 661
 662         pmp_priv = &padapter->mppriv;
 663         if (pmp_priv->tx.stop)
 664                 return;
 665         pmp_priv->tx.sended = 0;
 666         pmp_priv->tx.stop = 0;
 667         pmp_priv->tx_pktcount = 0;
 668
 669         /* 3 1. update_attrib() */
 670         pattrib = &pmp_priv->tx.attrib;
 671         memcpy(pattrib->src, padapter->eeprompriv.mac_addr, ETH_ALEN);
 672         memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
 673         memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
 674         bmcast = IS_MCAST(pattrib->ra);
 675         if (bmcast) {
 676                 pattrib->mac_id = 1;
 677                 pattrib->psta = rtw_get_bcmc_stainfo(padapter);
 678         } else {
 679                 pattrib->mac_id = 0;
 680                 pattrib->psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
 681         }
 682
 683         pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->pktlen;
 684
 685         /* 3 2. allocate xmit buffer */
 686         pkt_size = pattrib->last_txcmdsz;
 687
 688         kfree(pmp_priv->tx.pallocated_buf);
 689         pmp_priv->tx.write_size = pkt_size;
 690         pmp_priv->tx.buf_size = pkt_size + XMITBUF_ALIGN_SZ;
 691         pmp_priv->tx.pallocated_buf = rtw_zmalloc(pmp_priv->tx.buf_size);
 692         if (pmp_priv->tx.pallocated_buf == NULL) {
 693                 DBG_88E("%s: malloc(%d) fail!!\n", __func__, pmp_priv->tx.buf_size);
 694                 return;
 695         }
 696         pmp_priv->tx.buf = (u8 *)N_BYTE_ALIGMENT((size_t)(pmp_priv->tx.pallocated_buf), XMITBUF_ALIGN_SZ);
 697         ptr = pmp_priv->tx.buf;
 698
 699         desc = &(pmp_priv->tx.desc);
 700         _rtw_memset(desc, 0, TXDESC_SIZE);
 701         pkt_start = ptr;
 702         pkt_end = pkt_start + pkt_size;
 703
 704         /* 3 3. init TX descriptor */
 705         /*  offset 0 */
 706         desc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
 707         desc->txdw0 |= cpu_to_le32(pkt_size & 0x0000FFFF); /*  packet size */
 708         desc->txdw0 |= cpu_to_le32(((TXDESC_SIZE + OFFSET_SZ) << OFFSET_SHT) & 0x00FF0000); /* 32 bytes for TX Desc */
 709         if (bmcast)
 710                 desc->txdw0 |= cpu_to_le32(BMC); /*  broadcast packet */
 711
 712         desc->txdw1 |= cpu_to_le32((0x01 << 26) & 0xff000000);
 713         /*  offset 4 */
 714                 desc->txdw1 |= cpu_to_le32((pattrib->mac_id) & 0x3F); /* CAM_ID(MAC_ID) */
 715         desc->txdw1 |= cpu_to_le32((pattrib->qsel << QSEL_SHT) & 0x00001F00); /*  Queue Select, TID */
 716
 717         desc->txdw1 |= cpu_to_le32((pattrib->raid << RATE_ID_SHT) & 0x000F0000); /*  Rate Adaptive ID */
 718         /*  offset 8 */
 719         /*  offset 12 */
 720
 721         desc->txdw3 |= cpu_to_le32((pattrib->seqnum<<16)&0x0fff0000);
 722
 723         /*  offset 16 */
 724         desc->txdw4 |= cpu_to_le32(HW_SSN);
 725         desc->txdw4 |= cpu_to_le32(USERATE);
 726         desc->txdw4 |= cpu_to_le32(DISDATAFB);
 727
 728         if (pmp_priv->preamble) {
 729                 if (pmp_priv->rateidx <=  MPT_RATE_54M)
 730                         desc->txdw4 |= cpu_to_le32(DATA_SHORT); /*  CCK Short Preamble */
 731         }
 732         if (pmp_priv->bandwidth == HT_CHANNEL_WIDTH_40)
 733                 desc->txdw4 |= cpu_to_le32(DATA_BW);
 734
 735         /*  offset 20 */
 736         desc->txdw5 |= cpu_to_le32(pmp_priv->rateidx & 0x0000001F);
 737
 738         if (pmp_priv->preamble) {
 739                 if (pmp_priv->rateidx > MPT_RATE_54M)
 740                         desc->txdw5 |= cpu_to_le32(SGI); /*  MCS Short Guard Interval */
 741         }
 742         desc->txdw5 |= cpu_to_le32(RTY_LMT_EN); /*  retry limit enable */
 743         desc->txdw5 |= cpu_to_le32(0x00180000); /*  DATA/RTS Rate Fallback Limit */
 744
 745         /* 3 4. make wlan header, make_wlanhdr() */
 746         hdr = (struct rtw_ieee80211_hdr *)pkt_start;
 747         SetFrameSubType(&hdr->frame_ctl, pattrib->subtype);
 748         memcpy(hdr->addr1, pattrib->dst, ETH_ALEN); /*  DA */
 749         memcpy(hdr->addr2, pattrib->src, ETH_ALEN); /*  SA */
 750         memcpy(hdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN); /*  RA, BSSID */
 751
 752         /* 3 5. make payload */
 753         ptr = pkt_start + pattrib->hdrlen;
 754
 755         switch (pmp_priv->tx.payload) {
 756         case 0:
 757                 payload = 0x00;
 758                 break;
 759         case 1:
 760                 payload = 0x5a;
 761                 break;
 762         case 2:
 763                 payload = 0xa5;
 764                 break;
 765         case 3:
 766                 payload = 0xff;
 767                 break;
 768         default:
 769                 payload = 0x00;
 770                 break;
 771         }
 772
 773         _rtw_memset(ptr, payload, pkt_end - ptr);
 774
 775         /* 3 6. start thread */
 776         pmp_priv->tx.PktTxThread = kthread_run(mp_xmit_packet_thread, pmp_priv, "RTW_MP_THREAD");
 777         if (IS_ERR(pmp_priv->tx.PktTxThread))
 778                 DBG_88E("Create PktTx Thread Fail !!!!!\n");
 779 }
 780
 781 void SetPacketRx(struct adapter *pAdapter, u8 bStartRx)
 782 {
 783         struct hal_data_8188e   *pHalData = GET_HAL_DATA(pAdapter);
 784
 785         if (bStartRx) {
 786                 /*  Accept CRC error and destination address */
 787                 pHalData->ReceiveConfig = AAP | APM | AM | AB | APP_ICV | ADF | AMF | HTC_LOC_CTRL | APP_MIC | APP_PHYSTS;
 788
 789                 pHalData->ReceiveConfig |= ACRC32;
 790
 791                 rtw_write32(pAdapter, REG_RCR, pHalData->ReceiveConfig);
 792
 793                 /*  Accept all data frames */
 794                 rtw_write16(pAdapter, REG_RXFLTMAP2, 0xFFFF);
 795         } else {
 796                 rtw_write32(pAdapter, REG_RCR, 0);
 797         }
 798 }
 799
 800 void ResetPhyRxPktCount(struct adapter *pAdapter)
 801 {
 802         u32 i, phyrx_set = 0;
 803
 804         for (i = 0; i <= 0xF; i++) {
 805                 phyrx_set = 0;
 806                 phyrx_set |= _RXERR_RPT_SEL(i); /* select */
 807                 phyrx_set |= RXERR_RPT_RST;     /*  set counter to zero */
 808                 rtw_write32(pAdapter, REG_RXERR_RPT, phyrx_set);
 809         }
 810 }
 811
 812 static u32 GetPhyRxPktCounts(struct adapter *pAdapter, u32 selbit)
 813 {
 814         /* selection */
 815         u32 phyrx_set = 0, count = 0;
 816
 817         phyrx_set = _RXERR_RPT_SEL(selbit & 0xF);
 818         rtw_write32(pAdapter, REG_RXERR_RPT, phyrx_set);
 819
 820         /* Read packet count */
 821         count = rtw_read32(pAdapter, REG_RXERR_RPT) & RXERR_COUNTER_MASK;
 822
 823         return count;
 824 }
 825
 826 u32 GetPhyRxPktReceived(struct adapter *pAdapter)
 827 {
 828         u32 OFDM_cnt = 0, CCK_cnt = 0, HT_cnt = 0;
 829
 830         OFDM_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_OFDM_MPDU_OK);
 831         CCK_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_CCK_MPDU_OK);
 832         HT_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_HT_MPDU_OK);
 833
 834         return OFDM_cnt + CCK_cnt + HT_cnt;
 835 }
 836
 837 u32 GetPhyRxPktCRC32Error(struct adapter *pAdapter)
 838 {
 839         u32 OFDM_cnt = 0, CCK_cnt = 0, HT_cnt = 0;
 840
 841         OFDM_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_OFDM_MPDU_FAIL);
 842         CCK_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_CCK_MPDU_FAIL);
 843         HT_cnt = GetPhyRxPktCounts(pAdapter, RXERR_TYPE_HT_MPDU_FAIL);
 844
 845         return OFDM_cnt + CCK_cnt + HT_cnt;
 846 }
 847
 848 /* reg 0x808[9:0]: FFT data x */
 849 /* reg 0x808[22]:  0  -->  1  to get 1 FFT data y */
 850 /* reg 0x8B4[15:0]: FFT data y report */
 851 static u32 rtw_GetPSDData(struct adapter *pAdapter, u32 point)
 852 {
 853         int psd_val;
 854
 855
 856         psd_val = rtw_read32(pAdapter, 0x808);
 857         psd_val &= 0xFFBFFC00;
 858         psd_val |= point;
 859
 860         rtw_write32(pAdapter, 0x808, psd_val);
 861         mdelay(1);
 862         psd_val |= 0x00400000;
 863
 864         rtw_write32(pAdapter, 0x808, psd_val);
 865         mdelay(1);
 866         psd_val = rtw_read32(pAdapter, 0x8B4);
 867
 868         psd_val &= 0x0000FFFF;
 869
 870         return psd_val;
 871 }
 872
 873 /*
 874  *pts   start_point_min         stop_point_max
 875  * 128  64                      64 + 128 = 192
 876  * 256  128                     128 + 256 = 384
 877  * 512  256                     256 + 512 = 768
 878  * 1024 512                     512 + 1024 = 1536
 879  *
 880  */
 881 u32 mp_query_psd(struct adapter *pAdapter, u8 *data)
 882 {
 883         u32 i, psd_pts = 0, psd_start = 0, psd_stop = 0;
 884         u32 psd_data = 0;
 885         int ret;
 886
 887         if (!netif_running(pAdapter->pnetdev)) {
 888                 RT_TRACE(_module_mp_, _drv_warning_, ("mp_query_psd: Fail! interface not opened!\n"));
 889                 return 0;
 890         }
 891
 892         if (check_fwstate(&pAdapter->mlmepriv, WIFI_MP_STATE) == false) {
 893                 RT_TRACE(_module_mp_, _drv_warning_, ("mp_query_psd: Fail! not in MP mode!\n"));
 894                 return 0;
 895         }
 896
 897         if (strlen(data) == 0) { /* default value */
 898                 psd_pts = 128;
 899                 psd_start = 64;
 900                 psd_stop = 128;
 901         } else {
 902                 ret = sscanf(data, "pts =%d, start =%d, stop =%d",
 903                                 &psd_pts, &psd_start, &psd_stop);
 904                 if (ret != 3)
 905                         return 0;
 906         }
 907
 908         _rtw_memset(data, '\0', sizeof(*data));
 909
 910         i = psd_start;
 911         while (i < psd_stop) {
 912                 if (i >= psd_pts) {
 913                         psd_data = rtw_GetPSDData(pAdapter, i-psd_pts);
 914                 } else {
 915                         psd_data = rtw_GetPSDData(pAdapter, i);
 916                 }
 917                 sprintf(data, "%s%x ", data, psd_data);
 918                 i++;
 919         }
 920
 921         msleep(100);
 922         return strlen(data)+1;
 923 }
 924
 925 void _rtw_mp_xmit_priv(struct xmit_priv *pxmitpriv)
 926 {
 927            int i, res;
 928           struct adapter *padapter = pxmitpriv->adapter;
 929         struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
 930
 931         u32 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
 932         u32 num_xmit_extbuf = NR_XMIT_EXTBUFF;
 933         if (padapter->registrypriv.mp_mode == 0) {
 934                 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
 935                 num_xmit_extbuf = NR_XMIT_EXTBUFF;
 936         } else {
 937                 max_xmit_extbuf_size = 20000;
 938                 num_xmit_extbuf = 1;
 939         }
 940
 941         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 942         for (i = 0; i < num_xmit_extbuf; i++) {
 943                 rtw_os_xmit_resource_free(padapter, pxmitbuf, (max_xmit_extbuf_size + XMITBUF_ALIGN_SZ));
 944
 945                 pxmitbuf++;
 946         }
 947
 948         if (pxmitpriv->pallocated_xmit_extbuf)
 949                 vfree(pxmitpriv->pallocated_xmit_extbuf);
 950
 951         if (padapter->registrypriv.mp_mode == 0) {
 952                 max_xmit_extbuf_size = 20000;
 953                 num_xmit_extbuf = 1;
 954         } else {
 955                 max_xmit_extbuf_size = MAX_XMIT_EXTBUF_SZ;
 956                 num_xmit_extbuf = NR_XMIT_EXTBUFF;
 957         }
 958
 959         /*  Init xmit extension buff */
 960         _rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue);
 961
 962         pxmitpriv->pallocated_xmit_extbuf = vzalloc(num_xmit_extbuf * sizeof(struct xmit_buf) + 4);
 963
 964         if (pxmitpriv->pallocated_xmit_extbuf  == NULL) {
 965                 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xmit_extbuf fail!\n"));
 966                 res = _FAIL;
 967                 goto exit;
 968         }
 969
 970         pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((size_t)(pxmitpriv->pallocated_xmit_extbuf), 4);
 971
 972         pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
 973
 974         for (i = 0; i < num_xmit_extbuf; i++) {
 975                 _rtw_init_listhead(&pxmitbuf->list);
 976
 977                 pxmitbuf->priv_data = NULL;
 978                 pxmitbuf->padapter = padapter;
 979                 pxmitbuf->ext_tag = true;
 980
 981                 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, max_xmit_extbuf_size + XMITBUF_ALIGN_SZ);
 982                 if (res == _FAIL) {
 983                         res = _FAIL;
 984                         goto exit;
 985                 }
 986
 987                 rtw_list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmit_extbuf_queue.queue));
 988                 pxmitbuf++;
 989         }
 990
 991         pxmitpriv->free_xmit_extbuf_cnt = num_xmit_extbuf;
 992
 993 exit:
 994         ;
 995 }