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 ******************************************************************************/
15 #define _HCI_HAL_INIT_C_
16
17 #include <osdep_service.h>
18 #include <drv_types.h>
19 #include <rtw_efuse.h>
20
21 #include <HalPwrSeqCmd.h>
22 #include <Hal8723PwrSeq.h>
23 #include <rtl8723a_hal.h>
24 #include <linux/ieee80211.h>
25
26 #include <usb_ops.h>
27
28 static void phy_SsPwrSwitch92CU(struct rtw_adapter *Adapter,
29 enum rt_rf_power_state eRFPowerState);
30
31 static void
_ConfigChipOutEP(struct rtw_adapter * pAdapter,u8 NumOutPipe)32 _ConfigChipOutEP(struct rtw_adapter *pAdapter, u8 NumOutPipe)
33 {
34 u8 value8;
35 struct hal_data_8723a *pHalData = GET_HAL_DATA(pAdapter);
36
37 pHalData->OutEpQueueSel = 0;
38 pHalData->OutEpNumber = 0;
39
40 /* Normal and High queue */
41 value8 = rtl8723au_read8(pAdapter, (REG_NORMAL_SIE_EP + 1));
42
43 if (value8 & USB_NORMAL_SIE_EP_MASK) {
44 pHalData->OutEpQueueSel |= TX_SELE_HQ;
45 pHalData->OutEpNumber++;
46 }
47
48 if ((value8 >> USB_NORMAL_SIE_EP_SHIFT) & USB_NORMAL_SIE_EP_MASK) {
49 pHalData->OutEpQueueSel |= TX_SELE_NQ;
50 pHalData->OutEpNumber++;
51 }
52
53 /* Low queue */
54 value8 = rtl8723au_read8(pAdapter, (REG_NORMAL_SIE_EP + 2));
55 if (value8 & USB_NORMAL_SIE_EP_MASK) {
56 pHalData->OutEpQueueSel |= TX_SELE_LQ;
57 pHalData->OutEpNumber++;
58 }
59
60 /* TODO: Error recovery for this case */
61 /* RT_ASSERT((NumOutPipe == pHalData->OutEpNumber),
62 ("Out EP number isn't match! %d(Descriptor) != %d (SIE reg)\n",
63 (u32)NumOutPipe, (u32)pHalData->OutEpNumber)); */
64 }
65
rtl8723au_chip_configure(struct rtw_adapter * padapter)66 bool rtl8723au_chip_configure(struct rtw_adapter *padapter)
67 {
68 struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
69 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
70 u8 NumInPipe = pdvobjpriv->RtNumInPipes;
71 u8 NumOutPipe = pdvobjpriv->RtNumOutPipes;
72
73 _ConfigChipOutEP(padapter, NumOutPipe);
74
75 /* Normal chip with one IN and one OUT doesn't have interrupt IN EP. */
76 if (pHalData->OutEpNumber == 1) {
77 if (NumInPipe != 1)
78 return false;
79 }
80
81 return Hal_MappingOutPipe23a(padapter, NumOutPipe);
82 }
83
_InitPowerOn(struct rtw_adapter * padapter)84 static int _InitPowerOn(struct rtw_adapter *padapter)
85 {
86 u16 value16;
87 u8 value8;
88
89 /* RSV_CTRL 0x1C[7:0] = 0x00
90 unlock ISO/CLK/Power control register */
91 rtl8723au_write8(padapter, REG_RSV_CTRL, 0x0);
92
93 /* HW Power on sequence */
94 if (!HalPwrSeqCmdParsing23a(padapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
95 PWR_INTF_USB_MSK, rtl8723AU_card_enable_flow))
96 return _FAIL;
97
98 /* 0x04[19] = 1, suggest by Jackie 2011.05.09, reset 8051 */
99 value8 = rtl8723au_read8(padapter, REG_APS_FSMCO+2);
100 rtl8723au_write8(padapter, REG_APS_FSMCO + 2, value8 | BIT(3));
101
102 /* Enable MAC DMA/WMAC/SCHEDULE/SEC block */
103 /* Set CR bit10 to enable 32k calibration. Suggested by SD1 Gimmy.
104 Added by tynli. 2011.08.31. */
105 value16 = rtl8723au_read16(padapter, REG_CR);
106 value16 |= (HCI_TXDMA_EN | HCI_RXDMA_EN | TXDMA_EN | RXDMA_EN |
107 PROTOCOL_EN | SCHEDULE_EN | MACTXEN | MACRXEN |
108 ENSEC | CALTMR_EN);
109 rtl8723au_write16(padapter, REG_CR, value16);
110
111 /* for Efuse PG, suggest by Jackie 2011.11.23 */
112 PHY_SetBBReg(padapter, REG_EFUSE_CTRL, BIT(28)|BIT(29)|BIT(30), 0x06);
113
114 return _SUCCESS;
115 }
116
117 /* Shall USB interface init this? */
_InitInterrupt(struct rtw_adapter * Adapter)118 static void _InitInterrupt(struct rtw_adapter *Adapter)
119 {
120 u32 value32;
121
122 /* HISR - turn all on */
123 value32 = 0xFFFFFFFF;
124 rtl8723au_write32(Adapter, REG_HISR, value32);
125
126 /* HIMR - turn all on */
127 rtl8723au_write32(Adapter, REG_HIMR, value32);
128 }
129
_InitQueueReservedPage(struct rtw_adapter * Adapter)130 static void _InitQueueReservedPage(struct rtw_adapter *Adapter)
131 {
132 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
133 struct registry_priv *pregistrypriv = &Adapter->registrypriv;
134 u32 numHQ = 0;
135 u32 numLQ = 0;
136 u32 numNQ = 0;
137 u32 numPubQ;
138 u32 value32;
139 u8 value8;
140 bool bWiFiConfig = pregistrypriv->wifi_spec;
141
142 /* RT_ASSERT((outEPNum>= 2), ("for WMM , number of out-ep "
143 "must more than or equal to 2!\n")); */
144
145 numPubQ = bWiFiConfig ? WMM_NORMAL_PAGE_NUM_PUBQ : NORMAL_PAGE_NUM_PUBQ;
146
147 if (pHalData->OutEpQueueSel & TX_SELE_HQ) {
148 numHQ = bWiFiConfig ?
149 WMM_NORMAL_PAGE_NUM_HPQ : NORMAL_PAGE_NUM_HPQ;
150 }
151
152 if (pHalData->OutEpQueueSel & TX_SELE_LQ) {
153 numLQ = bWiFiConfig ?
154 WMM_NORMAL_PAGE_NUM_LPQ : NORMAL_PAGE_NUM_LPQ;
155 }
156 /* NOTE: This step shall be proceed before
157 writting REG_RQPN. */
158 if (pHalData->OutEpQueueSel & TX_SELE_NQ) {
159 numNQ = bWiFiConfig ?
160 WMM_NORMAL_PAGE_NUM_NPQ : NORMAL_PAGE_NUM_NPQ;
161 }
162 value8 = (u8)_NPQ(numNQ);
163 rtl8723au_write8(Adapter, REG_RQPN_NPQ, value8);
164
165 /* TX DMA */
166 value32 = _HPQ(numHQ) | _LPQ(numLQ) | _PUBQ(numPubQ) | LD_RQPN;
167 rtl8723au_write32(Adapter, REG_RQPN, value32);
168 }
169
_InitTxBufferBoundary(struct rtw_adapter * Adapter)170 static void _InitTxBufferBoundary(struct rtw_adapter *Adapter)
171 {
172 struct registry_priv *pregistrypriv = &Adapter->registrypriv;
173
174 u8 txpktbuf_bndy;
175
176 if (!pregistrypriv->wifi_spec)
177 txpktbuf_bndy = TX_PAGE_BOUNDARY;
178 else /* for WMM */
179 txpktbuf_bndy = WMM_NORMAL_TX_PAGE_BOUNDARY;
180
181 rtl8723au_write8(Adapter, REG_TXPKTBUF_BCNQ_BDNY, txpktbuf_bndy);
182 rtl8723au_write8(Adapter, REG_TXPKTBUF_MGQ_BDNY, txpktbuf_bndy);
183 rtl8723au_write8(Adapter, REG_TXPKTBUF_WMAC_LBK_BF_HD, txpktbuf_bndy);
184 rtl8723au_write8(Adapter, REG_TRXFF_BNDY, txpktbuf_bndy);
185 rtl8723au_write8(Adapter, REG_TDECTRL+1, txpktbuf_bndy);
186 }
187
_InitPageBoundary(struct rtw_adapter * Adapter)188 static void _InitPageBoundary(struct rtw_adapter *Adapter)
189 {
190 /* RX Page Boundary */
191 /* srand(static_cast<unsigned int>(time(NULL))); */
192 u16 rxff_bndy = 0x27FF;/* rand() % 1) ? 0x27FF : 0x23FF; */
193
194 rtl8723au_write16(Adapter, (REG_TRXFF_BNDY + 2), rxff_bndy);
195
196 /* TODO: ?? shall we set tx boundary? */
197 }
198
199 static void
_InitNormalChipRegPriority(struct rtw_adapter * Adapter,u16 beQ,u16 bkQ,u16 viQ,u16 voQ,u16 mgtQ,u16 hiQ)200 _InitNormalChipRegPriority(struct rtw_adapter *Adapter, u16 beQ, u16 bkQ,
201 u16 viQ, u16 voQ, u16 mgtQ, u16 hiQ)
202 {
203 u16 value16 = rtl8723au_read16(Adapter, REG_TRXDMA_CTRL) & 0x7;
204
205 value16 |= _TXDMA_BEQ_MAP(beQ) | _TXDMA_BKQ_MAP(bkQ) |
206 _TXDMA_VIQ_MAP(viQ) | _TXDMA_VOQ_MAP(voQ) |
207 _TXDMA_MGQ_MAP(mgtQ) | _TXDMA_HIQ_MAP(hiQ);
208
209 rtl8723au_write16(Adapter, REG_TRXDMA_CTRL, value16);
210 }
211
_InitNormalChipOneOutEpPriority(struct rtw_adapter * Adapter)212 static void _InitNormalChipOneOutEpPriority(struct rtw_adapter *Adapter)
213 {
214 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
215 u16 value = 0;
216
217 switch (pHalData->OutEpQueueSel) {
218 case TX_SELE_HQ:
219 value = QUEUE_HIGH;
220 break;
221 case TX_SELE_LQ:
222 value = QUEUE_LOW;
223 break;
224 case TX_SELE_NQ:
225 value = QUEUE_NORMAL;
226 break;
227 default:
228 /* RT_ASSERT(false, ("Shall not reach here!\n")); */
229 break;
230 }
231
232 _InitNormalChipRegPriority(Adapter, value, value, value,
233 value, value, value);
234 }
235
_InitNormalChipTwoOutEpPriority(struct rtw_adapter * Adapter)236 static void _InitNormalChipTwoOutEpPriority(struct rtw_adapter *Adapter)
237 {
238 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
239 struct registry_priv *pregistrypriv = &Adapter->registrypriv;
240 u16 beQ, bkQ, viQ, voQ, mgtQ, hiQ;
241 u16 valueHi = 0;
242 u16 valueLow = 0;
243
244 switch (pHalData->OutEpQueueSel) {
245 case (TX_SELE_HQ | TX_SELE_LQ):
246 valueHi = QUEUE_HIGH;
247 valueLow = QUEUE_LOW;
248 break;
249 case (TX_SELE_NQ | TX_SELE_LQ):
250 valueHi = QUEUE_NORMAL;
251 valueLow = QUEUE_LOW;
252 break;
253 case (TX_SELE_HQ | TX_SELE_NQ):
254 valueHi = QUEUE_HIGH;
255 valueLow = QUEUE_NORMAL;
256 break;
257 default:
258 /* RT_ASSERT(false, ("Shall not reach here!\n")); */
259 break;
260 }
261
262 if (!pregistrypriv->wifi_spec) {
263 beQ = valueLow;
264 bkQ = valueLow;
265 viQ = valueHi;
266 voQ = valueHi;
267 mgtQ = valueHi;
268 hiQ = valueHi;
269 } else {/* for WMM , CONFIG_OUT_EP_WIFI_MODE */
270 beQ = valueLow;
271 bkQ = valueHi;
272 viQ = valueHi;
273 voQ = valueLow;
274 mgtQ = valueHi;
275 hiQ = valueHi;
276 }
277
278 _InitNormalChipRegPriority(Adapter, beQ, bkQ, viQ, voQ, mgtQ, hiQ);
279 }
280
_InitNormalChipThreeOutEpPriority(struct rtw_adapter * Adapter)281 static void _InitNormalChipThreeOutEpPriority(struct rtw_adapter *Adapter)
282 {
283 struct registry_priv *pregistrypriv = &Adapter->registrypriv;
284 u16 beQ, bkQ, viQ, voQ, mgtQ, hiQ;
285
286 if (!pregistrypriv->wifi_spec) {/* typical setting */
287 beQ = QUEUE_LOW;
288 bkQ = QUEUE_LOW;
289 viQ = QUEUE_NORMAL;
290 voQ = QUEUE_HIGH;
291 mgtQ = QUEUE_HIGH;
292 hiQ = QUEUE_HIGH;
293 } else {/* for WMM */
294 beQ = QUEUE_LOW;
295 bkQ = QUEUE_NORMAL;
296 viQ = QUEUE_NORMAL;
297 voQ = QUEUE_HIGH;
298 mgtQ = QUEUE_HIGH;
299 hiQ = QUEUE_HIGH;
300 }
301 _InitNormalChipRegPriority(Adapter, beQ, bkQ, viQ, voQ, mgtQ, hiQ);
302 }
303
_InitQueuePriority(struct rtw_adapter * Adapter)304 static void _InitQueuePriority(struct rtw_adapter *Adapter)
305 {
306 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
307
308 switch (pHalData->OutEpNumber) {
309 case 1:
310 _InitNormalChipOneOutEpPriority(Adapter);
311 break;
312 case 2:
313 _InitNormalChipTwoOutEpPriority(Adapter);
314 break;
315 case 3:
316 _InitNormalChipThreeOutEpPriority(Adapter);
317 break;
318 default:
319 /* RT_ASSERT(false, ("Shall not reach here!\n")); */
320 break;
321 }
322 }
323
_InitTransferPageSize(struct rtw_adapter * Adapter)324 static void _InitTransferPageSize(struct rtw_adapter *Adapter)
325 {
326 /* Tx page size is always 128. */
327
328 u8 value8;
329 value8 = _PSRX(PBP_128) | _PSTX(PBP_128);
330 rtl8723au_write8(Adapter, REG_PBP, value8);
331 }
332
_InitDriverInfoSize(struct rtw_adapter * Adapter,u8 drvInfoSize)333 static void _InitDriverInfoSize(struct rtw_adapter *Adapter, u8 drvInfoSize)
334 {
335 rtl8723au_write8(Adapter, REG_RX_DRVINFO_SZ, drvInfoSize);
336 }
337
_InitWMACSetting(struct rtw_adapter * Adapter)338 static void _InitWMACSetting(struct rtw_adapter *Adapter)
339 {
340 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
341
342 /* don't turn on AAP, it will allow all packets to driver */
343 pHalData->ReceiveConfig = RCR_APM | RCR_AM | RCR_AB | RCR_CBSSID_DATA |
344 RCR_CBSSID_BCN | RCR_APP_ICV | RCR_AMF |
345 RCR_HTC_LOC_CTRL | RCR_APP_MIC |
346 RCR_APP_PHYSTS;
347
348 /* some REG_RCR will be modified later by
349 phy_ConfigMACWithHeaderFile() */
350 rtl8723au_write32(Adapter, REG_RCR, pHalData->ReceiveConfig);
351
352 /* Accept all multicast address */
353 rtl8723au_write32(Adapter, REG_MAR, 0xFFFFFFFF);
354 rtl8723au_write32(Adapter, REG_MAR + 4, 0xFFFFFFFF);
355
356 /* Accept all data frames */
357 /* value16 = 0xFFFF; */
358 /* rtl8723au_write16(Adapter, REG_RXFLTMAP2, value16); */
359
360 /* 2010.09.08 hpfan */
361 /* Since ADF is removed from RCR, ps-poll will not be indicate
362 to driver, */
363 /* RxFilterMap should mask ps-poll to gurantee AP mode can
364 rx ps-poll. */
365 /* value16 = 0x400; */
366 /* rtl8723au_write16(Adapter, REG_RXFLTMAP1, value16); */
367
368 /* Accept all management frames */
369 /* value16 = 0xFFFF; */
370 /* rtl8723au_write16(Adapter, REG_RXFLTMAP0, value16); */
371
372 /* enable RX_SHIFT bits */
373 /* rtl8723au_write8(Adapter, REG_TRXDMA_CTRL, rtl8723au_read8(Adapter,
374 REG_TRXDMA_CTRL)|BIT(1)); */
375 }
376
_InitAdaptiveCtrl(struct rtw_adapter * Adapter)377 static void _InitAdaptiveCtrl(struct rtw_adapter *Adapter)
378 {
379 u16 value16;
380 u32 value32;
381
382 /* Response Rate Set */
383 value32 = rtl8723au_read32(Adapter, REG_RRSR);
384 value32 &= ~RATE_BITMAP_ALL;
385 value32 |= RATE_RRSR_CCK_ONLY_1M;
386 rtl8723au_write32(Adapter, REG_RRSR, value32);
387
388 /* CF-END Threshold */
389 /* m_spIoBase->rtl8723au_write8(REG_CFEND_TH, 0x1); */
390
391 /* SIFS (used in NAV) */
392 value16 = _SPEC_SIFS_CCK(0x10) | _SPEC_SIFS_OFDM(0x10);
393 rtl8723au_write16(Adapter, REG_SPEC_SIFS, value16);
394
395 /* Retry Limit */
396 value16 = _LRL(0x30) | _SRL(0x30);
397 rtl8723au_write16(Adapter, REG_RL, value16);
398 }
399
_InitRateFallback(struct rtw_adapter * Adapter)400 static void _InitRateFallback(struct rtw_adapter *Adapter)
401 {
402 /* Set Data Auto Rate Fallback Retry Count register. */
403 rtl8723au_write32(Adapter, REG_DARFRC, 0x00000000);
404 rtl8723au_write32(Adapter, REG_DARFRC+4, 0x10080404);
405 rtl8723au_write32(Adapter, REG_RARFRC, 0x04030201);
406 rtl8723au_write32(Adapter, REG_RARFRC+4, 0x08070605);
407 }
408
_InitEDCA(struct rtw_adapter * Adapter)409 static void _InitEDCA(struct rtw_adapter *Adapter)
410 {
411 /* Set Spec SIFS (used in NAV) */
412 rtl8723au_write16(Adapter, REG_SPEC_SIFS, 0x100a);
413 rtl8723au_write16(Adapter, REG_MAC_SPEC_SIFS, 0x100a);
414
415 /* Set SIFS for CCK */
416 rtl8723au_write16(Adapter, REG_SIFS_CTX, 0x100a);
417
418 /* Set SIFS for OFDM */
419 rtl8723au_write16(Adapter, REG_SIFS_TRX, 0x100a);
420
421 /* TXOP */
422 rtl8723au_write32(Adapter, REG_EDCA_BE_PARAM, 0x005EA42B);
423 rtl8723au_write32(Adapter, REG_EDCA_BK_PARAM, 0x0000A44F);
424 rtl8723au_write32(Adapter, REG_EDCA_VI_PARAM, 0x005EA324);
425 rtl8723au_write32(Adapter, REG_EDCA_VO_PARAM, 0x002FA226);
426 }
427
_InitRDGSetting(struct rtw_adapter * Adapter)428 static void _InitRDGSetting(struct rtw_adapter *Adapter)
429 {
430 rtl8723au_write8(Adapter, REG_RD_CTRL, 0xFF);
431 rtl8723au_write16(Adapter, REG_RD_NAV_NXT, 0x200);
432 rtl8723au_write8(Adapter, REG_RD_RESP_PKT_TH, 0x05);
433 }
434
_InitRetryFunction(struct rtw_adapter * Adapter)435 static void _InitRetryFunction(struct rtw_adapter *Adapter)
436 {
437 u8 value8;
438
439 value8 = rtl8723au_read8(Adapter, REG_FWHW_TXQ_CTRL);
440 value8 |= EN_AMPDU_RTY_NEW;
441 rtl8723au_write8(Adapter, REG_FWHW_TXQ_CTRL, value8);
442
443 /* Set ACK timeout */
444 rtl8723au_write8(Adapter, REG_ACKTO, 0x40);
445 }
446
_InitRFType(struct rtw_adapter * Adapter)447 static void _InitRFType(struct rtw_adapter *Adapter)
448 {
449 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
450
451 pHalData->rf_type = RF_1T1R;
452 }
453
454 /* Set CCK and OFDM Block "ON" */
_BBTurnOnBlock(struct rtw_adapter * Adapter)455 static void _BBTurnOnBlock(struct rtw_adapter *Adapter)
456 {
457 PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bCCKEn, 0x1);
458 PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bOFDMEn, 0x1);
459 }
460
461 #define MgntActSet_RF_State(...)
_RfPowerSave(struct rtw_adapter * padapter)462 static void _RfPowerSave(struct rtw_adapter *padapter)
463 {
464 }
465
466 enum {
467 Antenna_Lfet = 1,
468 Antenna_Right = 2,
469 };
470
RfOnOffDetect23a(struct rtw_adapter * pAdapter)471 enum rt_rf_power_state RfOnOffDetect23a(struct rtw_adapter *pAdapter)
472 {
473 /* struct hal_data_8723a *pHalData = GET_HAL_DATA(pAdapter); */
474 u8 val8;
475 enum rt_rf_power_state rfpowerstate = rf_off;
476
477 rtl8723au_write8(pAdapter, REG_MAC_PINMUX_CFG,
478 rtl8723au_read8(pAdapter,
479 REG_MAC_PINMUX_CFG) & ~BIT(3));
480 val8 = rtl8723au_read8(pAdapter, REG_GPIO_IO_SEL);
481 DBG_8723A("GPIO_IN =%02x\n", val8);
482 rfpowerstate = (val8 & BIT(3)) ? rf_on : rf_off;
483
484 return rfpowerstate;
485 }
486
rtl8723au_hal_init(struct rtw_adapter * Adapter)487 int rtl8723au_hal_init(struct rtw_adapter *Adapter)
488 {
489 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
490 struct pwrctrl_priv *pwrctrlpriv = &Adapter->pwrctrlpriv;
491 struct registry_priv *pregistrypriv = &Adapter->registrypriv;
492 u8 val8 = 0;
493 u32 boundary;
494 int status = _SUCCESS;
495 bool mac_on;
496
497 unsigned long init_start_time = jiffies;
498
499 Adapter->hw_init_completed = false;
500
501 if (Adapter->pwrctrlpriv.bkeepfwalive) {
502 phy_SsPwrSwitch92CU(Adapter, rf_on);
503
504 if (pHalData->bIQKInitialized) {
505 rtl8723a_phy_iq_calibrate(Adapter, true);
506 } else {
507 rtl8723a_phy_iq_calibrate(Adapter, false);
508 pHalData->bIQKInitialized = true;
509 }
510 rtl8723a_odm_check_tx_power_tracking(Adapter);
511 rtl8723a_phy_lc_calibrate(Adapter);
512
513 goto exit;
514 }
515
516 /* Check if MAC has already power on. by tynli. 2011.05.27. */
517 val8 = rtl8723au_read8(Adapter, REG_CR);
518 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
519 "%s: REG_CR 0x100 = 0x%02x\n", __func__, val8);
520 /* Fix 92DU-VC S3 hang with the reason is that secondary mac is not
521 initialized. */
522 /* 0x100 value of first mac is 0xEA while 0x100 value of secondary
523 is 0x00 */
524 if (val8 == 0xEA) {
525 mac_on = false;
526 } else {
527 mac_on = true;
528 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
529 "%s: MAC has already power on\n", __func__);
530 }
531
532 status = _InitPowerOn(Adapter);
533 if (status == _FAIL) {
534 RT_TRACE(_module_hci_hal_init_c_, _drv_err_,
535 "Failed to init power on!\n");
536 goto exit;
537 }
538
539 if (!pregistrypriv->wifi_spec) {
540 boundary = TX_PAGE_BOUNDARY;
541 } else {
542 /* for WMM */
543 boundary = WMM_NORMAL_TX_PAGE_BOUNDARY;
544 }
545
546 if (!mac_on) {
547 status = InitLLTTable23a(Adapter, boundary);
548 if (status == _FAIL) {
549 RT_TRACE(_module_hci_hal_init_c_, _drv_err_,
550 "Failed to init LLT table\n");
551 goto exit;
552 }
553 }
554
555 if (pHalData->bRDGEnable)
556 _InitRDGSetting(Adapter);
557
558 status = rtl8723a_FirmwareDownload(Adapter);
559 if (status != _SUCCESS) {
560 Adapter->bFWReady = false;
561 DBG_8723A("fw download fail!\n");
562 goto exit;
563 } else {
564 Adapter->bFWReady = true;
565 DBG_8723A("fw download ok!\n");
566 }
567
568 rtl8723a_InitializeFirmwareVars(Adapter);
569
570 if (pwrctrlpriv->reg_rfoff == true) {
571 pwrctrlpriv->rf_pwrstate = rf_off;
572 }
573
574 /* 2010/08/09 MH We need to check if we need to turnon or off RF after detecting */
575 /* HW GPIO pin. Before PHY_RFConfig8192C. */
576 /* HalDetectPwrDownMode(Adapter); */
577 /* 2010/08/26 MH If Efuse does not support sective suspend then disable the function. */
578 /* HalDetectSelectiveSuspendMode(Adapter); */
579
580 /* Set RF type for BB/RF configuration */
581 _InitRFType(Adapter);/* _ReadRFType() */
582
583 /* Save target channel */
584 /* <Roger_Notes> Current Channel will be updated again later. */
585 pHalData->CurrentChannel = 6;/* default set to 6 */
586
587 status = PHY_MACConfig8723A(Adapter);
588 if (status == _FAIL) {
589 DBG_8723A("PHY_MACConfig8723A fault !!\n");
590 goto exit;
591 }
592
593 /* */
594 /* d. Initialize BB related configurations. */
595 /* */
596 status = PHY_BBConfig8723A(Adapter);
597 if (status == _FAIL) {
598 DBG_8723A("PHY_BBConfig8723A fault !!\n");
599 goto exit;
600 }
601
602 /* Add for tx power by rate fine tune. We need to call the function after BB config. */
603 /* Because the tx power by rate table is inited in BB config. */
604
605 status = PHY_RF6052_Config8723A(Adapter);
606 if (status == _FAIL) {
607 DBG_8723A("PHY_RF6052_Config8723A failed!!\n");
608 goto exit;
609 }
610
611 /* reducing 80M spur */
612 rtl8723au_write32(Adapter, REG_AFE_XTAL_CTRL, 0x0381808d);
613 rtl8723au_write32(Adapter, REG_AFE_PLL_CTRL, 0xf0ffff83);
614 rtl8723au_write32(Adapter, REG_AFE_PLL_CTRL, 0xf0ffff82);
615 rtl8723au_write32(Adapter, REG_AFE_PLL_CTRL, 0xf0ffff83);
616
617 /* RFSW Control */
618 /* 0x804[14]= 0 */
619 rtl8723au_write32(Adapter, rFPGA0_TxInfo, 0x00000003);
620 /* 0x870[6:5]= b'11 */
621 rtl8723au_write32(Adapter, rFPGA0_XAB_RFInterfaceSW, 0x07000760);
622 /* 0x860[6:5]= b'00 */
623 rtl8723au_write32(Adapter, rFPGA0_XA_RFInterfaceOE, 0x66F60210);
624
625 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
626 "%s: 0x870 = value 0x%x\n", __func__,
627 rtl8723au_read32(Adapter, 0x870));
628
629 /* */
630 /* Joseph Note: Keep RfRegChnlVal for later use. */
631 /* */
632 pHalData->RfRegChnlVal[0] = PHY_QueryRFReg(Adapter, RF_PATH_A,
633 RF_CHNLBW, bRFRegOffsetMask);
634 pHalData->RfRegChnlVal[1] = PHY_QueryRFReg(Adapter, RF_PATH_B,
635 RF_CHNLBW, bRFRegOffsetMask);
636
637 if (!mac_on) {
638 _InitQueueReservedPage(Adapter);
639 _InitTxBufferBoundary(Adapter);
640 }
641 _InitQueuePriority(Adapter);
642 _InitPageBoundary(Adapter);
643 _InitTransferPageSize(Adapter);
644
645 /* Get Rx PHY status in order to report RSSI and others. */
646 _InitDriverInfoSize(Adapter, DRVINFO_SZ);
647
648 _InitInterrupt(Adapter);
649 hw_var_set_macaddr(Adapter, Adapter->eeprompriv.mac_addr);
650 rtl8723a_set_media_status(Adapter, MSR_INFRA);
651 _InitWMACSetting(Adapter);
652 _InitAdaptiveCtrl(Adapter);
653 _InitEDCA(Adapter);
654 _InitRateFallback(Adapter);
655 _InitRetryFunction(Adapter);
656 rtl8723a_InitBeaconParameters(Adapter);
657
658 _BBTurnOnBlock(Adapter);
659 /* NicIFSetMacAddress(padapter, padapter->PermanentAddress); */
660
661 rtl8723a_cam_invalidate_all(Adapter);
662
663 /* 2010/12/17 MH We need to set TX power according to EFUSE content at first. */
664 PHY_SetTxPowerLevel8723A(Adapter, pHalData->CurrentChannel);
665
666 rtl8723a_InitAntenna_Selection(Adapter);
667
668 /* HW SEQ CTRL */
669 /* set 0x0 to 0xFF by tynli. Default enable HW SEQ NUM. */
670 rtl8723au_write8(Adapter, REG_HWSEQ_CTRL, 0xFF);
671
672 /* */
673 /* Disable BAR, suggested by Scott */
674 /* 2010.04.09 add by hpfan */
675 /* */
676 rtl8723au_write32(Adapter, REG_BAR_MODE_CTRL, 0x0201ffff);
677
678 if (pregistrypriv->wifi_spec)
679 rtl8723au_write16(Adapter, REG_FAST_EDCA_CTRL, 0);
680
681 /* Move by Neo for USB SS from above setp */
682 _RfPowerSave(Adapter);
683
684 /* 2010/08/26 MH Merge from 8192CE. */
685 /* sherry masked that it has been done in _RfPowerSave */
686 /* 20110927 */
687 /* recovery for 8192cu and 9723Au 20111017 */
688 if (pwrctrlpriv->rf_pwrstate == rf_on) {
689 if (pHalData->bIQKInitialized) {
690 rtl8723a_phy_iq_calibrate(Adapter, true);
691 } else {
692 rtl8723a_phy_iq_calibrate(Adapter, false);
693 pHalData->bIQKInitialized = true;
694 }
695
696 rtl8723a_odm_check_tx_power_tracking(Adapter);
697
698 rtl8723a_phy_lc_calibrate(Adapter);
699
700 rtl8723a_dual_antenna_detection(Adapter);
701 }
702
703 /* fixed USB interface interference issue */
704 rtl8723au_write8(Adapter, 0xfe40, 0xe0);
705 rtl8723au_write8(Adapter, 0xfe41, 0x8d);
706 rtl8723au_write8(Adapter, 0xfe42, 0x80);
707 rtl8723au_write32(Adapter, 0x20c, 0xfd0320);
708 /* Solve too many protocol error on USB bus */
709 if (!IS_81xxC_VENDOR_UMC_A_CUT(pHalData->VersionID)) {
710 /* 0xE6 = 0x94 */
711 rtl8723au_write8(Adapter, 0xFE40, 0xE6);
712 rtl8723au_write8(Adapter, 0xFE41, 0x94);
713 rtl8723au_write8(Adapter, 0xFE42, 0x80);
714
715 /* 0xE0 = 0x19 */
716 rtl8723au_write8(Adapter, 0xFE40, 0xE0);
717 rtl8723au_write8(Adapter, 0xFE41, 0x19);
718 rtl8723au_write8(Adapter, 0xFE42, 0x80);
719
720 /* 0xE5 = 0x91 */
721 rtl8723au_write8(Adapter, 0xFE40, 0xE5);
722 rtl8723au_write8(Adapter, 0xFE41, 0x91);
723 rtl8723au_write8(Adapter, 0xFE42, 0x80);
724
725 /* 0xE2 = 0x81 */
726 rtl8723au_write8(Adapter, 0xFE40, 0xE2);
727 rtl8723au_write8(Adapter, 0xFE41, 0x81);
728 rtl8723au_write8(Adapter, 0xFE42, 0x80);
729
730 }
731
732 /* _InitPABias(Adapter); */
733
734 /* Init BT hw config. */
735 rtl8723a_BT_init_hwconfig(Adapter);
736
737 rtl8723a_InitHalDm(Adapter);
738
739 val8 = (WiFiNavUpperUs + HAL_8723A_NAV_UPPER_UNIT - 1) /
740 HAL_8723A_NAV_UPPER_UNIT;
741 rtl8723au_write8(Adapter, REG_NAV_UPPER, val8);
742
743 /* 2011/03/09 MH debug only, UMC-B cut pass 2500 S5 test, but we need to fin root cause. */
744 if (((rtl8723au_read32(Adapter, rFPGA0_RFMOD) & 0xFF000000) !=
745 0x83000000)) {
746 PHY_SetBBReg(Adapter, rFPGA0_RFMOD, BIT(24), 1);
747 RT_TRACE(_module_hci_hal_init_c_, _drv_err_,
748 "%s: IQK fail recover\n", __func__);
749 }
750
751 /* ack for xmit mgmt frames. */
752 rtl8723au_write32(Adapter, REG_FWHW_TXQ_CTRL,
753 rtl8723au_read32(Adapter, REG_FWHW_TXQ_CTRL)|BIT(12));
754
755 exit:
756 if (status == _SUCCESS) {
757 Adapter->hw_init_completed = true;
758
759 if (Adapter->registrypriv.notch_filter == 1)
760 rtl8723a_notch_filter(Adapter, 1);
761 }
762
763 DBG_8723A("%s in %dms\n", __func__,
764 jiffies_to_msecs(jiffies - init_start_time));
765 return status;
766 }
767
phy_SsPwrSwitch92CU(struct rtw_adapter * Adapter,enum rt_rf_power_state eRFPowerState)768 static void phy_SsPwrSwitch92CU(struct rtw_adapter *Adapter,
769 enum rt_rf_power_state eRFPowerState)
770 {
771 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
772 u8 sps0;
773
774 sps0 = rtl8723au_read8(Adapter, REG_SPS0_CTRL);
775
776 switch (eRFPowerState) {
777 case rf_on:
778 /* 1. Enable MAC Clock. Can not be enabled now. */
779 /* WriteXBYTE(REG_SYS_CLKR+1,
780 ReadXBYTE(REG_SYS_CLKR+1) | BIT(3)); */
781
782 /* 2. Force PWM, Enable SPS18_LDO_Marco_Block */
783 rtl8723au_write8(Adapter, REG_SPS0_CTRL,
784 sps0 | BIT(0) | BIT(3));
785
786 /* 3. restore BB, AFE control register. */
787 /* RF */
788 if (pHalData->rf_type == RF_2T2R)
789 PHY_SetBBReg(Adapter, rFPGA0_XAB_RFParameter,
790 0x380038, 1);
791 else
792 PHY_SetBBReg(Adapter, rFPGA0_XAB_RFParameter,
793 0x38, 1);
794 PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, 0xf0, 1);
795 PHY_SetBBReg(Adapter, rFPGA0_RFMOD, BIT(1), 0);
796
797 /* AFE */
798 if (pHalData->rf_type == RF_2T2R)
799 rtl8723au_write32(Adapter, rRx_Wait_CCA, 0x63DB25A0);
800 else if (pHalData->rf_type == RF_1T1R)
801 rtl8723au_write32(Adapter, rRx_Wait_CCA, 0x631B25A0);
802
803 /* 4. issue 3-wire command that RF set to Rx idle
804 mode. This is used to re-write the RX idle mode. */
805 /* We can only prvide a usual value instead and then
806 HW will modify the value by itself. */
807 PHY_SetRFReg(Adapter, RF_PATH_A, RF_AC,
808 bRFRegOffsetMask, 0x32D95);
809 if (pHalData->rf_type == RF_2T2R) {
810 PHY_SetRFReg(Adapter, RF_PATH_B, RF_AC,
811 bRFRegOffsetMask, 0x32D95);
812 }
813 break;
814 case rf_sleep:
815 case rf_off:
816 if (IS_81xxC_VENDOR_UMC_B_CUT(pHalData->VersionID))
817 sps0 &= ~BIT(0);
818 else
819 sps0 &= ~(BIT(0) | BIT(3));
820
821 RT_TRACE(_module_hal_init_c_, _drv_err_, "SS LVL1\n");
822 /* Disable RF and BB only for SelectSuspend. */
823
824 /* 1. Set BB/RF to shutdown. */
825 /* (1) Reg878[5:3]= 0 RF rx_code for
826 preamble power saving */
827 /* (2)Reg878[21:19]= 0 Turn off RF-B */
828 /* (3) RegC04[7:4]= 0 Turn off all paths
829 for packet detection */
830 /* (4) Reg800[1] = 1 enable preamble power saving */
831 Adapter->pwrctrlpriv.PS_BBRegBackup[PSBBREG_RF0] =
832 rtl8723au_read32(Adapter, rFPGA0_XAB_RFParameter);
833 Adapter->pwrctrlpriv.PS_BBRegBackup[PSBBREG_RF1] =
834 rtl8723au_read32(Adapter, rOFDM0_TRxPathEnable);
835 Adapter->pwrctrlpriv.PS_BBRegBackup[PSBBREG_RF2] =
836 rtl8723au_read32(Adapter, rFPGA0_RFMOD);
837 if (pHalData->rf_type == RF_2T2R) {
838 PHY_SetBBReg(Adapter, rFPGA0_XAB_RFParameter,
839 0x380038, 0);
840 } else if (pHalData->rf_type == RF_1T1R) {
841 PHY_SetBBReg(Adapter, rFPGA0_XAB_RFParameter, 0x38, 0);
842 }
843 PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, 0xf0, 0);
844 PHY_SetBBReg(Adapter, rFPGA0_RFMOD, BIT(1), 1);
845
846 /* 2 .AFE control register to power down. bit[30:22] */
847 Adapter->pwrctrlpriv.PS_BBRegBackup[PSBBREG_AFE0] =
848 rtl8723au_read32(Adapter, rRx_Wait_CCA);
849 if (pHalData->rf_type == RF_2T2R)
850 rtl8723au_write32(Adapter, rRx_Wait_CCA, 0x00DB25A0);
851 else if (pHalData->rf_type == RF_1T1R)
852 rtl8723au_write32(Adapter, rRx_Wait_CCA, 0x001B25A0);
853
854 /* 3. issue 3-wire command that RF set to power down.*/
855 PHY_SetRFReg(Adapter, RF_PATH_A, RF_AC, bRFRegOffsetMask, 0);
856 if (pHalData->rf_type == RF_2T2R)
857 PHY_SetRFReg(Adapter, RF_PATH_B, RF_AC,
858 bRFRegOffsetMask, 0);
859
860 /* 4. Force PFM , disable SPS18_LDO_Marco_Block */
861 rtl8723au_write8(Adapter, REG_SPS0_CTRL, sps0);
862 break;
863 default:
864 break;
865 }
866 }
867
CardDisableRTL8723U(struct rtw_adapter * Adapter)868 static void CardDisableRTL8723U(struct rtw_adapter *Adapter)
869 {
870 u8 u1bTmp;
871
872 DBG_8723A("CardDisableRTL8723U\n");
873 /* USB-MF Card Disable Flow */
874 /* 1. Run LPS WL RFOFF flow */
875 HalPwrSeqCmdParsing23a(Adapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
876 PWR_INTF_USB_MSK, rtl8723AU_enter_lps_flow);
877
878 /* 2. 0x1F[7:0] = 0 turn off RF */
879 rtl8723au_write8(Adapter, REG_RF_CTRL, 0x00);
880
881 /* ==== Reset digital sequence ====== */
882 if ((rtl8723au_read8(Adapter, REG_MCUFWDL) & BIT(7)) &&
883 Adapter->bFWReady) /* 8051 RAM code */
884 rtl8723a_FirmwareSelfReset(Adapter);
885
886 /* Reset MCU. Suggested by Filen. 2011.01.26. by tynli. */
887 u1bTmp = rtl8723au_read8(Adapter, REG_SYS_FUNC_EN+1);
888 rtl8723au_write8(Adapter, REG_SYS_FUNC_EN+1, u1bTmp & ~BIT(2));
889
890 /* g. MCUFWDL 0x80[1:0]= 0 reset MCU ready status */
891 rtl8723au_write8(Adapter, REG_MCUFWDL, 0x00);
892
893 /* ==== Reset digital sequence end ====== */
894 /* Card disable power action flow */
895 HalPwrSeqCmdParsing23a(Adapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
896 PWR_INTF_USB_MSK,
897 rtl8723AU_card_disable_flow);
898
899 /* Reset MCU IO Wrapper, added by Roger, 2011.08.30. */
900 u1bTmp = rtl8723au_read8(Adapter, REG_RSV_CTRL + 1);
901 rtl8723au_write8(Adapter, REG_RSV_CTRL+1, u1bTmp & ~BIT(0));
902 u1bTmp = rtl8723au_read8(Adapter, REG_RSV_CTRL + 1);
903 rtl8723au_write8(Adapter, REG_RSV_CTRL+1, u1bTmp | BIT(0));
904
905 /* 7. RSV_CTRL 0x1C[7:0] = 0x0E lock ISO/CLK/Power control register */
906 rtl8723au_write8(Adapter, REG_RSV_CTRL, 0x0e);
907 }
908
rtl8723au_hal_deinit(struct rtw_adapter * padapter)909 int rtl8723au_hal_deinit(struct rtw_adapter *padapter)
910 {
911 DBG_8723A("==> %s\n", __func__);
912
913 #ifdef CONFIG_8723AU_BT_COEXIST
914 BT_HaltProcess(padapter);
915 #endif
916 /* 2011/02/18 To Fix RU LNA power leakage problem. We need to
917 execute below below in Adapter init and halt sequence.
918 According to EEchou's opinion, we can enable the ability for all */
919 /* IC. Accord to johnny's opinion, only RU need the support. */
920 CardDisableRTL8723U(padapter);
921
922 padapter->hw_init_completed = false;
923
924 return _SUCCESS;
925 }
926
rtl8723au_inirp_init(struct rtw_adapter * Adapter)927 int rtl8723au_inirp_init(struct rtw_adapter *Adapter)
928 {
929 u8 i;
930 struct recv_buf *precvbuf;
931 int status;
932 struct recv_priv *precvpriv = &Adapter->recvpriv;
933 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
934
935 status = _SUCCESS;
936
937 RT_TRACE(_module_hci_hal_init_c_, _drv_info_, "===> usb_inirp_init\n");
938
939 /* issue Rx irp to receive data */
940 precvbuf = (struct recv_buf *)precvpriv->precv_buf;
941 for (i = 0; i < NR_RECVBUFF; i++) {
942 if (rtl8723au_read_port(Adapter, 0, precvbuf) == _FAIL) {
943 RT_TRACE(_module_hci_hal_init_c_, _drv_err_,
944 "usb_rx_init: usb_read_port error\n");
945 status = _FAIL;
946 goto exit;
947 }
948 precvbuf++;
949 }
950 if (rtl8723au_read_interrupt(Adapter) == _FAIL) {
951 RT_TRACE(_module_hci_hal_init_c_, _drv_err_,
952 "%s: usb_read_interrupt error\n", __func__);
953 status = _FAIL;
954 }
955 pHalData->IntrMask[0] = rtl8723au_read32(Adapter, REG_USB_HIMR);
956 MSG_8723A("pHalData->IntrMask = 0x%04x\n", pHalData->IntrMask[0]);
957 pHalData->IntrMask[0] |= UHIMR_C2HCMD|UHIMR_CPWM;
958 rtl8723au_write32(Adapter, REG_USB_HIMR, pHalData->IntrMask[0]);
959 exit:
960 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
961 "<=== usb_inirp_init\n");
962 return status;
963 }
964
rtl8723au_inirp_deinit(struct rtw_adapter * Adapter)965 int rtl8723au_inirp_deinit(struct rtw_adapter *Adapter)
966 {
967 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
968
969 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
970 "===> usb_rx_deinit\n");
971 rtl8723au_read_port_cancel(Adapter);
972 pHalData->IntrMask[0] = rtl8723au_read32(Adapter, REG_USB_HIMR);
973 MSG_8723A("%s pHalData->IntrMask = 0x%04x\n", __func__,
974 pHalData->IntrMask[0]);
975 pHalData->IntrMask[0] = 0x0;
976 rtl8723au_write32(Adapter, REG_USB_HIMR, pHalData->IntrMask[0]);
977 RT_TRACE(_module_hci_hal_init_c_, _drv_info_,
978 "<=== usb_rx_deinit\n");
979 return _SUCCESS;
980 }
981
_ReadBoardType(struct rtw_adapter * Adapter,u8 * PROMContent,bool AutoloadFail)982 static void _ReadBoardType(struct rtw_adapter *Adapter, u8 *PROMContent,
983 bool AutoloadFail)
984 {
985 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
986 u8 boardType = BOARD_USB_DONGLE;
987
988 if (AutoloadFail) {
989 if (IS_8723_SERIES(pHalData->VersionID))
990 pHalData->rf_type = RF_1T1R;
991 else
992 pHalData->rf_type = RF_2T2R;
993 pHalData->BoardType = boardType;
994 return;
995 }
996
997 boardType = PROMContent[EEPROM_NORMAL_BoardType];
998 boardType &= BOARD_TYPE_NORMAL_MASK;/* bit[7:5] */
999 boardType >>= 5;
1000
1001 pHalData->BoardType = boardType;
1002 MSG_8723A("_ReadBoardType(%x)\n", pHalData->BoardType);
1003
1004 if (boardType == BOARD_USB_High_PA)
1005 pHalData->ExternalPA = 1;
1006 }
1007
Hal_EfuseParseMACAddr_8723AU(struct rtw_adapter * padapter,u8 * hwinfo,bool AutoLoadFail)1008 static void Hal_EfuseParseMACAddr_8723AU(struct rtw_adapter *padapter,
1009 u8 *hwinfo, bool AutoLoadFail)
1010 {
1011 u16 i;
1012 u8 sMacAddr[ETH_ALEN] = {0x00, 0xE0, 0x4C, 0x87, 0x23, 0x00};
1013 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
1014
1015 if (AutoLoadFail) {
1016 for (i = 0; i < 6; i++)
1017 pEEPROM->mac_addr[i] = sMacAddr[i];
1018 } else {
1019 /* Read Permanent MAC address */
1020 memcpy(pEEPROM->mac_addr, &hwinfo[EEPROM_MAC_ADDR_8723AU],
1021 ETH_ALEN);
1022 }
1023
1024 RT_TRACE(_module_hci_hal_init_c_, _drv_notice_,
1025 "Hal_EfuseParseMACAddr_8723AU: Permanent Address =%02x:%02x:%02x:%02x:%02x:%02x\n",
1026 pEEPROM->mac_addr[0], pEEPROM->mac_addr[1],
1027 pEEPROM->mac_addr[2], pEEPROM->mac_addr[3],
1028 pEEPROM->mac_addr[4], pEEPROM->mac_addr[5]);
1029 }
1030
readAdapterInfo(struct rtw_adapter * padapter)1031 static void readAdapterInfo(struct rtw_adapter *padapter)
1032 {
1033 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
1034 /* struct hal_data_8723a * pHalData = GET_HAL_DATA(padapter); */
1035 u8 hwinfo[HWSET_MAX_SIZE];
1036
1037 Hal_InitPGData(padapter, hwinfo);
1038 Hal_EfuseParseIDCode(padapter, hwinfo);
1039 Hal_EfuseParseEEPROMVer(padapter, hwinfo,
1040 pEEPROM->bautoload_fail_flag);
1041 Hal_EfuseParseMACAddr_8723AU(padapter, hwinfo,
1042 pEEPROM->bautoload_fail_flag);
1043 Hal_EfuseParsetxpowerinfo_8723A(padapter, hwinfo,
1044 pEEPROM->bautoload_fail_flag);
1045 _ReadBoardType(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
1046 Hal_EfuseParseBTCoexistInfo_8723A(padapter, hwinfo,
1047 pEEPROM->bautoload_fail_flag);
1048
1049 rtl8723a_EfuseParseChnlPlan(padapter, hwinfo,
1050 pEEPROM->bautoload_fail_flag);
1051 Hal_EfuseParseThermalMeter_8723A(padapter, hwinfo,
1052 pEEPROM->bautoload_fail_flag);
1053 /* _ReadRFSetting(Adapter, PROMContent, pEEPROM->bautoload_fail_flag); */
1054 /* _ReadPSSetting(Adapter, PROMContent, pEEPROM->bautoload_fail_flag); */
1055 Hal_EfuseParseAntennaDiversity(padapter, hwinfo,
1056 pEEPROM->bautoload_fail_flag);
1057
1058 Hal_EfuseParseEEPROMVer(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
1059 Hal_EfuseParseCustomerID(padapter, hwinfo,
1060 pEEPROM->bautoload_fail_flag);
1061 Hal_EfuseParseRateIndicationOption(padapter, hwinfo,
1062 pEEPROM->bautoload_fail_flag);
1063 Hal_EfuseParseXtal_8723A(padapter, hwinfo,
1064 pEEPROM->bautoload_fail_flag);
1065
1066 /* hal_CustomizedBehavior_8723U(Adapter); */
1067
1068 /* Adapter->bDongle = (PROMContent[EEPROM_EASY_REPLACEMENT] == 1)? 0: 1; */
1069 DBG_8723A("%s(): REPLACEMENT = %x\n", __func__, padapter->bDongle);
1070 }
1071
_ReadPROMContent(struct rtw_adapter * Adapter)1072 static void _ReadPROMContent(struct rtw_adapter *Adapter)
1073 {
1074 struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);
1075 u8 eeValue;
1076
1077 eeValue = rtl8723au_read8(Adapter, REG_9346CR);
1078 /* To check system boot selection. */
1079 pEEPROM->EepromOrEfuse = (eeValue & BOOT_FROM_EEPROM) ? true : false;
1080 pEEPROM->bautoload_fail_flag = (eeValue & EEPROM_EN) ? false : true;
1081
1082 DBG_8723A("Boot from %s, Autoload %s !\n",
1083 (pEEPROM->EepromOrEfuse ? "EEPROM" : "EFUSE"),
1084 (pEEPROM->bautoload_fail_flag ? "Fail" : "OK"));
1085
1086 readAdapterInfo(Adapter);
1087 }
1088
1089 /* */
1090 /* Description: */
1091 /* We should set Efuse cell selection to WiFi cell in default. */
1092 /* */
1093 /* Assumption: */
1094 /* PASSIVE_LEVEL */
1095 /* */
1096 /* Added by Roger, 2010.11.23. */
1097 /* */
hal_EfuseCellSel(struct rtw_adapter * Adapter)1098 static void hal_EfuseCellSel(struct rtw_adapter *Adapter)
1099 {
1100 u32 value32;
1101
1102 value32 = rtl8723au_read32(Adapter, EFUSE_TEST);
1103 value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
1104 rtl8723au_write32(Adapter, EFUSE_TEST, value32);
1105 }
1106
rtl8723a_read_adapter_info(struct rtw_adapter * Adapter)1107 void rtl8723a_read_adapter_info(struct rtw_adapter *Adapter)
1108 {
1109 unsigned long start = jiffies;
1110
1111 /* Read EEPROM size before call any EEPROM function */
1112 Adapter->EepromAddressSize = GetEEPROMSize8723A(Adapter);
1113
1114 MSG_8723A("====> _ReadAdapterInfo8723AU\n");
1115
1116 hal_EfuseCellSel(Adapter);
1117
1118 _ReadPROMContent(Adapter);
1119
1120 MSG_8723A("<==== _ReadAdapterInfo8723AU in %d ms\n",
1121 jiffies_to_msecs(jiffies - start));
1122 }
1123
1124 /* */
1125 /* Description: */
1126 /* Query setting of specified variable. */
1127 /* */
GetHalDefVar8192CUsb(struct rtw_adapter * Adapter,enum hal_def_variable eVariable,void * pValue)1128 int GetHalDefVar8192CUsb(struct rtw_adapter *Adapter,
1129 enum hal_def_variable eVariable, void *pValue)
1130 {
1131 struct hal_data_8723a *pHalData = GET_HAL_DATA(Adapter);
1132 int bResult = _SUCCESS;
1133
1134 switch (eVariable) {
1135 case HAL_DEF_UNDERCORATEDSMOOTHEDPWDB:
1136 *((int *)pValue) = pHalData->dmpriv.UndecoratedSmoothedPWDB;
1137 break;
1138 case HAL_DEF_IS_SUPPORT_ANT_DIV:
1139 break;
1140 case HAL_DEF_CURRENT_ANTENNA:
1141 break;
1142 case HAL_DEF_DRVINFO_SZ:
1143 *((u32 *)pValue) = DRVINFO_SZ;
1144 break;
1145 case HAL_DEF_MAX_RECVBUF_SZ:
1146 *((u32 *)pValue) = MAX_RECVBUF_SZ;
1147 break;
1148 case HAL_DEF_RX_PACKET_OFFSET:
1149 *((u32 *)pValue) = RXDESC_SIZE + DRVINFO_SZ;
1150 break;
1151 case HAL_DEF_DBG_DUMP_RXPKT:
1152 *((u8 *)pValue) = pHalData->bDumpRxPkt;
1153 break;
1154 case HAL_DEF_DBG_DM_FUNC:
1155 *((u32 *)pValue) = pHalData->odmpriv.SupportAbility;
1156 break;
1157 case HW_VAR_MAX_RX_AMPDU_FACTOR:
1158 *((u32 *)pValue) = IEEE80211_HT_MAX_AMPDU_64K;
1159 break;
1160 case HW_DEF_ODM_DBG_FLAG:
1161 {
1162 struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
1163 printk("pDM_Odm->DebugComponents = 0x%llx\n",
1164 pDM_Odm->DebugComponents);
1165 }
1166 break;
1167 default:
1168 bResult = _FAIL;
1169 break;
1170 }
1171
1172 return bResult;
1173 }
1174
rtl8723a_update_ramask(struct rtw_adapter * padapter,u32 mac_id,u8 rssi_level)1175 void rtl8723a_update_ramask(struct rtw_adapter *padapter,
1176 u32 mac_id, u8 rssi_level)
1177 {
1178 struct sta_info *psta;
1179 struct FW_Sta_Info *fw_sta;
1180 struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
1181 struct dm_priv *pdmpriv = &pHalData->dmpriv;
1182 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1183 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1184 struct wlan_bssid_ex *cur_network = &pmlmeinfo->network;
1185 u8 init_rate, networkType, raid, arg;
1186 u32 mask, rate_bitmap;
1187 u8 shortGIrate = false;
1188 int supportRateNum;
1189
1190 if (mac_id >= NUM_STA) /* CAM_SIZE */
1191 return;
1192
1193 psta = pmlmeinfo->FW_sta_info[mac_id].psta;
1194 if (psta == NULL)
1195 return;
1196
1197 switch (mac_id) {
1198 case 0:/* for infra mode */
1199 supportRateNum =
1200 rtw_get_rateset_len23a(cur_network->SupportedRates);
1201 networkType = judge_network_type23a(padapter,
1202 cur_network->SupportedRates,
1203 supportRateNum) & 0xf;
1204 /* pmlmeext->cur_wireless_mode = networkType; */
1205 raid = networktype_to_raid23a(networkType);
1206
1207 mask = update_supported_rate23a(cur_network->SupportedRates,
1208 supportRateNum);
1209 mask |= (pmlmeinfo->HT_enable) ?
1210 update_MSC_rate23a(&pmlmeinfo->ht_cap) : 0;
1211
1212 if (support_short_GI23a(padapter, &pmlmeinfo->ht_cap))
1213 shortGIrate = true;
1214 break;
1215
1216 case 1:/* for broadcast/multicast */
1217 fw_sta = &pmlmeinfo->FW_sta_info[mac_id];
1218 supportRateNum = rtw_get_rateset_len23a(fw_sta->SupportedRates);
1219 if (pmlmeext->cur_wireless_mode & WIRELESS_11B)
1220 networkType = WIRELESS_11B;
1221 else
1222 networkType = WIRELESS_11G;
1223 raid = networktype_to_raid23a(networkType);
1224
1225 mask = update_basic_rate23a(cur_network->SupportedRates,
1226 supportRateNum);
1227 break;
1228
1229 default: /* for each sta in IBSS */
1230 fw_sta = &pmlmeinfo->FW_sta_info[mac_id];
1231 supportRateNum = rtw_get_rateset_len23a(fw_sta->SupportedRates);
1232 networkType = judge_network_type23a(padapter,
1233 fw_sta->SupportedRates,
1234 supportRateNum) & 0xf;
1235 /* pmlmeext->cur_wireless_mode = networkType; */
1236 raid = networktype_to_raid23a(networkType);
1237
1238 mask = update_supported_rate23a(cur_network->SupportedRates,
1239 supportRateNum);
1240
1241 /* todo: support HT in IBSS */
1242 break;
1243 }
1244
1245 /* mask &= 0x0fffffff; */
1246 rate_bitmap = ODM_Get_Rate_Bitmap23a(pHalData, mac_id, mask,
1247 rssi_level);
1248 DBG_8723A("%s => mac_id:%d, networkType:0x%02x, "
1249 "mask:0x%08x\n\t ==> rssi_level:%d, rate_bitmap:0x%08x\n",
1250 __func__, mac_id, networkType, mask, rssi_level, rate_bitmap);
1251
1252 mask &= rate_bitmap;
1253 mask |= ((raid << 28) & 0xf0000000);
1254
1255 init_rate = get_highest_rate_idx23a(mask) & 0x3f;
1256
1257 arg = mac_id & 0x1f;/* MACID */
1258 arg |= BIT(7);
1259
1260 if (shortGIrate == true)
1261 arg |= BIT(5);
1262
1263 DBG_8723A("update raid entry, mask = 0x%x, arg = 0x%x\n", mask, arg);
1264
1265 rtl8723a_set_raid_cmd(padapter, mask, arg);
1266
1267 /* set ra_id */
1268 psta->raid = raid;
1269 psta->init_rate = init_rate;
1270
1271 /* set correct initial date rate for each mac_id */
1272 pdmpriv->INIDATA_RATE[mac_id] = init_rate;
1273 }
1274