1 /****************************************************************************** 2 * 3 * Copyright(c) 2009-2012 Realtek Corporation. 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 * The full GNU General Public License is included in this distribution in the 19 * file called LICENSE. 20 * 21 * Contact Information: 22 * wlanfae <wlanfae@realtek.com> 23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, 24 * Hsinchu 300, Taiwan. 25 * 26 * Larry Finger <Larry.Finger@lwfinger.net> 27 * 28 *****************************************************************************/ 29 30 #include "../wifi.h" 31 #include "reg.h" 32 #include "def.h" 33 #include "phy.h" 34 #include "rf.h" 35 #include "dm.h" 36 37 38 static void _rtl92s_get_powerbase(struct ieee80211_hw *hw, u8 *p_pwrlevel, 39 u8 chnl, u32 *ofdmbase, u32 *mcsbase, 40 u8 *p_final_pwridx) 41 { 42 struct rtl_priv *rtlpriv = rtl_priv(hw); 43 struct rtl_phy *rtlphy = &(rtlpriv->phy); 44 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 45 u32 pwrbase0, pwrbase1; 46 u8 legacy_pwrdiff = 0, ht20_pwrdiff = 0; 47 u8 i, pwrlevel[4]; 48 49 for (i = 0; i < 2; i++) 50 pwrlevel[i] = p_pwrlevel[i]; 51 52 /* We only care about the path A for legacy. */ 53 if (rtlefuse->eeprom_version < 2) { 54 pwrbase0 = pwrlevel[0] + (rtlefuse->legacy_httxpowerdiff & 0xf); 55 } else { 56 legacy_pwrdiff = rtlefuse->txpwr_legacyhtdiff 57 [RF90_PATH_A][chnl - 1]; 58 59 /* For legacy OFDM, tx pwr always > HT OFDM pwr. 60 * We do not care Path B 61 * legacy OFDM pwr diff. NO BB register 62 * to notify HW. */ 63 pwrbase0 = pwrlevel[0] + legacy_pwrdiff; 64 } 65 66 pwrbase0 = (pwrbase0 << 24) | (pwrbase0 << 16) | (pwrbase0 << 8) | 67 pwrbase0; 68 *ofdmbase = pwrbase0; 69 70 /* MCS rates */ 71 if (rtlefuse->eeprom_version >= 2) { 72 /* Check HT20 to HT40 diff */ 73 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20) { 74 for (i = 0; i < 2; i++) { 75 /* rf-A, rf-B */ 76 /* HT 20<->40 pwr diff */ 77 ht20_pwrdiff = rtlefuse->txpwr_ht20diff 78 [i][chnl - 1]; 79 80 if (ht20_pwrdiff < 8) /* 0~+7 */ 81 pwrlevel[i] += ht20_pwrdiff; 82 else /* index8-15=-8~-1 */ 83 pwrlevel[i] -= (16 - ht20_pwrdiff); 84 } 85 } 86 } 87 88 /* use index of rf-A */ 89 pwrbase1 = pwrlevel[0]; 90 pwrbase1 = (pwrbase1 << 24) | (pwrbase1 << 16) | (pwrbase1 << 8) | 91 pwrbase1; 92 *mcsbase = pwrbase1; 93 94 /* The following is for Antenna 95 * diff from Ant-B to Ant-A */ 96 p_final_pwridx[0] = pwrlevel[0]; 97 p_final_pwridx[1] = pwrlevel[1]; 98 99 switch (rtlefuse->eeprom_regulatory) { 100 case 3: 101 /* The following is for calculation 102 * of the power diff for Ant-B to Ant-A. */ 103 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) { 104 p_final_pwridx[0] += rtlefuse->pwrgroup_ht40 105 [RF90_PATH_A][ 106 chnl - 1]; 107 p_final_pwridx[1] += rtlefuse->pwrgroup_ht40 108 [RF90_PATH_B][ 109 chnl - 1]; 110 } else { 111 p_final_pwridx[0] += rtlefuse->pwrgroup_ht20 112 [RF90_PATH_A][ 113 chnl - 1]; 114 p_final_pwridx[1] += rtlefuse->pwrgroup_ht20 115 [RF90_PATH_B][ 116 chnl - 1]; 117 } 118 break; 119 default: 120 break; 121 } 122 123 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) { 124 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 125 "40MHz finalpwr_idx (A / B) = 0x%x / 0x%x\n", 126 p_final_pwridx[0], p_final_pwridx[1]); 127 } else { 128 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 129 "20MHz finalpwr_idx (A / B) = 0x%x / 0x%x\n", 130 p_final_pwridx[0], p_final_pwridx[1]); 131 } 132 } 133 134 static void _rtl92s_set_antennadiff(struct ieee80211_hw *hw, 135 u8 *p_final_pwridx) 136 { 137 struct rtl_priv *rtlpriv = rtl_priv(hw); 138 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 139 struct rtl_phy *rtlphy = &(rtlpriv->phy); 140 s8 ant_pwr_diff = 0; 141 u32 u4reg_val = 0; 142 143 if (rtlphy->rf_type == RF_2T2R) { 144 ant_pwr_diff = p_final_pwridx[1] - p_final_pwridx[0]; 145 146 /* range is from 7~-8, 147 * index = 0x0~0xf */ 148 if (ant_pwr_diff > 7) 149 ant_pwr_diff = 7; 150 if (ant_pwr_diff < -8) 151 ant_pwr_diff = -8; 152 153 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 154 "Antenna Diff from RF-B to RF-A = %d (0x%x)\n", 155 ant_pwr_diff, ant_pwr_diff & 0xf); 156 157 ant_pwr_diff &= 0xf; 158 } 159 160 /* Antenna TX power difference */ 161 rtlefuse->antenna_txpwdiff[2] = 0;/* RF-D, don't care */ 162 rtlefuse->antenna_txpwdiff[1] = 0;/* RF-C, don't care */ 163 rtlefuse->antenna_txpwdiff[0] = (u8)(ant_pwr_diff); /* RF-B */ 164 165 u4reg_val = rtlefuse->antenna_txpwdiff[2] << 8 | 166 rtlefuse->antenna_txpwdiff[1] << 4 | 167 rtlefuse->antenna_txpwdiff[0]; 168 169 rtl_set_bbreg(hw, RFPGA0_TXGAINSTAGE, (BXBTXAGC | BXCTXAGC | BXDTXAGC), 170 u4reg_val); 171 172 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, "Write BCD-Diff(0x%x) = 0x%x\n", 173 RFPGA0_TXGAINSTAGE, u4reg_val); 174 } 175 176 static void _rtl92s_get_txpower_writeval_byregulatory(struct ieee80211_hw *hw, 177 u8 chnl, u8 index, 178 u32 pwrbase0, 179 u32 pwrbase1, 180 u32 *p_outwrite_val) 181 { 182 struct rtl_priv *rtlpriv = rtl_priv(hw); 183 struct rtl_phy *rtlphy = &(rtlpriv->phy); 184 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 185 u8 i, chnlgroup, pwrdiff_limit[4]; 186 u32 writeval, customer_limit; 187 188 /* Index 0 & 1= legacy OFDM, 2-5=HT_MCS rate */ 189 switch (rtlefuse->eeprom_regulatory) { 190 case 0: 191 /* Realtek better performance increase power diff 192 * defined by Realtek for large power */ 193 chnlgroup = 0; 194 195 writeval = rtlphy->mcs_offset[chnlgroup][index] + 196 ((index < 2) ? pwrbase0 : pwrbase1); 197 198 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 199 "RTK better performance, writeval = 0x%x\n", writeval); 200 break; 201 case 1: 202 /* Realtek regulatory increase power diff defined 203 * by Realtek for regulatory */ 204 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) { 205 writeval = ((index < 2) ? pwrbase0 : pwrbase1); 206 207 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 208 "Realtek regulatory, 40MHz, writeval = 0x%x\n", 209 writeval); 210 } else { 211 chnlgroup = 0; 212 213 if (rtlphy->pwrgroup_cnt >= 3) { 214 if (chnl <= 3) 215 chnlgroup = 0; 216 else if (chnl >= 4 && chnl <= 8) 217 chnlgroup = 1; 218 else if (chnl > 8) 219 chnlgroup = 2; 220 if (rtlphy->pwrgroup_cnt == 4) 221 chnlgroup++; 222 } 223 224 writeval = rtlphy->mcs_offset[chnlgroup][index] 225 + ((index < 2) ? 226 pwrbase0 : pwrbase1); 227 228 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 229 "Realtek regulatory, 20MHz, writeval = 0x%x\n", 230 writeval); 231 } 232 break; 233 case 2: 234 /* Better regulatory don't increase any power diff */ 235 writeval = ((index < 2) ? pwrbase0 : pwrbase1); 236 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 237 "Better regulatory, writeval = 0x%x\n", writeval); 238 break; 239 case 3: 240 /* Customer defined power diff. increase power diff 241 defined by customer. */ 242 chnlgroup = 0; 243 244 if (rtlphy->current_chan_bw == HT_CHANNEL_WIDTH_20_40) { 245 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 246 "customer's limit, 40MHz = 0x%x\n", 247 rtlefuse->pwrgroup_ht40 248 [RF90_PATH_A][chnl - 1]); 249 } else { 250 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 251 "customer's limit, 20MHz = 0x%x\n", 252 rtlefuse->pwrgroup_ht20 253 [RF90_PATH_A][chnl - 1]); 254 } 255 256 for (i = 0; i < 4; i++) { 257 pwrdiff_limit[i] = (u8)((rtlphy->mcs_offset 258 [chnlgroup][index] & (0x7f << (i * 8))) 259 >> (i * 8)); 260 261 if (rtlphy->current_chan_bw == 262 HT_CHANNEL_WIDTH_20_40) { 263 if (pwrdiff_limit[i] > 264 rtlefuse->pwrgroup_ht40 265 [RF90_PATH_A][chnl - 1]) { 266 pwrdiff_limit[i] = 267 rtlefuse->pwrgroup_ht40 268 [RF90_PATH_A][chnl - 1]; 269 } 270 } else { 271 if (pwrdiff_limit[i] > 272 rtlefuse->pwrgroup_ht20 273 [RF90_PATH_A][chnl - 1]) { 274 pwrdiff_limit[i] = 275 rtlefuse->pwrgroup_ht20 276 [RF90_PATH_A][chnl - 1]; 277 } 278 } 279 } 280 281 customer_limit = (pwrdiff_limit[3] << 24) | 282 (pwrdiff_limit[2] << 16) | 283 (pwrdiff_limit[1] << 8) | 284 (pwrdiff_limit[0]); 285 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 286 "Customer's limit = 0x%x\n", customer_limit); 287 288 writeval = customer_limit + ((index < 2) ? 289 pwrbase0 : pwrbase1); 290 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 291 "Customer, writeval = 0x%x\n", writeval); 292 break; 293 default: 294 chnlgroup = 0; 295 writeval = rtlphy->mcs_offset[chnlgroup][index] + 296 ((index < 2) ? pwrbase0 : pwrbase1); 297 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD, 298 "RTK better performance, writeval = 0x%x\n", writeval); 299 break; 300 } 301 302 if (rtlpriv->dm.dynamic_txhighpower_lvl == TX_HIGH_PWR_LEVEL_LEVEL1) 303 writeval = 0x10101010; 304 else if (rtlpriv->dm.dynamic_txhighpower_lvl == 305 TX_HIGH_PWR_LEVEL_LEVEL2) 306 writeval = 0x0; 307 308 *p_outwrite_val = writeval; 309 310 } 311 312 static void _rtl92s_write_ofdm_powerreg(struct ieee80211_hw *hw, 313 u8 index, u32 val) 314 { 315 struct rtl_priv *rtlpriv = rtl_priv(hw); 316 struct rtl_phy *rtlphy = &(rtlpriv->phy); 317 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 318 u16 regoffset[6] = {0xe00, 0xe04, 0xe10, 0xe14, 0xe18, 0xe1c}; 319 u8 i, rfa_pwr[4]; 320 u8 rfa_lower_bound = 0, rfa_upper_bound = 0, rf_pwr_diff = 0; 321 u32 writeval = val; 322 323 /* If path A and Path B coexist, we must limit Path A tx power. 324 * Protect Path B pwr over or under flow. We need to calculate 325 * upper and lower bound of path A tx power. */ 326 if (rtlphy->rf_type == RF_2T2R) { 327 rf_pwr_diff = rtlefuse->antenna_txpwdiff[0]; 328 329 /* Diff=-8~-1 */ 330 if (rf_pwr_diff >= 8) { 331 /* Prevent underflow!! */ 332 rfa_lower_bound = 0x10 - rf_pwr_diff; 333 /* if (rf_pwr_diff >= 0) Diff = 0-7 */ 334 } else { 335 rfa_upper_bound = RF6052_MAX_TX_PWR - rf_pwr_diff; 336 } 337 } 338 339 for (i = 0; i < 4; i++) { 340 rfa_pwr[i] = (u8)((writeval & (0x7f << (i * 8))) >> (i * 8)); 341 if (rfa_pwr[i] > RF6052_MAX_TX_PWR) 342 rfa_pwr[i] = RF6052_MAX_TX_PWR; 343 344 /* If path A and Path B coexist, we must limit Path A tx power. 345 * Protect Path B pwr over or under flow. We need to calculate 346 * upper and lower bound of path A tx power. */ 347 if (rtlphy->rf_type == RF_2T2R) { 348 /* Diff=-8~-1 */ 349 if (rf_pwr_diff >= 8) { 350 /* Prevent underflow!! */ 351 if (rfa_pwr[i] < rfa_lower_bound) 352 rfa_pwr[i] = rfa_lower_bound; 353 /* Diff = 0-7 */ 354 } else if (rf_pwr_diff >= 1) { 355 /* Prevent overflow */ 356 if (rfa_pwr[i] > rfa_upper_bound) 357 rfa_pwr[i] = rfa_upper_bound; 358 } 359 } 360 361 } 362 363 writeval = (rfa_pwr[3] << 24) | (rfa_pwr[2] << 16) | (rfa_pwr[1] << 8) | 364 rfa_pwr[0]; 365 366 rtl_set_bbreg(hw, regoffset[index], 0x7f7f7f7f, writeval); 367 } 368 369 void rtl92s_phy_rf6052_set_ofdmtxpower(struct ieee80211_hw *hw, 370 u8 *p_pwrlevel, u8 chnl) 371 { 372 u32 writeval, pwrbase0, pwrbase1; 373 u8 index = 0; 374 u8 finalpwr_idx[4]; 375 376 _rtl92s_get_powerbase(hw, p_pwrlevel, chnl, &pwrbase0, &pwrbase1, 377 &finalpwr_idx[0]); 378 _rtl92s_set_antennadiff(hw, &finalpwr_idx[0]); 379 380 for (index = 0; index < 6; index++) { 381 _rtl92s_get_txpower_writeval_byregulatory(hw, chnl, index, 382 pwrbase0, pwrbase1, &writeval); 383 384 _rtl92s_write_ofdm_powerreg(hw, index, writeval); 385 } 386 } 387 388 void rtl92s_phy_rf6052_set_ccktxpower(struct ieee80211_hw *hw, u8 pwrlevel) 389 { 390 struct rtl_priv *rtlpriv = rtl_priv(hw); 391 struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); 392 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw)); 393 u32 txagc = 0; 394 bool dont_inc_cck_or_turboscanoff = false; 395 396 if (((rtlefuse->eeprom_version >= 2) && 397 (rtlefuse->txpwr_safetyflag == 1)) || 398 ((rtlefuse->eeprom_version >= 2) && 399 (rtlefuse->eeprom_regulatory != 0))) 400 dont_inc_cck_or_turboscanoff = true; 401 402 if (mac->act_scanning) { 403 txagc = 0x3f; 404 if (dont_inc_cck_or_turboscanoff) 405 txagc = pwrlevel; 406 } else { 407 txagc = pwrlevel; 408 409 if (rtlpriv->dm.dynamic_txhighpower_lvl == 410 TX_HIGH_PWR_LEVEL_LEVEL1) 411 txagc = 0x10; 412 else if (rtlpriv->dm.dynamic_txhighpower_lvl == 413 TX_HIGH_PWR_LEVEL_LEVEL2) 414 txagc = 0x0; 415 } 416 417 if (txagc > RF6052_MAX_TX_PWR) 418 txagc = RF6052_MAX_TX_PWR; 419 420 rtl_set_bbreg(hw, RTXAGC_CCK_MCS32, BTX_AGCRATECCK, txagc); 421 422 } 423 424 bool rtl92s_phy_rf6052_config(struct ieee80211_hw *hw) 425 { 426 struct rtl_priv *rtlpriv = rtl_priv(hw); 427 struct rtl_phy *rtlphy = &(rtlpriv->phy); 428 u32 u4reg_val = 0; 429 u8 rfpath; 430 bool rtstatus = true; 431 struct bb_reg_def *pphyreg; 432 433 /* Initialize RF */ 434 for (rfpath = 0; rfpath < rtlphy->num_total_rfpath; rfpath++) { 435 436 pphyreg = &rtlphy->phyreg_def[rfpath]; 437 438 /* Store original RFENV control type */ 439 switch (rfpath) { 440 case RF90_PATH_A: 441 case RF90_PATH_C: 442 u4reg_val = rtl92s_phy_query_bb_reg(hw, 443 pphyreg->rfintfs, 444 BRFSI_RFENV); 445 break; 446 case RF90_PATH_B: 447 case RF90_PATH_D: 448 u4reg_val = rtl92s_phy_query_bb_reg(hw, 449 pphyreg->rfintfs, 450 BRFSI_RFENV << 16); 451 break; 452 } 453 454 /* Set RF_ENV enable */ 455 rtl92s_phy_set_bb_reg(hw, pphyreg->rfintfe, 456 BRFSI_RFENV << 16, 0x1); 457 458 /* Set RF_ENV output high */ 459 rtl92s_phy_set_bb_reg(hw, pphyreg->rfintfo, BRFSI_RFENV, 0x1); 460 461 /* Set bit number of Address and Data for RF register */ 462 rtl92s_phy_set_bb_reg(hw, pphyreg->rfhssi_para2, 463 B3WIRE_ADDRESSLENGTH, 0x0); 464 rtl92s_phy_set_bb_reg(hw, pphyreg->rfhssi_para2, 465 B3WIRE_DATALENGTH, 0x0); 466 467 /* Initialize RF fom connfiguration file */ 468 switch (rfpath) { 469 case RF90_PATH_A: 470 rtstatus = rtl92s_phy_config_rf(hw, 471 (enum radio_path)rfpath); 472 break; 473 case RF90_PATH_B: 474 rtstatus = rtl92s_phy_config_rf(hw, 475 (enum radio_path)rfpath); 476 break; 477 case RF90_PATH_C: 478 break; 479 case RF90_PATH_D: 480 break; 481 } 482 483 /* Restore RFENV control type */ 484 switch (rfpath) { 485 case RF90_PATH_A: 486 case RF90_PATH_C: 487 rtl92s_phy_set_bb_reg(hw, pphyreg->rfintfs, BRFSI_RFENV, 488 u4reg_val); 489 break; 490 case RF90_PATH_B: 491 case RF90_PATH_D: 492 rtl92s_phy_set_bb_reg(hw, pphyreg->rfintfs, 493 BRFSI_RFENV << 16, 494 u4reg_val); 495 break; 496 } 497 498 if (!rtstatus) { 499 pr_err("Radio[%d] Fail!!\n", rfpath); 500 goto fail; 501 } 502 503 } 504 505 return rtstatus; 506 507 fail: 508 return rtstatus; 509 } 510 511 void rtl92s_phy_rf6052_set_bandwidth(struct ieee80211_hw *hw, u8 bandwidth) 512 { 513 struct rtl_priv *rtlpriv = rtl_priv(hw); 514 struct rtl_phy *rtlphy = &(rtlpriv->phy); 515 516 switch (bandwidth) { 517 case HT_CHANNEL_WIDTH_20: 518 rtlphy->rfreg_chnlval[0] = ((rtlphy->rfreg_chnlval[0] & 519 0xfffff3ff) | 0x0400); 520 rtl_set_rfreg(hw, RF90_PATH_A, RF_CHNLBW, RFREG_OFFSET_MASK, 521 rtlphy->rfreg_chnlval[0]); 522 break; 523 case HT_CHANNEL_WIDTH_20_40: 524 rtlphy->rfreg_chnlval[0] = ((rtlphy->rfreg_chnlval[0] & 525 0xfffff3ff)); 526 rtl_set_rfreg(hw, RF90_PATH_A, RF_CHNLBW, RFREG_OFFSET_MASK, 527 rtlphy->rfreg_chnlval[0]); 528 break; 529 default: 530 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, 531 "unknown bandwidth: %#X\n", bandwidth); 532 break; 533 } 534 } 535