1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 5 * 6 * Modifications for inclusion into the Linux staging tree are 7 * Copyright(c) 2010 Larry Finger. All rights reserved. 8 * 9 * Contact information: 10 * WLAN FAE <wlanfae@realtek.com> 11 * Larry Finger <Larry.Finger@lwfinger.net> 12 * 13 ******************************************************************************/ 14 #define _RTL871X_MP_C_ 15 16 #include "osdep_service.h" 17 #include "drv_types.h" 18 #include "rtl871x_mp_phy_regdef.h" 19 #include "rtl8712_cmd.h" 20 21 static void _init_mp_priv_(struct mp_priv *pmp_priv) 22 { 23 pmp_priv->mode = _LOOPBOOK_MODE_; 24 pmp_priv->curr_ch = 1; 25 pmp_priv->curr_modem = MIXED_PHY; 26 pmp_priv->curr_rateidx = 0; 27 pmp_priv->curr_txpoweridx = 0x14; 28 pmp_priv->antenna_tx = ANTENNA_A; 29 pmp_priv->antenna_rx = ANTENNA_AB; 30 pmp_priv->check_mp_pkt = 0; 31 pmp_priv->tx_pktcount = 0; 32 pmp_priv->rx_pktcount = 0; 33 pmp_priv->rx_crcerrpktcount = 0; 34 } 35 36 static int init_mp_priv(struct mp_priv *pmp_priv) 37 { 38 int i; 39 struct mp_xmit_frame *pmp_xmitframe; 40 41 _init_mp_priv_(pmp_priv); 42 _init_queue(&pmp_priv->free_mp_xmitqueue); 43 pmp_priv->pallocated_mp_xmitframe_buf = NULL; 44 pmp_priv->pallocated_mp_xmitframe_buf = kmalloc(NR_MP_XMITFRAME * 45 sizeof(struct mp_xmit_frame) + 4, 46 GFP_ATOMIC); 47 if (!pmp_priv->pallocated_mp_xmitframe_buf) { 48 return -ENOMEM; 49 } 50 pmp_priv->pmp_xmtframe_buf = pmp_priv->pallocated_mp_xmitframe_buf + 51 4 - 52 ((addr_t)(pmp_priv->pallocated_mp_xmitframe_buf) & 3); 53 pmp_xmitframe = (struct mp_xmit_frame *)pmp_priv->pmp_xmtframe_buf; 54 for (i = 0; i < NR_MP_XMITFRAME; i++) { 55 INIT_LIST_HEAD(&(pmp_xmitframe->list)); 56 list_add_tail(&(pmp_xmitframe->list), 57 &(pmp_priv->free_mp_xmitqueue.queue)); 58 pmp_xmitframe->pkt = NULL; 59 pmp_xmitframe->frame_tag = MP_FRAMETAG; 60 pmp_xmitframe->padapter = pmp_priv->papdater; 61 pmp_xmitframe++; 62 } 63 pmp_priv->free_mp_xmitframe_cnt = NR_MP_XMITFRAME; 64 return 0; 65 } 66 67 static int free_mp_priv(struct mp_priv *pmp_priv) 68 { 69 kfree(pmp_priv->pallocated_mp_xmitframe_buf); 70 return 0; 71 } 72 73 void mp871xinit(struct _adapter *padapter) 74 { 75 struct mp_priv *pmppriv = &padapter->mppriv; 76 77 pmppriv->papdater = padapter; 78 init_mp_priv(pmppriv); 79 } 80 81 void mp871xdeinit(struct _adapter *padapter) 82 { 83 struct mp_priv *pmppriv = &padapter->mppriv; 84 85 free_mp_priv(pmppriv); 86 } 87 88 /* 89 * Special for bb and rf reg read/write 90 */ 91 static u32 fw_iocmd_read(struct _adapter *pAdapter, struct IOCMD_STRUCT iocmd) 92 { 93 u32 cmd32 = 0, val32 = 0; 94 u8 iocmd_class = iocmd.cmdclass; 95 u16 iocmd_value = iocmd.value; 96 u8 iocmd_idx = iocmd.index; 97 98 cmd32 = (iocmd_class << 24) | (iocmd_value << 8) | iocmd_idx; 99 if (r8712_fw_cmd(pAdapter, cmd32)) 100 r8712_fw_cmd_data(pAdapter, &val32, 1); 101 else 102 val32 = 0; 103 return val32; 104 } 105 106 static u8 fw_iocmd_write(struct _adapter *pAdapter, 107 struct IOCMD_STRUCT iocmd, u32 value) 108 { 109 u32 cmd32 = 0; 110 u8 iocmd_class = iocmd.cmdclass; 111 u32 iocmd_value = iocmd.value; 112 u8 iocmd_idx = iocmd.index; 113 114 r8712_fw_cmd_data(pAdapter, &value, 0); 115 msleep(100); 116 cmd32 = (iocmd_class << 24) | (iocmd_value << 8) | iocmd_idx; 117 return r8712_fw_cmd(pAdapter, cmd32); 118 } 119 120 /* offset : 0X800~0XFFF */ 121 u32 r8712_bb_reg_read(struct _adapter *pAdapter, u16 offset) 122 { 123 u8 shift = offset & 0x0003; /* 4 byte access */ 124 u16 bb_addr = offset & 0x0FFC; /* 4 byte access */ 125 u32 bb_val = 0; 126 struct IOCMD_STRUCT iocmd; 127 128 iocmd.cmdclass = IOCMD_CLASS_BB_RF; 129 iocmd.value = bb_addr; 130 iocmd.index = IOCMD_BB_READ_IDX; 131 bb_val = fw_iocmd_read(pAdapter, iocmd); 132 if (shift != 0) { 133 u32 bb_val2 = 0; 134 135 bb_val >>= (shift * 8); 136 iocmd.value += 4; 137 bb_val2 = fw_iocmd_read(pAdapter, iocmd); 138 bb_val2 <<= ((4 - shift) * 8); 139 bb_val |= bb_val2; 140 } 141 return bb_val; 142 } 143 144 /* offset : 0X800~0XFFF */ 145 u8 r8712_bb_reg_write(struct _adapter *pAdapter, u16 offset, u32 value) 146 { 147 u8 shift = offset & 0x0003; /* 4 byte access */ 148 u16 bb_addr = offset & 0x0FFC; /* 4 byte access */ 149 struct IOCMD_STRUCT iocmd; 150 151 iocmd.cmdclass = IOCMD_CLASS_BB_RF; 152 iocmd.value = bb_addr; 153 iocmd.index = IOCMD_BB_WRITE_IDX; 154 if (shift != 0) { 155 u32 oldValue = 0; 156 u32 newValue = value; 157 158 oldValue = r8712_bb_reg_read(pAdapter, iocmd.value); 159 oldValue &= (0xFFFFFFFF >> ((4 - shift) * 8)); 160 value = oldValue | (newValue << (shift * 8)); 161 if (!fw_iocmd_write(pAdapter, iocmd, value)) 162 return false; 163 iocmd.value += 4; 164 oldValue = r8712_bb_reg_read(pAdapter, iocmd.value); 165 oldValue &= (0xFFFFFFFF << (shift * 8)); 166 value = oldValue | (newValue >> ((4 - shift) * 8)); 167 } 168 return fw_iocmd_write(pAdapter, iocmd, value); 169 } 170 171 /* offset : 0x00 ~ 0xFF */ 172 u32 r8712_rf_reg_read(struct _adapter *pAdapter, u8 path, u8 offset) 173 { 174 u16 rf_addr = (path << 8) | offset; 175 struct IOCMD_STRUCT iocmd; 176 177 iocmd.cmdclass = IOCMD_CLASS_BB_RF; 178 iocmd.value = rf_addr; 179 iocmd.index = IOCMD_RF_READ_IDX; 180 return fw_iocmd_read(pAdapter, iocmd); 181 } 182 183 u8 r8712_rf_reg_write(struct _adapter *pAdapter, u8 path, u8 offset, u32 value) 184 { 185 u16 rf_addr = (path << 8) | offset; 186 struct IOCMD_STRUCT iocmd; 187 188 iocmd.cmdclass = IOCMD_CLASS_BB_RF; 189 iocmd.value = rf_addr; 190 iocmd.index = IOCMD_RF_WRIT_IDX; 191 return fw_iocmd_write(pAdapter, iocmd, value); 192 } 193 194 static u32 bitshift(u32 bitmask) 195 { 196 u32 i; 197 198 for (i = 0; i <= 31; i++) 199 if (((bitmask >> i) & 0x1) == 1) 200 break; 201 return i; 202 } 203 204 static u32 get_bb_reg(struct _adapter *pAdapter, u16 offset, u32 bitmask) 205 { 206 u32 org_value, bit_shift; 207 208 org_value = r8712_bb_reg_read(pAdapter, offset); 209 bit_shift = bitshift(bitmask); 210 return (org_value & bitmask) >> bit_shift; 211 } 212 213 static u8 set_bb_reg(struct _adapter *pAdapter, 214 u16 offset, 215 u32 bitmask, 216 u32 value) 217 { 218 u32 org_value, bit_shift, new_value; 219 220 if (bitmask != bMaskDWord) { 221 org_value = r8712_bb_reg_read(pAdapter, offset); 222 bit_shift = bitshift(bitmask); 223 new_value = (org_value & (~bitmask)) | (value << bit_shift); 224 } else { 225 new_value = value; 226 } 227 return r8712_bb_reg_write(pAdapter, offset, new_value); 228 } 229 230 static u32 get_rf_reg(struct _adapter *pAdapter, u8 path, u8 offset, 231 u32 bitmask) 232 { 233 u32 org_value, bit_shift; 234 235 org_value = r8712_rf_reg_read(pAdapter, path, offset); 236 bit_shift = bitshift(bitmask); 237 return (org_value & bitmask) >> bit_shift; 238 } 239 240 static u8 set_rf_reg(struct _adapter *pAdapter, u8 path, u8 offset, u32 bitmask, 241 u32 value) 242 { 243 u32 org_value, bit_shift, new_value; 244 245 if (bitmask != bMaskDWord) { 246 org_value = r8712_rf_reg_read(pAdapter, path, offset); 247 bit_shift = bitshift(bitmask); 248 new_value = (org_value & (~bitmask)) | (value << bit_shift); 249 } else { 250 new_value = value; 251 } 252 return r8712_rf_reg_write(pAdapter, path, offset, new_value); 253 } 254 255 /* 256 * SetChannel 257 * Description 258 * Use H2C command to change channel, 259 * not only modify rf register, but also other setting need to be done. 260 */ 261 void r8712_SetChannel(struct _adapter *pAdapter) 262 { 263 struct cmd_priv *pcmdpriv = &pAdapter->cmdpriv; 264 struct cmd_obj *pcmd = NULL; 265 struct SetChannel_parm *pparm = NULL; 266 u16 code = GEN_CMD_CODE(_SetChannel); 267 268 pcmd = kmalloc(sizeof(*pcmd), GFP_ATOMIC); 269 if (!pcmd) 270 return; 271 pparm = kmalloc(sizeof(*pparm), GFP_ATOMIC); 272 if (!pparm) { 273 kfree(pcmd); 274 return; 275 } 276 pparm->curr_ch = pAdapter->mppriv.curr_ch; 277 init_h2fwcmd_w_parm_no_rsp(pcmd, pparm, code); 278 r8712_enqueue_cmd(pcmdpriv, pcmd); 279 } 280 281 static void SetCCKTxPower(struct _adapter *pAdapter, u8 TxPower) 282 { 283 u16 TxAGC = 0; 284 285 TxAGC = TxPower; 286 set_bb_reg(pAdapter, rTxAGC_CCK_Mcs32, bTxAGCRateCCK, TxAGC); 287 } 288 289 static void SetOFDMTxPower(struct _adapter *pAdapter, u8 TxPower) 290 { 291 u32 TxAGC = 0; 292 293 TxAGC |= ((TxPower << 24) | (TxPower << 16) | (TxPower << 8) | 294 TxPower); 295 set_bb_reg(pAdapter, rTxAGC_Rate18_06, bTxAGCRate18_06, TxAGC); 296 set_bb_reg(pAdapter, rTxAGC_Rate54_24, bTxAGCRate54_24, TxAGC); 297 set_bb_reg(pAdapter, rTxAGC_Mcs03_Mcs00, bTxAGCRateMCS3_MCS0, TxAGC); 298 set_bb_reg(pAdapter, rTxAGC_Mcs07_Mcs04, bTxAGCRateMCS7_MCS4, TxAGC); 299 set_bb_reg(pAdapter, rTxAGC_Mcs11_Mcs08, bTxAGCRateMCS11_MCS8, TxAGC); 300 set_bb_reg(pAdapter, rTxAGC_Mcs15_Mcs12, bTxAGCRateMCS15_MCS12, TxAGC); 301 } 302 303 void r8712_SetTxPower(struct _adapter *pAdapter) 304 { 305 u8 TxPower = pAdapter->mppriv.curr_txpoweridx; 306 307 SetCCKTxPower(pAdapter, TxPower); 308 SetOFDMTxPower(pAdapter, TxPower); 309 } 310 311 void r8712_SetTxAGCOffset(struct _adapter *pAdapter, u32 ulTxAGCOffset) 312 { 313 u32 TxAGCOffset_B, TxAGCOffset_C, TxAGCOffset_D, tmpAGC; 314 315 TxAGCOffset_B = ulTxAGCOffset & 0x000000ff; 316 TxAGCOffset_C = (ulTxAGCOffset & 0x0000ff00) >> 8; 317 TxAGCOffset_D = (ulTxAGCOffset & 0x00ff0000) >> 16; 318 tmpAGC = TxAGCOffset_D << 8 | TxAGCOffset_C << 4 | TxAGCOffset_B; 319 set_bb_reg(pAdapter, rFPGA0_TxGainStage, 320 (bXBTxAGC | bXCTxAGC | bXDTxAGC), tmpAGC); 321 } 322 323 void r8712_SetDataRate(struct _adapter *pAdapter) 324 { 325 u8 path = RF_PATH_A; 326 u8 offset = RF_SYN_G2; 327 u32 value; 328 329 value = (pAdapter->mppriv.curr_rateidx < 4) ? 0x4440 : 0xF200; 330 r8712_rf_reg_write(pAdapter, path, offset, value); 331 } 332 333 void r8712_SwitchBandwidth(struct _adapter *pAdapter) 334 { 335 /* 3 1.Set MAC register : BWOPMODE bit2:1 20MhzBW */ 336 u8 regBwOpMode = 0; 337 u8 Bandwidth = pAdapter->mppriv.curr_bandwidth; 338 339 regBwOpMode = r8712_read8(pAdapter, 0x10250203); 340 if (Bandwidth == HT_CHANNEL_WIDTH_20) 341 regBwOpMode |= BIT(2); 342 else 343 regBwOpMode &= ~(BIT(2)); 344 r8712_write8(pAdapter, 0x10250203, regBwOpMode); 345 /* 3 2.Set PHY related register */ 346 switch (Bandwidth) { 347 /* 20 MHz channel*/ 348 case HT_CHANNEL_WIDTH_20: 349 set_bb_reg(pAdapter, rFPGA0_RFMOD, bRFMOD, 0x0); 350 set_bb_reg(pAdapter, rFPGA1_RFMOD, bRFMOD, 0x0); 351 /* Use PHY_REG.txt default value. Do not need to change. 352 * Correct the tx power for CCK rate in 40M. 353 * It is set in Tx descriptor for 8192x series 354 */ 355 set_bb_reg(pAdapter, rFPGA0_AnalogParameter2, bMaskDWord, 0x58); 356 break; 357 /* 40 MHz channel*/ 358 case HT_CHANNEL_WIDTH_40: 359 set_bb_reg(pAdapter, rFPGA0_RFMOD, bRFMOD, 0x1); 360 set_bb_reg(pAdapter, rFPGA1_RFMOD, bRFMOD, 0x1); 361 /* Use PHY_REG.txt default value. Do not need to change. 362 * Correct the tx power for CCK rate in 40M. 363 * Set Control channel to upper or lower. These settings are 364 * required only for 40MHz 365 */ 366 set_bb_reg(pAdapter, rCCK0_System, bCCKSideBand, 367 (HAL_PRIME_CHNL_OFFSET_DONT_CARE >> 1)); 368 set_bb_reg(pAdapter, rOFDM1_LSTF, 0xC00, 369 HAL_PRIME_CHNL_OFFSET_DONT_CARE); 370 set_bb_reg(pAdapter, rFPGA0_AnalogParameter2, bMaskDWord, 0x18); 371 break; 372 default: 373 break; 374 } 375 376 /* 3 3.Set RF related register */ 377 switch (Bandwidth) { 378 case HT_CHANNEL_WIDTH_20: 379 set_rf_reg(pAdapter, RF_PATH_A, RF_CHNLBW, 380 BIT(10) | BIT(11), 0x01); 381 break; 382 case HT_CHANNEL_WIDTH_40: 383 set_rf_reg(pAdapter, RF_PATH_A, RF_CHNLBW, 384 BIT(10) | BIT(11), 0x00); 385 break; 386 default: 387 break; 388 } 389 } 390 /*------------------------------Define structure----------------------------*/ 391 struct R_ANTENNA_SELECT_OFDM { 392 u32 r_tx_antenna:4; 393 u32 r_ant_l:4; 394 u32 r_ant_non_ht:4; 395 u32 r_ant_ht1:4; 396 u32 r_ant_ht2:4; 397 u32 r_ant_ht_s1:4; 398 u32 r_ant_non_ht_s1:4; 399 u32 OFDM_TXSC:2; 400 u32 Reserved:2; 401 }; 402 403 struct R_ANTENNA_SELECT_CCK { 404 u8 r_cckrx_enable_2:2; 405 u8 r_cckrx_enable:2; 406 u8 r_ccktx_enable:4; 407 }; 408 409 void r8712_SwitchAntenna(struct _adapter *pAdapter) 410 { 411 u32 ofdm_tx_en_val = 0, ofdm_tx_ant_sel_val = 0; 412 u8 ofdm_rx_ant_sel_val = 0; 413 u8 cck_ant_select_val = 0; 414 u32 cck_ant_sel_val = 0; 415 struct R_ANTENNA_SELECT_CCK *p_cck_txrx; 416 417 p_cck_txrx = (struct R_ANTENNA_SELECT_CCK *)&cck_ant_select_val; 418 419 switch (pAdapter->mppriv.antenna_tx) { 420 case ANTENNA_A: 421 /* From SD3 Willis suggestion !!! Set RF A=TX and B as standby*/ 422 set_bb_reg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 2); 423 set_bb_reg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 1); 424 ofdm_tx_en_val = 0x3; 425 ofdm_tx_ant_sel_val = 0x11111111;/* Power save */ 426 p_cck_txrx->r_ccktx_enable = 0x8; 427 break; 428 case ANTENNA_B: 429 set_bb_reg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 1); 430 set_bb_reg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 2); 431 ofdm_tx_en_val = 0x3; 432 ofdm_tx_ant_sel_val = 0x22222222;/* Power save */ 433 p_cck_txrx->r_ccktx_enable = 0x4; 434 break; 435 case ANTENNA_AB: /* For 8192S */ 436 set_bb_reg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 2); 437 set_bb_reg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 2); 438 ofdm_tx_en_val = 0x3; 439 ofdm_tx_ant_sel_val = 0x3321333; /* Disable Power save */ 440 p_cck_txrx->r_ccktx_enable = 0xC; 441 break; 442 default: 443 break; 444 } 445 /*OFDM Tx*/ 446 set_bb_reg(pAdapter, rFPGA1_TxInfo, 0xffffffff, ofdm_tx_ant_sel_val); 447 /*OFDM Tx*/ 448 set_bb_reg(pAdapter, rFPGA0_TxInfo, 0x0000000f, ofdm_tx_en_val); 449 switch (pAdapter->mppriv.antenna_rx) { 450 case ANTENNA_A: 451 ofdm_rx_ant_sel_val = 0x1; /* A */ 452 p_cck_txrx->r_cckrx_enable = 0x0; /* default: A */ 453 p_cck_txrx->r_cckrx_enable_2 = 0x0; /* option: A */ 454 break; 455 case ANTENNA_B: 456 ofdm_rx_ant_sel_val = 0x2; /* B */ 457 p_cck_txrx->r_cckrx_enable = 0x1; /* default: B */ 458 p_cck_txrx->r_cckrx_enable_2 = 0x1; /* option: B */ 459 break; 460 case ANTENNA_AB: 461 ofdm_rx_ant_sel_val = 0x3; /* AB */ 462 p_cck_txrx->r_cckrx_enable = 0x0; /* default:A */ 463 p_cck_txrx->r_cckrx_enable_2 = 0x1; /* option:B */ 464 break; 465 default: 466 break; 467 } 468 /*OFDM Rx*/ 469 set_bb_reg(pAdapter, rOFDM0_TRxPathEnable, 0x0000000f, 470 ofdm_rx_ant_sel_val); 471 /*OFDM Rx*/ 472 set_bb_reg(pAdapter, rOFDM1_TRxPathEnable, 0x0000000f, 473 ofdm_rx_ant_sel_val); 474 475 cck_ant_sel_val = cck_ant_select_val; 476 /*CCK TxRx*/ 477 set_bb_reg(pAdapter, rCCK0_AFESetting, bMaskByte3, cck_ant_sel_val); 478 } 479 480 static void TriggerRFThermalMeter(struct _adapter *pAdapter) 481 { 482 /* 0x24: RF Reg[6:5] */ 483 set_rf_reg(pAdapter, RF_PATH_A, RF_T_METER, bRFRegOffsetMask, 0x60); 484 } 485 486 static u32 ReadRFThermalMeter(struct _adapter *pAdapter) 487 { 488 /* 0x24: RF Reg[4:0] */ 489 return get_rf_reg(pAdapter, RF_PATH_A, RF_T_METER, 0x1F); 490 } 491 492 void r8712_GetThermalMeter(struct _adapter *pAdapter, u32 *value) 493 { 494 TriggerRFThermalMeter(pAdapter); 495 msleep(1000); 496 *value = ReadRFThermalMeter(pAdapter); 497 } 498 499 void r8712_SetSingleCarrierTx(struct _adapter *pAdapter, u8 bStart) 500 { 501 if (bStart) { /* Start Single Carrier. */ 502 /* 1. if OFDM block on? */ 503 if (!get_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn)) 504 /*set OFDM block on*/ 505 set_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bEnable); 506 /* 2. set CCK test mode off, set to CCK normal mode */ 507 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, bDisable); 508 /* 3. turn on scramble setting */ 509 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, bEnable); 510 /* 4. Turn On Single Carrier Tx and off the other test modes. */ 511 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable); 512 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bEnable); 513 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable); 514 } else { /* Stop Single Carrier.*/ 515 /* Turn off all test modes.*/ 516 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable); 517 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, 518 bDisable); 519 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable); 520 msleep(20); 521 /*BB Reset*/ 522 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x0); 523 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x1); 524 } 525 } 526 527 void r8712_SetSingleToneTx(struct _adapter *pAdapter, u8 bStart) 528 { 529 u8 rfPath; 530 531 switch (pAdapter->mppriv.antenna_tx) { 532 case ANTENNA_B: 533 rfPath = RF_PATH_B; 534 break; 535 case ANTENNA_A: 536 default: 537 rfPath = RF_PATH_A; 538 break; 539 } 540 if (bStart) { /* Start Single Tone.*/ 541 set_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn, bDisable); 542 set_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bDisable); 543 set_rf_reg(pAdapter, rfPath, RF_TX_G2, bRFRegOffsetMask, 544 0xd4000); 545 msleep(100); 546 /* PAD all on.*/ 547 set_rf_reg(pAdapter, rfPath, RF_AC, bRFRegOffsetMask, 0x2001f); 548 msleep(100); 549 } else { /* Stop Single Tone.*/ 550 set_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn, bEnable); 551 set_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bEnable); 552 set_rf_reg(pAdapter, rfPath, RF_TX_G2, bRFRegOffsetMask, 553 0x54000); 554 msleep(100); 555 /* PAD all on.*/ 556 set_rf_reg(pAdapter, rfPath, RF_AC, bRFRegOffsetMask, 0x30000); 557 msleep(100); 558 } 559 } 560 561 void r8712_SetCarrierSuppressionTx(struct _adapter *pAdapter, u8 bStart) 562 { 563 if (bStart) { /* Start Carrier Suppression.*/ 564 if (pAdapter->mppriv.curr_rateidx <= MPT_RATE_11M) { 565 /* 1. if CCK block on? */ 566 if (!get_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn)) { 567 /*set CCK block on*/ 568 set_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn, 569 bEnable); 570 } 571 /* Turn Off All Test Mode */ 572 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, 573 bDisable); 574 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, 575 bDisable); 576 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, 577 bDisable); 578 /*transmit mode*/ 579 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, 0x2); 580 /*turn off scramble setting*/ 581 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, 582 bDisable); 583 /*Set CCK Tx Test Rate*/ 584 /*Set FTxRate to 1Mbps*/ 585 set_bb_reg(pAdapter, rCCK0_System, bCCKTxRate, 0x0); 586 } 587 } else { /* Stop Carrier Suppression. */ 588 if (pAdapter->mppriv.curr_rateidx <= MPT_RATE_11M) { 589 /*normal mode*/ 590 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, 0x0); 591 /*turn on scramble setting*/ 592 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, 593 bEnable); 594 /*BB Reset*/ 595 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x0); 596 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x1); 597 } 598 } 599 } 600 601 static void SetCCKContinuousTx(struct _adapter *pAdapter, u8 bStart) 602 { 603 u32 cckrate; 604 605 if (bStart) { 606 /* 1. if CCK block on? */ 607 if (!get_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn)) { 608 /*set CCK block on*/ 609 set_bb_reg(pAdapter, rFPGA0_RFMOD, bCCKEn, bEnable); 610 } 611 /* Turn Off All Test Mode */ 612 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable); 613 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable); 614 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable); 615 /*Set CCK Tx Test Rate*/ 616 cckrate = pAdapter->mppriv.curr_rateidx; 617 set_bb_reg(pAdapter, rCCK0_System, bCCKTxRate, cckrate); 618 /*transmit mode*/ 619 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, 0x2); 620 /*turn on scramble setting*/ 621 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, bEnable); 622 } else { 623 /*normal mode*/ 624 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, 0x0); 625 /*turn on scramble setting*/ 626 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, bEnable); 627 /*BB Reset*/ 628 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x0); 629 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x1); 630 } 631 } /* mpt_StartCckContTx */ 632 633 static void SetOFDMContinuousTx(struct _adapter *pAdapter, u8 bStart) 634 { 635 if (bStart) { 636 /* 1. if OFDM block on? */ 637 if (!get_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn)) { 638 /*set OFDM block on*/ 639 set_bb_reg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bEnable); 640 } 641 /* 2. set CCK test mode off, set to CCK normal mode*/ 642 set_bb_reg(pAdapter, rCCK0_System, bCCKBBMode, bDisable); 643 /* 3. turn on scramble setting */ 644 set_bb_reg(pAdapter, rCCK0_System, bCCKScramble, bEnable); 645 /* 4. Turn On Continue Tx and turn off the other test modes.*/ 646 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bEnable); 647 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable); 648 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable); 649 } else { 650 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable); 651 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, 652 bDisable); 653 set_bb_reg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable); 654 msleep(20); 655 /*BB Reset*/ 656 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x0); 657 set_bb_reg(pAdapter, rPMAC_Reset, bBBResetB, 0x1); 658 } 659 } /* mpt_StartOfdmContTx */ 660 661 void r8712_SetContinuousTx(struct _adapter *pAdapter, u8 bStart) 662 { 663 /* ADC turn off [bit24-21] adc port0 ~ port1 */ 664 if (bStart) { 665 r8712_bb_reg_write(pAdapter, rRx_Wait_CCCA, 666 r8712_bb_reg_read(pAdapter, 667 rRx_Wait_CCCA) & 0xFE1FFFFF); 668 msleep(100); 669 } 670 if (pAdapter->mppriv.curr_rateidx <= MPT_RATE_11M) 671 SetCCKContinuousTx(pAdapter, bStart); 672 else if ((pAdapter->mppriv.curr_rateidx >= MPT_RATE_6M) && 673 (pAdapter->mppriv.curr_rateidx <= MPT_RATE_MCS15)) 674 SetOFDMContinuousTx(pAdapter, bStart); 675 /* ADC turn on [bit24-21] adc port0 ~ port1 */ 676 if (!bStart) 677 r8712_bb_reg_write(pAdapter, rRx_Wait_CCCA, 678 r8712_bb_reg_read(pAdapter, 679 rRx_Wait_CCCA) | 0x01E00000); 680 } 681 682 void r8712_ResetPhyRxPktCount(struct _adapter *pAdapter) 683 { 684 u32 i, phyrx_set = 0; 685 686 for (i = OFDM_PPDU_BIT; i <= HT_MPDU_FAIL_BIT; i++) { 687 phyrx_set = 0; 688 phyrx_set |= (i << 28); /*select*/ 689 phyrx_set |= 0x08000000; /* set counter to zero*/ 690 r8712_write32(pAdapter, RXERR_RPT, phyrx_set); 691 } 692 } 693 694 static u32 GetPhyRxPktCounts(struct _adapter *pAdapter, u32 selbit) 695 { 696 /*selection*/ 697 u32 phyrx_set = 0; 698 u32 SelectBit; 699 700 SelectBit = selbit << 28; 701 phyrx_set |= (SelectBit & 0xF0000000); 702 r8712_write32(pAdapter, RXERR_RPT, phyrx_set); 703 /*Read packet count*/ 704 return r8712_read32(pAdapter, RXERR_RPT) & RPTMaxCount; 705 } 706 707 u32 r8712_GetPhyRxPktReceived(struct _adapter *pAdapter) 708 { 709 u32 OFDM_cnt = GetPhyRxPktCounts(pAdapter, OFDM_MPDU_OK_BIT); 710 u32 CCK_cnt = GetPhyRxPktCounts(pAdapter, CCK_MPDU_OK_BIT); 711 u32 HT_cnt = GetPhyRxPktCounts(pAdapter, HT_MPDU_OK_BIT); 712 713 return OFDM_cnt + CCK_cnt + HT_cnt; 714 } 715 716 u32 r8712_GetPhyRxPktCRC32Error(struct _adapter *pAdapter) 717 { 718 u32 OFDM_cnt = GetPhyRxPktCounts(pAdapter, OFDM_MPDU_FAIL_BIT); 719 u32 CCK_cnt = GetPhyRxPktCounts(pAdapter, CCK_MPDU_FAIL_BIT); 720 u32 HT_cnt = GetPhyRxPktCounts(pAdapter, HT_MPDU_FAIL_BIT); 721 722 return OFDM_cnt + CCK_cnt + HT_cnt; 723 } 724