1 /******************************************************************************
3 * Copyright(c) 2007 - 2013 Realtek Corporation. All rights reserved.
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.
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
14 ******************************************************************************/
17 #include <linux/firmware.h>
18 #include <linux/slab.h>
19 #include <drv_types.h>
20 #include <rtw_debug.h>
21 #include <rtl8723b_hal.h>
22 #include "hal_com_h2c.h"
24 static void _FWDownloadEnable(struct adapter
*padapter
, bool enable
)
30 tmp
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
31 rtw_write8(padapter
, REG_SYS_FUNC_EN
+1, tmp
|0x04);
33 tmp
= rtw_read8(padapter
, REG_MCUFWDL
);
34 rtw_write8(padapter
, REG_MCUFWDL
, tmp
|0x01);
37 tmp
= rtw_read8(padapter
, REG_MCUFWDL
);
40 rtw_write8(padapter
, REG_MCUFWDL
, tmp
|0x01);
42 } while (count
++ < 100);
45 DBG_871X("%s: !!!!!!!!Write 0x80 Fail!: count = %d\n", __func__
, count
);
48 tmp
= rtw_read8(padapter
, REG_MCUFWDL
+2);
49 rtw_write8(padapter
, REG_MCUFWDL
+2, tmp
&0xf7);
51 /* MCU firmware download disable. */
52 tmp
= rtw_read8(padapter
, REG_MCUFWDL
);
53 rtw_write8(padapter
, REG_MCUFWDL
, tmp
&0xfe);
57 static int _BlockWrite(struct adapter
*padapter
, void *buffer
, u32 buffSize
)
61 u32 blockSize_p1
= 4; /* (Default) Phase #1 : PCI muse use 4-byte write to download FW */
62 u32 blockSize_p2
= 8; /* Phase #2 : Use 8-byte, if Phase#1 use big size to write FW. */
63 u32 blockSize_p3
= 1; /* Phase #3 : Use 1-byte, the remnant of FW image. */
64 u32 blockCount_p1
= 0, blockCount_p2
= 0, blockCount_p3
= 0;
65 u32 remainSize_p1
= 0, remainSize_p2
= 0;
66 u8
*bufferPtr
= buffer
;
67 u32 i
= 0, offset
= 0;
69 /* printk("====>%s %d\n", __func__, __LINE__); */
72 blockCount_p1
= buffSize
/ blockSize_p1
;
73 remainSize_p1
= buffSize
% blockSize_p1
;
80 "_BlockWrite: [P1] buffSize(%d) blockSize_p1(%d) blockCount_p1(%d) remainSize_p1(%d)\n",
89 for (i
= 0; i
< blockCount_p1
; i
++) {
90 ret
= rtw_write32(padapter
, (FW_8723B_START_ADDRESS
+ i
* blockSize_p1
), *((u32
*)(bufferPtr
+ i
* blockSize_p1
)));
92 printk("====>%s %d i:%d\n", __func__
, __LINE__
, i
);
99 offset
= blockCount_p1
* blockSize_p1
;
101 blockCount_p2
= remainSize_p1
/blockSize_p2
;
102 remainSize_p2
= remainSize_p1
%blockSize_p2
;
109 "_BlockWrite: [P2] buffSize_p2(%d) blockSize_p2(%d) blockCount_p2(%d) remainSize_p2(%d)\n",
122 offset
= (blockCount_p1
* blockSize_p1
) + (blockCount_p2
* blockSize_p2
);
124 blockCount_p3
= remainSize_p2
/ blockSize_p3
;
126 RT_TRACE(_module_hal_init_c_
, _drv_notice_
,
127 ("_BlockWrite: [P3] buffSize_p3(%d) blockSize_p3(%d) blockCount_p3(%d)\n",
128 (buffSize
-offset
), blockSize_p3
, blockCount_p3
));
130 for (i
= 0; i
< blockCount_p3
; i
++) {
131 ret
= rtw_write8(padapter
, (FW_8723B_START_ADDRESS
+ offset
+ i
), *(bufferPtr
+ offset
+ i
));
134 printk("====>%s %d i:%d\n", __func__
, __LINE__
, i
);
143 static int _PageWrite(
144 struct adapter
*padapter
,
151 u8 u8Page
= (u8
) (page
& 0x07);
153 value8
= (rtw_read8(padapter
, REG_MCUFWDL
+2) & 0xF8) | u8Page
;
154 rtw_write8(padapter
, REG_MCUFWDL
+2, value8
);
156 return _BlockWrite(padapter
, buffer
, size
);
159 static int _WriteFW(struct adapter
*padapter
, void *buffer
, u32 size
)
161 /* Since we need dynamic decide method of dwonload fw, so we call this function to get chip version. */
162 /* We can remove _ReadChipVersion from ReadpadapterInfo8192C later. */
164 u32 pageNums
, remainSize
;
166 u8
*bufferPtr
= buffer
;
168 pageNums
= size
/ MAX_DLFW_PAGE_SIZE
;
169 /* RT_ASSERT((pageNums <= 4), ("Page numbers should not greater then 4\n")); */
170 remainSize
= size
% MAX_DLFW_PAGE_SIZE
;
172 for (page
= 0; page
< pageNums
; page
++) {
173 offset
= page
* MAX_DLFW_PAGE_SIZE
;
174 ret
= _PageWrite(padapter
, page
, bufferPtr
+offset
, MAX_DLFW_PAGE_SIZE
);
177 printk("====>%s %d\n", __func__
, __LINE__
);
183 offset
= pageNums
* MAX_DLFW_PAGE_SIZE
;
185 ret
= _PageWrite(padapter
, page
, bufferPtr
+offset
, remainSize
);
188 printk("====>%s %d\n", __func__
, __LINE__
);
192 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("_WriteFW Done- for Normal chip.\n"));
198 void _8051Reset8723(struct adapter
*padapter
)
204 /* Reset 8051(WLMCU) IO wrapper */
206 /* Suggested by Isaac@SD1 and Gimmy@SD1, coding by Lucas@20130624 */
207 io_rst
= rtw_read8(padapter
, REG_RSV_CTRL
+1);
209 rtw_write8(padapter
, REG_RSV_CTRL
+1, io_rst
);
211 cpu_rst
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
213 rtw_write8(padapter
, REG_SYS_FUNC_EN
+1, cpu_rst
);
215 /* Enable 8051 IO wrapper */
217 io_rst
= rtw_read8(padapter
, REG_RSV_CTRL
+1);
219 rtw_write8(padapter
, REG_RSV_CTRL
+1, io_rst
);
221 cpu_rst
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
223 rtw_write8(padapter
, REG_SYS_FUNC_EN
+1, cpu_rst
);
225 DBG_8192C("%s: Finish\n", __func__
);
228 u8 g_fwdl_chksum_fail
= 0;
230 static s32
polling_fwdl_chksum(
231 struct adapter
*adapter
, u32 min_cnt
, u32 timeout_ms
236 unsigned long start
= jiffies
;
239 /* polling CheckSum report */
242 value32
= rtw_read32(adapter
, REG_MCUFWDL
);
243 if (value32
& FWDL_ChkSum_rpt
|| adapter
->bSurpriseRemoved
|| adapter
->bDriverStopped
)
246 } while (jiffies_to_msecs(jiffies
-start
) < timeout_ms
|| cnt
< min_cnt
);
248 if (!(value32
& FWDL_ChkSum_rpt
)) {
252 if (g_fwdl_chksum_fail
) {
253 DBG_871X("%s: fwdl test case: fwdl_chksum_fail\n", __func__
);
254 g_fwdl_chksum_fail
--;
262 "%s: Checksum report %s! (%u, %dms), REG_MCUFWDL:0x%08x\n",
264 (ret
== _SUCCESS
) ? "OK" : "Fail",
266 jiffies_to_msecs(jiffies
-start
),
273 u8 g_fwdl_wintint_rdy_fail
= 0;
275 static s32
_FWFreeToGo(struct adapter
*adapter
, u32 min_cnt
, u32 timeout_ms
)
279 unsigned long start
= jiffies
;
282 value32
= rtw_read32(adapter
, REG_MCUFWDL
);
283 value32
|= MCUFWDL_RDY
;
284 value32
&= ~WINTINI_RDY
;
285 rtw_write32(adapter
, REG_MCUFWDL
, value32
);
287 _8051Reset8723(adapter
);
289 /* polling for FW ready */
292 value32
= rtw_read32(adapter
, REG_MCUFWDL
);
293 if (value32
& WINTINI_RDY
|| adapter
->bSurpriseRemoved
|| adapter
->bDriverStopped
)
296 } while (jiffies_to_msecs(jiffies
- start
) < timeout_ms
|| cnt
< min_cnt
);
298 if (!(value32
& WINTINI_RDY
)) {
302 if (g_fwdl_wintint_rdy_fail
) {
303 DBG_871X("%s: fwdl test case: wintint_rdy_fail\n", __func__
);
304 g_fwdl_wintint_rdy_fail
--;
312 "%s: Polling FW ready %s! (%u, %dms), REG_MCUFWDL:0x%08x\n",
314 (ret
== _SUCCESS
) ? "OK" : "Fail",
316 jiffies_to_msecs(jiffies
-start
),
323 #define IS_FW_81xxC(padapter) (((GET_HAL_DATA(padapter))->FirmwareSignature & 0xFFF0) == 0x88C0)
325 void rtl8723b_FirmwareSelfReset(struct adapter
*padapter
)
327 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
332 !(IS_FW_81xxC(padapter
) && ((pHalData
->FirmwareVersion
< 0x21) || (pHalData
->FirmwareVersion
== 0x21 && pHalData
->FirmwareSubVersion
< 0x01)))
333 ) { /* after 88C Fw v33.1 */
334 /* 0x1cf = 0x20. Inform 8051 to reset. 2009.12.25. tynli_test */
335 rtw_write8(padapter
, REG_HMETFR
+3, 0x20);
337 u1bTmp
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
338 while (u1bTmp
& BIT2
) {
343 u1bTmp
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
345 RT_TRACE(_module_hal_init_c_
, _drv_notice_
, ("-%s: 8051 reset success (%d)\n", __func__
, Delay
));
348 RT_TRACE(_module_hal_init_c_
, _drv_notice_
, ("%s: Force 8051 reset!!!\n", __func__
));
349 /* force firmware reset */
350 u1bTmp
= rtw_read8(padapter
, REG_SYS_FUNC_EN
+1);
351 rtw_write8(padapter
, REG_SYS_FUNC_EN
+1, u1bTmp
&(~BIT2
));
358 /* Download 8192C firmware code. */
361 s32
rtl8723b_FirmwareDownload(struct adapter
*padapter
, bool bUsedWoWLANFw
)
363 s32 rtStatus
= _SUCCESS
;
365 unsigned long fwdl_start_time
;
366 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
367 struct rt_firmware
*pFirmware
;
368 struct rt_firmware
*pBTFirmware
;
369 struct rt_firmware_hdr
*pFwHdr
= NULL
;
372 const struct firmware
*fw
;
373 struct device
*device
= dvobj_to_dev(padapter
->dvobj
);
375 struct dvobj_priv
*psdpriv
= padapter
->dvobj
;
376 struct debug_priv
*pdbgpriv
= &psdpriv
->drv_dbg
;
379 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("+%s\n", __func__
));
381 RT_TRACE(_module_hal_init_c_
, _drv_notice_
, ("+%s, bUsedWoWLANFw:%d\n", __func__
, bUsedWoWLANFw
));
383 pFirmware
= kzalloc(sizeof(struct rt_firmware
), GFP_KERNEL
);
386 pBTFirmware
= kzalloc(sizeof(struct rt_firmware
), GFP_KERNEL
);
391 tmp_ps
= rtw_read8(padapter
, 0xa3);
394 /* 1. write 0xA3[:2:0] = 3b'010 */
395 rtw_write8(padapter
, 0xa3, tmp_ps
);
396 /* 2. read power_state = 0xA0[1:0] */
397 tmp_ps
= rtw_read8(padapter
, 0xa0);
399 if (tmp_ps
!= 0x01) {
400 DBG_871X(FUNC_ADPT_FMT
" tmp_ps =%x\n", FUNC_ADPT_ARG(padapter
), tmp_ps
);
401 pdbgpriv
->dbg_downloadfw_pwr_state_cnt
++;
406 fwfilepath
= "rtlwifi/rtl8723bs_wowlan.bin";
408 #endif /* CONFIG_WOWLAN */
409 fwfilepath
= "rtlwifi/rtl8723bs_nic.bin";
411 pr_info("rtl8723bs: acquire FW from file:%s\n", fwfilepath
);
413 rtStatus
= request_firmware(&fw
, fwfilepath
, device
);
415 pr_err("Request firmware failed with error 0x%x\n", rtStatus
);
421 pr_err("Firmware %s not available\n", fwfilepath
);
426 if (fw
->size
> FW_8723B_SIZE
) {
431 ("Firmware size exceed 0x%X. Check it.\n", FW_8188E_SIZE
)
436 pFirmware
->szFwBuffer
= kzalloc(fw
->size
, GFP_KERNEL
);
437 if (!pFirmware
->szFwBuffer
) {
442 memcpy(pFirmware
->szFwBuffer
, fw
->data
, fw
->size
);
443 pFirmware
->ulFwLength
= fw
->size
;
444 release_firmware(fw
);
445 if (pFirmware
->ulFwLength
> FW_8723B_SIZE
) {
447 DBG_871X_LEVEL(_drv_emerg_
, "Firmware size:%u exceed %u\n", pFirmware
->ulFwLength
, FW_8723B_SIZE
);
451 pFirmwareBuf
= pFirmware
->szFwBuffer
;
452 FirmwareLen
= pFirmware
->ulFwLength
;
454 /* To Check Fw header. Added by tynli. 2009.12.04. */
455 pFwHdr
= (struct rt_firmware_hdr
*)pFirmwareBuf
;
457 pHalData
->FirmwareVersion
= le16_to_cpu(pFwHdr
->Version
);
458 pHalData
->FirmwareSubVersion
= le16_to_cpu(pFwHdr
->Subversion
);
459 pHalData
->FirmwareSignature
= le16_to_cpu(pFwHdr
->Signature
);
462 "%s: fw_ver =%x fw_subver =%04x sig = 0x%x, Month =%02x, Date =%02x, Hour =%02x, Minute =%02x\n",
464 pHalData
->FirmwareVersion
,
465 pHalData
->FirmwareSubVersion
,
466 pHalData
->FirmwareSignature
,
473 if (IS_FW_HEADER_EXIST_8723B(pFwHdr
)) {
474 DBG_871X("%s(): Shift for fw header!\n", __func__
);
475 /* Shift 32 bytes for FW header */
476 pFirmwareBuf
= pFirmwareBuf
+ 32;
477 FirmwareLen
= FirmwareLen
- 32;
480 /* Suggested by Filen. If 8051 is running in RAM code, driver should inform Fw to reset by itself, */
481 /* or it will cause download Fw fail. 2010.02.01. by tynli. */
482 if (rtw_read8(padapter
, REG_MCUFWDL
) & RAM_DL_SEL
) { /* 8051 RAM code */
483 rtw_write8(padapter
, REG_MCUFWDL
, 0x00);
484 rtl8723b_FirmwareSelfReset(padapter
);
487 _FWDownloadEnable(padapter
, true);
488 fwdl_start_time
= jiffies
;
490 !padapter
->bDriverStopped
&&
491 !padapter
->bSurpriseRemoved
&&
492 (write_fw
++ < 3 || jiffies_to_msecs(jiffies
- fwdl_start_time
) < 500)
494 /* reset FWDL chksum */
495 rtw_write8(padapter
, REG_MCUFWDL
, rtw_read8(padapter
, REG_MCUFWDL
)|FWDL_ChkSum_rpt
);
497 rtStatus
= _WriteFW(padapter
, pFirmwareBuf
, FirmwareLen
);
498 if (rtStatus
!= _SUCCESS
)
501 rtStatus
= polling_fwdl_chksum(padapter
, 5, 50);
502 if (rtStatus
== _SUCCESS
)
505 _FWDownloadEnable(padapter
, false);
506 if (_SUCCESS
!= rtStatus
)
509 rtStatus
= _FWFreeToGo(padapter
, 10, 200);
510 if (_SUCCESS
!= rtStatus
)
515 "FWDL %s. write_fw:%u, %dms\n",
516 (rtStatus
== _SUCCESS
)?"success":"fail",
518 jiffies_to_msecs(jiffies
- fwdl_start_time
)
522 kfree(pFirmware
->szFwBuffer
);
526 DBG_871X(" <=== rtl8723b_FirmwareDownload()\n");
530 void rtl8723b_InitializeFirmwareVars(struct adapter
*padapter
)
532 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
534 /* Init Fw LPS related. */
535 adapter_to_pwrctl(padapter
)->bFwCurrentInPSMode
= false;
538 rtw_write8(padapter
, REG_HMETFR
, 0x0f);
540 /* Init H2C counter. by tynli. 2009.12.09. */
541 pHalData
->LastHMEBoxNum
= 0;
542 /* pHalData->H2CQueueHead = 0; */
543 /* pHalData->H2CQueueTail = 0; */
544 /* pHalData->H2CStopInsertQueue = false; */
547 #if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
551 /* Description: Prepare some information to Fw for WoWLAN. */
552 /* (1) Download wowlan Fw. */
553 /* (2) Download RSVD page packets. */
554 /* (3) Enable AP offload if needed. */
556 /* 2011.04.12 by tynli. */
558 void SetFwRelatedForWoWLAN8723b(
559 struct adapter
*padapter
, u8 bHostIsGoingtoSleep
564 /* 1. Before WoWLAN we need to re-download WoWLAN Fw. */
566 status
= rtl8723b_FirmwareDownload(padapter
, bHostIsGoingtoSleep
);
567 if (status
!= _SUCCESS
) {
568 DBG_871X("SetFwRelatedForWoWLAN8723b(): Re-Download Firmware failed!!\n");
571 DBG_871X("SetFwRelatedForWoWLAN8723b(): Re-Download Firmware Success !!\n");
574 /* 2. Re-Init the variables about Fw related setting. */
576 rtl8723b_InitializeFirmwareVars(padapter
);
578 #endif /* CONFIG_WOWLAN */
580 static void rtl8723b_free_hal_data(struct adapter
*padapter
)
585 /* Efuse related code */
587 static u8
hal_EfuseSwitchToBank(
588 struct adapter
*padapter
, u8 bank
, bool bPseudoTest
593 #ifdef HAL_EFUSE_MEMORY
594 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
595 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
599 DBG_8192C("%s: Efuse switch bank to %d\n", __func__
, bank
);
601 #ifdef HAL_EFUSE_MEMORY
602 pEfuseHal
->fakeEfuseBank
= bank
;
604 fakeEfuseBank
= bank
;
608 value32
= rtw_read32(padapter
, EFUSE_TEST
);
612 value32
= (value32
& ~EFUSE_SEL_MASK
) | EFUSE_SEL(EFUSE_WIFI_SEL_0
);
615 value32
= (value32
& ~EFUSE_SEL_MASK
) | EFUSE_SEL(EFUSE_BT_SEL_0
);
618 value32
= (value32
& ~EFUSE_SEL_MASK
) | EFUSE_SEL(EFUSE_BT_SEL_1
);
621 value32
= (value32
& ~EFUSE_SEL_MASK
) | EFUSE_SEL(EFUSE_BT_SEL_2
);
624 value32
= (value32
& ~EFUSE_SEL_MASK
) | EFUSE_SEL(EFUSE_WIFI_SEL_0
);
628 rtw_write32(padapter
, EFUSE_TEST
, value32
);
634 static void Hal_GetEfuseDefinition(
635 struct adapter
*padapter
,
643 case TYPE_EFUSE_MAX_SECTION
:
648 if (efuseType
== EFUSE_WIFI
)
649 *pMax_section
= EFUSE_MAX_SECTION_8723B
;
651 *pMax_section
= EFUSE_BT_MAX_SECTION
;
655 case TYPE_EFUSE_REAL_CONTENT_LEN
:
660 if (efuseType
== EFUSE_WIFI
)
661 *pu2Tmp
= EFUSE_REAL_CONTENT_LEN_8723B
;
663 *pu2Tmp
= EFUSE_BT_REAL_CONTENT_LEN
;
667 case TYPE_AVAILABLE_EFUSE_BYTES_BANK
:
672 if (efuseType
== EFUSE_WIFI
)
673 *pu2Tmp
= (EFUSE_REAL_CONTENT_LEN_8723B
-EFUSE_OOB_PROTECT_BYTES
);
675 *pu2Tmp
= (EFUSE_BT_REAL_BANK_CONTENT_LEN
-EFUSE_PROTECT_BYTES_BANK
);
679 case TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
:
684 if (efuseType
== EFUSE_WIFI
)
685 *pu2Tmp
= (EFUSE_REAL_CONTENT_LEN_8723B
-EFUSE_OOB_PROTECT_BYTES
);
687 *pu2Tmp
= (EFUSE_BT_REAL_CONTENT_LEN
-(EFUSE_PROTECT_BYTES_BANK
*3));
691 case TYPE_EFUSE_MAP_LEN
:
696 if (efuseType
== EFUSE_WIFI
)
697 *pu2Tmp
= EFUSE_MAX_MAP_LEN
;
699 *pu2Tmp
= EFUSE_BT_MAP_LEN
;
703 case TYPE_EFUSE_PROTECT_BYTES_BANK
:
708 if (efuseType
== EFUSE_WIFI
)
709 *pu1Tmp
= EFUSE_OOB_PROTECT_BYTES
;
711 *pu1Tmp
= EFUSE_PROTECT_BYTES_BANK
;
715 case TYPE_EFUSE_CONTENT_LEN_BANK
:
720 if (efuseType
== EFUSE_WIFI
)
721 *pu2Tmp
= EFUSE_REAL_CONTENT_LEN_8723B
;
723 *pu2Tmp
= EFUSE_BT_REAL_BANK_CONTENT_LEN
;
737 #define VOLTAGE_V25 0x03
738 #define LDOE25_SHIFT 28
741 /* The following is for compile ok */
742 /* That should be merged with the original in the future */
744 #define EFUSE_ACCESS_ON_8723 0x69 /* For RTL8723 only. */
745 #define EFUSE_ACCESS_OFF_8723 0x00 /* For RTL8723 only. */
746 #define REG_EFUSE_ACCESS_8723 0x00CF /* Efuse access protection for RTL8723 */
749 static void Hal_BT_EfusePowerSwitch(
750 struct adapter
*padapter
, u8 bWrite
, u8 PwrState
754 if (PwrState
== true) {
755 /* enable BT power cut */
757 tempval
= rtw_read8(padapter
, 0x6B);
759 rtw_write8(padapter
, 0x6B, tempval
);
761 /* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay */
762 /* So don't wirte 0x6A[14]= 1 and 0x6A[15]= 0 together! */
764 /* disable BT output isolation */
766 tempval
= rtw_read8(padapter
, 0x6B);
768 rtw_write8(padapter
, 0x6B, tempval
);
770 /* enable BT output isolation */
772 tempval
= rtw_read8(padapter
, 0x6B);
774 rtw_write8(padapter
, 0x6B, tempval
);
776 /* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay */
777 /* So don't wirte 0x6A[14]= 1 and 0x6A[15]= 0 together! */
779 /* disable BT power cut */
781 tempval
= rtw_read8(padapter
, 0x6B);
783 rtw_write8(padapter
, 0x6B, tempval
);
787 static void Hal_EfusePowerSwitch(
788 struct adapter
*padapter
, u8 bWrite
, u8 PwrState
795 if (PwrState
== true) {
796 /* To avoid cannot access efuse regsiters after disable/enable several times during DTM test. */
797 /* Suggested by SD1 IsaacHsu. 2013.07.08, added by tynli. */
798 tempval
= rtw_read8(padapter
, SDIO_LOCAL_BASE
|SDIO_REG_HSUS_CTRL
);
799 if (tempval
& BIT(0)) { /* SDIO local register is suspend */
804 rtw_write8(padapter
, SDIO_LOCAL_BASE
|SDIO_REG_HSUS_CTRL
, tempval
);
806 /* check 0x86[1:0]= 10'2h, wait power state to leave suspend */
808 tempval
= rtw_read8(padapter
, SDIO_LOCAL_BASE
|SDIO_REG_HSUS_CTRL
);
821 DBG_8192C(FUNC_ADPT_FMT
": Leave SDIO local register suspend fail! Local 0x86 =%#X\n",
822 FUNC_ADPT_ARG(padapter
), tempval
);
824 DBG_8192C(FUNC_ADPT_FMT
": Leave SDIO local register suspend OK! Local 0x86 =%#X\n",
825 FUNC_ADPT_ARG(padapter
), tempval
);
829 rtw_write8(padapter
, REG_EFUSE_ACCESS_8723
, EFUSE_ACCESS_ON_8723
);
831 /* Reset: 0x0000h[28], default valid */
832 tmpV16
= rtw_read16(padapter
, REG_SYS_FUNC_EN
);
833 if (!(tmpV16
& FEN_ELDR
)) {
835 rtw_write16(padapter
, REG_SYS_FUNC_EN
, tmpV16
);
838 /* Clock: Gated(0x0008h[5]) 8M(0x0008h[1]) clock from ANA, default valid */
839 tmpV16
= rtw_read16(padapter
, REG_SYS_CLKR
);
840 if ((!(tmpV16
& LOADER_CLK_EN
)) || (!(tmpV16
& ANA8M
))) {
841 tmpV16
|= (LOADER_CLK_EN
| ANA8M
);
842 rtw_write16(padapter
, REG_SYS_CLKR
, tmpV16
);
845 if (bWrite
== true) {
846 /* Enable LDO 2.5V before read/write action */
847 tempval
= rtw_read8(padapter
, EFUSE_TEST
+3);
849 tempval
|= (VOLTAGE_V25
<< 4);
850 rtw_write8(padapter
, EFUSE_TEST
+3, (tempval
| 0x80));
852 /* rtw_write8(padapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_ON); */
855 rtw_write8(padapter
, REG_EFUSE_ACCESS
, EFUSE_ACCESS_OFF
);
857 if (bWrite
== true) {
858 /* Disable LDO 2.5V after read/write action */
859 tempval
= rtw_read8(padapter
, EFUSE_TEST
+3);
860 rtw_write8(padapter
, EFUSE_TEST
+3, (tempval
& 0x7F));
866 static void hal_ReadEFuse_WiFi(
867 struct adapter
*padapter
,
874 #ifdef HAL_EFUSE_MEMORY
875 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
876 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
881 u8 efuseHeader
, efuseExtHdr
, efuseData
;
885 /* DBG_871X("YJ: ====>%s():_offset =%d _size_byte =%d bPseudoTest =%d\n", __func__, _offset, _size_byte, bPseudoTest); */
887 /* Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10. */
889 if ((_offset
+_size_byte
) > EFUSE_MAX_MAP_LEN
) {
890 DBG_8192C("%s: Invalid offset(%#x) with read bytes(%#x)!!\n", __func__
, _offset
, _size_byte
);
894 efuseTbl
= (u8
*)rtw_malloc(EFUSE_MAX_MAP_LEN
);
895 if (efuseTbl
== NULL
) {
896 DBG_8192C("%s: alloc efuseTbl fail!\n", __func__
);
899 /* 0xff will be efuse default value instead of 0x00. */
900 memset(efuseTbl
, 0xFF, EFUSE_MAX_MAP_LEN
);
905 for (i
= 0; i
< 256; i
++)
906 efuse_OneByteRead(padapter
, i
, &efuseTbl
[i
], false);
907 DBG_871X("Efuse Content:\n");
908 for (i
= 0; i
< 256; i
++) {
911 printk("%02X ", efuseTbl
[i
]);
918 /* switch bank back to bank 0 for later BT and wifi use. */
919 hal_EfuseSwitchToBank(padapter
, 0, bPseudoTest
);
921 while (AVAILABLE_EFUSE_ADDR(eFuse_Addr
)) {
922 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseHeader
, bPseudoTest
);
923 if (efuseHeader
== 0xFF) {
924 DBG_8192C("%s: data end at address =%#x\n", __func__
, eFuse_Addr
-1);
927 /* DBG_8192C("%s: efuse[0x%X]= 0x%02X\n", __func__, eFuse_Addr-1, efuseHeader); */
929 /* Check PG header for section num. */
930 if (EXT_HEADER(efuseHeader
)) { /* extended header */
931 offset
= GET_HDR_OFFSET_2_0(efuseHeader
);
932 /* DBG_8192C("%s: extended header offset = 0x%X\n", __func__, offset); */
934 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseExtHdr
, bPseudoTest
);
935 /* DBG_8192C("%s: efuse[0x%X]= 0x%02X\n", __func__, eFuse_Addr-1, efuseExtHdr); */
936 if (ALL_WORDS_DISABLED(efuseExtHdr
))
939 offset
|= ((efuseExtHdr
& 0xF0) >> 1);
940 wden
= (efuseExtHdr
& 0x0F);
942 offset
= ((efuseHeader
>> 4) & 0x0f);
943 wden
= (efuseHeader
& 0x0f);
945 /* DBG_8192C("%s: Offset =%d Worden = 0x%X\n", __func__, offset, wden); */
947 if (offset
< EFUSE_MAX_SECTION_8723B
) {
949 /* Get word enable value from PG header */
950 /* DBG_8192C("%s: Offset =%d Worden = 0x%X\n", __func__, offset, wden); */
952 addr
= offset
* PGPKT_DATA_SIZE
;
953 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
954 /* Check word enable condition in the section */
955 if (!(wden
& (0x01<<i
))) {
956 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseData
, bPseudoTest
);
957 /* DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__, eFuse_Addr-1, efuseData); */
958 efuseTbl
[addr
] = efuseData
;
960 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseData
, bPseudoTest
);
961 /* DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__, eFuse_Addr-1, efuseData); */
962 efuseTbl
[addr
+1] = efuseData
;
967 DBG_8192C(KERN_ERR
"%s: offset(%d) is illegal!!\n", __func__
, offset
);
968 eFuse_Addr
+= Efuse_CalculateWordCnts(wden
)*2;
972 /* Copy from Efuse map to output pointer memory!!! */
973 for (i
= 0; i
< _size_byte
; i
++)
974 pbuf
[i
] = efuseTbl
[_offset
+i
];
978 DBG_871X("Efuse Realmap:\n");
979 for (i
= 0; i
< _size_byte
; i
++) {
982 printk("%02X ", pbuf
[i
]);
987 /* Calculate Efuse utilization */
988 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, &total
, bPseudoTest
);
989 used
= eFuse_Addr
- 1;
990 efuse_usage
= (u8
)((used
*100)/total
);
992 #ifdef HAL_EFUSE_MEMORY
993 pEfuseHal
->fakeEfuseUsedBytes
= used
;
995 fakeEfuseUsedBytes
= used
;
998 rtw_hal_set_hwreg(padapter
, HW_VAR_EFUSE_BYTES
, (u8
*)&used
);
999 rtw_hal_set_hwreg(padapter
, HW_VAR_EFUSE_USAGE
, (u8
*)&efuse_usage
);
1005 static void hal_ReadEFuse_BT(
1006 struct adapter
*padapter
,
1013 #ifdef HAL_EFUSE_MEMORY
1014 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
1015 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
1020 u8 efuseHeader
, efuseExtHdr
, efuseData
;
1027 /* Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10. */
1029 if ((_offset
+_size_byte
) > EFUSE_BT_MAP_LEN
) {
1030 DBG_8192C("%s: Invalid offset(%#x) with read bytes(%#x)!!\n", __func__
, _offset
, _size_byte
);
1034 efuseTbl
= rtw_malloc(EFUSE_BT_MAP_LEN
);
1035 if (efuseTbl
== NULL
) {
1036 DBG_8192C("%s: efuseTbl malloc fail!\n", __func__
);
1039 /* 0xff will be efuse default value instead of 0x00. */
1040 memset(efuseTbl
, 0xFF, EFUSE_BT_MAP_LEN
);
1042 EFUSE_GetEfuseDefinition(padapter
, EFUSE_BT
, TYPE_AVAILABLE_EFUSE_BYTES_BANK
, &total
, bPseudoTest
);
1044 for (bank
= 1; bank
< 3; bank
++) { /* 8723b Max bake 0~2 */
1045 if (hal_EfuseSwitchToBank(padapter
, bank
, bPseudoTest
) == false) {
1046 DBG_8192C("%s: hal_EfuseSwitchToBank Fail!!\n", __func__
);
1052 while (AVAILABLE_EFUSE_ADDR(eFuse_Addr
)) {
1053 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseHeader
, bPseudoTest
);
1054 if (efuseHeader
== 0xFF)
1056 DBG_8192C("%s: efuse[%#X]= 0x%02x (header)\n", __func__
, (((bank
-1)*EFUSE_REAL_CONTENT_LEN_8723B
)+eFuse_Addr
-1), efuseHeader
);
1058 /* Check PG header for section num. */
1059 if (EXT_HEADER(efuseHeader
)) { /* extended header */
1060 offset
= GET_HDR_OFFSET_2_0(efuseHeader
);
1061 DBG_8192C("%s: extended header offset_2_0 = 0x%X\n", __func__
, offset
);
1063 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseExtHdr
, bPseudoTest
);
1064 DBG_8192C("%s: efuse[%#X]= 0x%02x (ext header)\n", __func__
, (((bank
-1)*EFUSE_REAL_CONTENT_LEN_8723B
)+eFuse_Addr
-1), efuseExtHdr
);
1065 if (ALL_WORDS_DISABLED(efuseExtHdr
))
1069 offset
|= ((efuseExtHdr
& 0xF0) >> 1);
1070 wden
= (efuseExtHdr
& 0x0F);
1072 offset
= ((efuseHeader
>> 4) & 0x0f);
1073 wden
= (efuseHeader
& 0x0f);
1076 if (offset
< EFUSE_BT_MAX_SECTION
) {
1079 /* Get word enable value from PG header */
1080 DBG_8192C("%s: Offset =%d Worden =%#X\n", __func__
, offset
, wden
);
1082 addr
= offset
* PGPKT_DATA_SIZE
;
1083 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
1084 /* Check word enable condition in the section */
1085 if (!(wden
& (0x01<<i
))) {
1086 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseData
, bPseudoTest
);
1087 DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__
, eFuse_Addr
-1, efuseData
);
1088 efuseTbl
[addr
] = efuseData
;
1090 efuse_OneByteRead(padapter
, eFuse_Addr
++, &efuseData
, bPseudoTest
);
1091 DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__
, eFuse_Addr
-1, efuseData
);
1092 efuseTbl
[addr
+1] = efuseData
;
1097 DBG_8192C("%s: offset(%d) is illegal!!\n", __func__
, offset
);
1098 eFuse_Addr
+= Efuse_CalculateWordCnts(wden
)*2;
1102 if ((eFuse_Addr
-1) < total
) {
1103 DBG_8192C("%s: bank(%d) data end at %#x\n", __func__
, bank
, eFuse_Addr
-1);
1108 /* switch bank back to bank 0 for later BT and wifi use. */
1109 hal_EfuseSwitchToBank(padapter
, 0, bPseudoTest
);
1111 /* Copy from Efuse map to output pointer memory!!! */
1112 for (i
= 0; i
< _size_byte
; i
++)
1113 pbuf
[i
] = efuseTbl
[_offset
+i
];
1116 /* Calculate Efuse utilization. */
1118 EFUSE_GetEfuseDefinition(padapter
, EFUSE_BT
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, &total
, bPseudoTest
);
1119 used
= (EFUSE_BT_REAL_BANK_CONTENT_LEN
*(bank
-1)) + eFuse_Addr
- 1;
1120 DBG_8192C("%s: bank(%d) data end at %#x , used =%d\n", __func__
, bank
, eFuse_Addr
-1, used
);
1121 efuse_usage
= (u8
)((used
*100)/total
);
1123 #ifdef HAL_EFUSE_MEMORY
1124 pEfuseHal
->fakeBTEfuseUsedBytes
= used
;
1126 fakeBTEfuseUsedBytes
= used
;
1129 rtw_hal_set_hwreg(padapter
, HW_VAR_EFUSE_BT_BYTES
, (u8
*)&used
);
1130 rtw_hal_set_hwreg(padapter
, HW_VAR_EFUSE_BT_USAGE
, (u8
*)&efuse_usage
);
1137 static void Hal_ReadEFuse(
1138 struct adapter
*padapter
,
1146 if (efuseType
== EFUSE_WIFI
)
1147 hal_ReadEFuse_WiFi(padapter
, _offset
, _size_byte
, pbuf
, bPseudoTest
);
1149 hal_ReadEFuse_BT(padapter
, _offset
, _size_byte
, pbuf
, bPseudoTest
);
1152 static u16
hal_EfuseGetCurrentSize_WiFi(
1153 struct adapter
*padapter
, bool bPseudoTest
1156 #ifdef HAL_EFUSE_MEMORY
1157 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
1158 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
1161 u16 start_addr
= 0; /* for debug */
1162 u8 hoffset
= 0, hworden
= 0;
1163 u8 efuse_data
, word_cnts
= 0;
1164 u32 count
= 0; /* for debug */
1168 #ifdef HAL_EFUSE_MEMORY
1169 efuse_addr
= (u16
)pEfuseHal
->fakeEfuseUsedBytes
;
1171 efuse_addr
= (u16
)fakeEfuseUsedBytes
;
1174 rtw_hal_get_hwreg(padapter
, HW_VAR_EFUSE_BYTES
, (u8
*)&efuse_addr
);
1176 start_addr
= efuse_addr
;
1177 DBG_8192C("%s: start_efuse_addr = 0x%X\n", __func__
, efuse_addr
);
1179 /* switch bank back to bank 0 for later BT and wifi use. */
1180 hal_EfuseSwitchToBank(padapter
, 0, bPseudoTest
);
1183 while (AVAILABLE_EFUSE_ADDR(efuse_addr
)) {
1184 if (efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
) == false) {
1185 DBG_8192C(KERN_ERR
"%s: efuse_OneByteRead Fail! addr = 0x%X !!\n", __func__
, efuse_addr
);
1189 if (efuse_data
== 0xFF)
1192 if ((start_addr
!= 0) && (efuse_addr
== start_addr
)) {
1194 DBG_8192C(FUNC_ADPT_FMT
": [WARNING] efuse raw 0x%X = 0x%02X not 0xFF!!(%d times)\n",
1195 FUNC_ADPT_ARG(padapter
), efuse_addr
, efuse_data
, count
);
1202 /* try again form address 0 */
1213 if (EXT_HEADER(efuse_data
)) {
1214 hoffset
= GET_HDR_OFFSET_2_0(efuse_data
);
1216 efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
);
1217 if (ALL_WORDS_DISABLED(efuse_data
))
1220 hoffset
|= ((efuse_data
& 0xF0) >> 1);
1221 hworden
= efuse_data
& 0x0F;
1223 hoffset
= (efuse_data
>>4) & 0x0F;
1224 hworden
= efuse_data
& 0x0F;
1227 word_cnts
= Efuse_CalculateWordCnts(hworden
);
1228 efuse_addr
+= (word_cnts
*2)+1;
1232 #ifdef HAL_EFUSE_MEMORY
1233 pEfuseHal
->fakeEfuseUsedBytes
= efuse_addr
;
1235 fakeEfuseUsedBytes
= efuse_addr
;
1238 rtw_hal_set_hwreg(padapter
, HW_VAR_EFUSE_BYTES
, (u8
*)&efuse_addr
);
1243 /* report max size to prevent wirte efuse */
1244 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, &efuse_addr
, bPseudoTest
);
1247 DBG_8192C("%s: CurrentSize =%d\n", __func__
, efuse_addr
);
1252 static u16
hal_EfuseGetCurrentSize_BT(struct adapter
*padapter
, u8 bPseudoTest
)
1254 #ifdef HAL_EFUSE_MEMORY
1255 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
1256 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
1261 u8 hoffset
= 0, hworden
= 0;
1262 u8 efuse_data
, word_cnts
= 0;
1266 #ifdef HAL_EFUSE_MEMORY
1267 btusedbytes
= pEfuseHal
->fakeBTEfuseUsedBytes
;
1269 btusedbytes
= fakeBTEfuseUsedBytes
;
1272 rtw_hal_get_hwreg(padapter
, HW_VAR_EFUSE_BT_BYTES
, (u8
*)&btusedbytes
);
1274 efuse_addr
= (u16
)((btusedbytes
%EFUSE_BT_REAL_BANK_CONTENT_LEN
));
1275 startBank
= (u8
)(1+(btusedbytes
/EFUSE_BT_REAL_BANK_CONTENT_LEN
));
1277 DBG_8192C("%s: start from bank =%d addr = 0x%X\n", __func__
, startBank
, efuse_addr
);
1279 EFUSE_GetEfuseDefinition(padapter
, EFUSE_BT
, TYPE_AVAILABLE_EFUSE_BYTES_BANK
, &retU2
, bPseudoTest
);
1281 for (bank
= startBank
; bank
< 3; bank
++) {
1282 if (hal_EfuseSwitchToBank(padapter
, bank
, bPseudoTest
) == false) {
1283 DBG_8192C(KERN_ERR
"%s: switch bank(%d) Fail!!\n", __func__
, bank
);
1284 /* bank = EFUSE_MAX_BANK; */
1288 /* only when bank is switched we have to reset the efuse_addr. */
1289 if (bank
!= startBank
)
1293 while (AVAILABLE_EFUSE_ADDR(efuse_addr
)) {
1294 if (efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
) == false) {
1295 DBG_8192C(KERN_ERR
"%s: efuse_OneByteRead Fail! addr = 0x%X !!\n", __func__
, efuse_addr
);
1296 /* bank = EFUSE_MAX_BANK; */
1299 DBG_8192C("%s: efuse_OneByteRead ! addr = 0x%X !efuse_data = 0x%X! bank =%d\n", __func__
, efuse_addr
, efuse_data
, bank
);
1301 if (efuse_data
== 0xFF)
1304 if (EXT_HEADER(efuse_data
)) {
1305 hoffset
= GET_HDR_OFFSET_2_0(efuse_data
);
1307 efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
);
1308 DBG_8192C("%s: efuse_OneByteRead EXT_HEADER ! addr = 0x%X !efuse_data = 0x%X! bank =%d\n", __func__
, efuse_addr
, efuse_data
, bank
);
1310 if (ALL_WORDS_DISABLED(efuse_data
)) {
1315 /* hoffset = ((hoffset & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1); */
1316 hoffset
|= ((efuse_data
& 0xF0) >> 1);
1317 hworden
= efuse_data
& 0x0F;
1319 hoffset
= (efuse_data
>>4) & 0x0F;
1320 hworden
= efuse_data
& 0x0F;
1323 DBG_8192C(FUNC_ADPT_FMT
": Offset =%d Worden =%#X\n",
1324 FUNC_ADPT_ARG(padapter
), hoffset
, hworden
);
1326 word_cnts
= Efuse_CalculateWordCnts(hworden
);
1327 /* read next header */
1328 efuse_addr
+= (word_cnts
*2)+1;
1333 efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
) &&
1334 AVAILABLE_EFUSE_ADDR(efuse_addr
)
1336 if (efuse_data
!= 0xFF) {
1337 if ((efuse_data
&0x1F) == 0x0F) { /* extended header */
1338 hoffset
= efuse_data
;
1340 efuse_OneByteRead(padapter
, efuse_addr
, &efuse_data
, bPseudoTest
);
1341 if ((efuse_data
& 0x0F) == 0x0F) {
1345 hoffset
= ((hoffset
& 0xE0) >> 5) | ((efuse_data
& 0xF0) >> 1);
1346 hworden
= efuse_data
& 0x0F;
1349 hoffset
= (efuse_data
>>4) & 0x0F;
1350 hworden
= efuse_data
& 0x0F;
1352 word_cnts
= Efuse_CalculateWordCnts(hworden
);
1353 /* read next header */
1354 efuse_addr
= efuse_addr
+ (word_cnts
*2)+1;
1361 /* Check if we need to check next bank efuse */
1362 if (efuse_addr
< retU2
)
1363 break; /* don't need to check next bank. */
1366 retU2
= ((bank
-1)*EFUSE_BT_REAL_BANK_CONTENT_LEN
)+efuse_addr
;
1368 pEfuseHal
->fakeBTEfuseUsedBytes
= retU2
;
1369 /* RT_DISP(FEEPROM, EFUSE_PG, ("Hal_EfuseGetCurrentSize_BT92C(), already use %u bytes\n", pEfuseHal->fakeBTEfuseUsedBytes)); */
1371 pEfuseHal
->BTEfuseUsedBytes
= retU2
;
1372 /* RT_DISP(FEEPROM, EFUSE_PG, ("Hal_EfuseGetCurrentSize_BT92C(), already use %u bytes\n", pEfuseHal->BTEfuseUsedBytes)); */
1375 DBG_8192C("%s: CurrentSize =%d\n", __func__
, retU2
);
1379 static u16
Hal_EfuseGetCurrentSize(
1380 struct adapter
*padapter
, u8 efuseType
, bool bPseudoTest
1385 if (efuseType
== EFUSE_WIFI
)
1386 ret
= hal_EfuseGetCurrentSize_WiFi(padapter
, bPseudoTest
);
1388 ret
= hal_EfuseGetCurrentSize_BT(padapter
, bPseudoTest
);
1393 static u8
Hal_EfuseWordEnableDataWrite(
1394 struct adapter
*padapter
,
1402 u16 start_addr
= efuse_addr
;
1403 u8 badworden
= 0x0F;
1404 u8 tmpdata
[PGPKT_DATA_SIZE
];
1407 /* DBG_8192C("%s: efuse_addr =%#x word_en =%#x\n", __func__, efuse_addr, word_en); */
1408 memset(tmpdata
, 0xFF, PGPKT_DATA_SIZE
);
1410 if (!(word_en
& BIT(0))) {
1411 tmpaddr
= start_addr
;
1412 efuse_OneByteWrite(padapter
, start_addr
++, data
[0], bPseudoTest
);
1413 efuse_OneByteWrite(padapter
, start_addr
++, data
[1], bPseudoTest
);
1415 efuse_OneByteRead(padapter
, tmpaddr
, &tmpdata
[0], bPseudoTest
);
1416 efuse_OneByteRead(padapter
, tmpaddr
+1, &tmpdata
[1], bPseudoTest
);
1417 if ((data
[0] != tmpdata
[0]) || (data
[1] != tmpdata
[1])) {
1418 badworden
&= (~BIT(0));
1421 if (!(word_en
& BIT(1))) {
1422 tmpaddr
= start_addr
;
1423 efuse_OneByteWrite(padapter
, start_addr
++, data
[2], bPseudoTest
);
1424 efuse_OneByteWrite(padapter
, start_addr
++, data
[3], bPseudoTest
);
1426 efuse_OneByteRead(padapter
, tmpaddr
, &tmpdata
[2], bPseudoTest
);
1427 efuse_OneByteRead(padapter
, tmpaddr
+1, &tmpdata
[3], bPseudoTest
);
1428 if ((data
[2] != tmpdata
[2]) || (data
[3] != tmpdata
[3])) {
1429 badworden
&= (~BIT(1));
1433 if (!(word_en
& BIT(2))) {
1434 tmpaddr
= start_addr
;
1435 efuse_OneByteWrite(padapter
, start_addr
++, data
[4], bPseudoTest
);
1436 efuse_OneByteWrite(padapter
, start_addr
++, data
[5], bPseudoTest
);
1438 efuse_OneByteRead(padapter
, tmpaddr
, &tmpdata
[4], bPseudoTest
);
1439 efuse_OneByteRead(padapter
, tmpaddr
+1, &tmpdata
[5], bPseudoTest
);
1440 if ((data
[4] != tmpdata
[4]) || (data
[5] != tmpdata
[5])) {
1441 badworden
&= (~BIT(2));
1445 if (!(word_en
& BIT(3))) {
1446 tmpaddr
= start_addr
;
1447 efuse_OneByteWrite(padapter
, start_addr
++, data
[6], bPseudoTest
);
1448 efuse_OneByteWrite(padapter
, start_addr
++, data
[7], bPseudoTest
);
1450 efuse_OneByteRead(padapter
, tmpaddr
, &tmpdata
[6], bPseudoTest
);
1451 efuse_OneByteRead(padapter
, tmpaddr
+1, &tmpdata
[7], bPseudoTest
);
1452 if ((data
[6] != tmpdata
[6]) || (data
[7] != tmpdata
[7])) {
1453 badworden
&= (~BIT(3));
1460 static s32
Hal_EfusePgPacketRead(
1461 struct adapter
*padapter
,
1467 u8 efuse_data
, word_cnts
= 0;
1469 u8 hoffset
= 0, hworden
= 0;
1478 EFUSE_GetEfuseDefinition(padapter
, EFUSE_WIFI
, TYPE_EFUSE_MAX_SECTION
, &max_section
, bPseudoTest
);
1479 if (offset
> max_section
) {
1480 DBG_8192C("%s: Packet offset(%d) is illegal(>%d)!\n", __func__
, offset
, max_section
);
1484 memset(data
, 0xFF, PGPKT_DATA_SIZE
);
1488 /* <Roger_TODO> Efuse has been pre-programmed dummy 5Bytes at the end of Efuse by CP. */
1489 /* Skip dummy parts to prevent unexpected data read from Efuse. */
1490 /* By pass right now. 2009.02.19. */
1492 while (AVAILABLE_EFUSE_ADDR(efuse_addr
)) {
1493 if (efuse_OneByteRead(padapter
, efuse_addr
++, &efuse_data
, bPseudoTest
) == false) {
1498 if (efuse_data
== 0xFF)
1501 if (EXT_HEADER(efuse_data
)) {
1502 hoffset
= GET_HDR_OFFSET_2_0(efuse_data
);
1503 efuse_OneByteRead(padapter
, efuse_addr
++, &efuse_data
, bPseudoTest
);
1504 if (ALL_WORDS_DISABLED(efuse_data
)) {
1505 DBG_8192C("%s: Error!! All words disabled!\n", __func__
);
1509 hoffset
|= ((efuse_data
& 0xF0) >> 1);
1510 hworden
= efuse_data
& 0x0F;
1512 hoffset
= (efuse_data
>>4) & 0x0F;
1513 hworden
= efuse_data
& 0x0F;
1516 if (hoffset
== offset
) {
1517 for (i
= 0; i
< EFUSE_MAX_WORD_UNIT
; i
++) {
1518 /* Check word enable condition in the section */
1519 if (!(hworden
& (0x01<<i
))) {
1520 efuse_OneByteRead(padapter
, efuse_addr
++, &efuse_data
, bPseudoTest
);
1521 /* DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__, efuse_addr+tmpidx, efuse_data); */
1522 data
[i
*2] = efuse_data
;
1524 efuse_OneByteRead(padapter
, efuse_addr
++, &efuse_data
, bPseudoTest
);
1525 /* DBG_8192C("%s: efuse[%#X]= 0x%02X\n", __func__, efuse_addr+tmpidx, efuse_data); */
1526 data
[(i
*2)+1] = efuse_data
;
1530 word_cnts
= Efuse_CalculateWordCnts(hworden
);
1531 efuse_addr
+= word_cnts
*2;
1538 static u8
hal_EfusePgCheckAvailableAddr(
1539 struct adapter
*padapter
, u8 efuseType
, u8 bPseudoTest
1542 u16 max_available
= 0;
1546 EFUSE_GetEfuseDefinition(padapter
, efuseType
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, &max_available
, bPseudoTest
);
1547 /* DBG_8192C("%s: max_available =%d\n", __func__, max_available); */
1549 current_size
= Efuse_GetCurrentSize(padapter
, efuseType
, bPseudoTest
);
1550 if (current_size
>= max_available
) {
1551 DBG_8192C("%s: Error!! current_size(%d)>max_available(%d)\n", __func__
, current_size
, max_available
);
1557 static void hal_EfuseConstructPGPkt(
1561 PPGPKT_STRUCT pTargetPkt
1564 memset(pTargetPkt
->data
, 0xFF, PGPKT_DATA_SIZE
);
1565 pTargetPkt
->offset
= offset
;
1566 pTargetPkt
->word_en
= word_en
;
1567 efuse_WordEnableDataRead(word_en
, pData
, pTargetPkt
->data
);
1568 pTargetPkt
->word_cnts
= Efuse_CalculateWordCnts(pTargetPkt
->word_en
);
1571 static u8
hal_EfusePartialWriteCheck(
1572 struct adapter
*padapter
,
1575 PPGPKT_STRUCT pTargetPkt
,
1579 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
1580 PEFUSE_HAL pEfuseHal
= &pHalData
->EfuseHal
;
1582 u16 startAddr
= 0, efuse_max_available_len
= 0, efuse_max
= 0;
1585 EFUSE_GetEfuseDefinition(padapter
, efuseType
, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL
, &efuse_max_available_len
, bPseudoTest
);
1586 EFUSE_GetEfuseDefinition(padapter
, efuseType
, TYPE_EFUSE_CONTENT_LEN_BANK
, &efuse_max
, bPseudoTest
);
1588 if (efuseType
== EFUSE_WIFI
) {
1590 #ifdef HAL_EFUSE_MEMORY
1591 startAddr
= (u16
)pEfuseHal
->fakeEfuseUsedBytes
;
1593 startAddr
= (u16
)fakeEfuseUsedBytes
;
1596 rtw_hal_get_hwreg(padapter
, HW_VAR_EFUSE_BYTES
, (u8
*)&startAddr
);
1599 #ifdef HAL_EFUSE_MEMORY
1600 startAddr
= (u16
)pEfuseHal
->fakeBTEfuseUsedBytes
;
1602 startAddr
= (u16
)fakeBTEfuseUsedBytes
;
1605 rtw_hal_get_hwreg(padapter
, HW_VAR_EFUSE_BT_BYTES
, (u8
*)&startAddr
);
1607 startAddr
%= efuse_max
;
1608 DBG_8192C("%s: startAddr =%#X\n", __func__
, startAddr
);
1611 if (startAddr
>= efuse_max_available_len
) {
1613 DBG_8192C("%s: startAddr(%d) >= efuse_max_available_len(%d)\n", __func__
, startAddr
, efuse_max_available_len
);
1617 if (efuse_OneByteRead(padapter
, startAddr
, &efuse_data
, bPseudoTest
) && (efuse_data
!= 0xFF)) {
1620 DBG_8192C("%s: Something Wrong! last bytes(%#X = 0x%02X) is not 0xFF\n",
1621 __func__
, startAddr
, efuse_data
);
1624 if (EXT_HEADER(efuse_data
)) {
1625 cur_header
= efuse_data
;
1627 efuse_OneByteRead(padapter
, startAddr
, &efuse_data
, bPseudoTest
);
1628 if (ALL_WORDS_DISABLED(efuse_data
)) {
1629 DBG_8192C("%s: Error condition, all words disabled!", __func__
);
1633 curPkt
.offset
= ((cur_header
& 0xE0) >> 5) | ((efuse_data
& 0xF0) >> 1);
1634 curPkt
.word_en
= efuse_data
& 0x0F;
1637 cur_header
= efuse_data
;
1638 curPkt
.offset
= (cur_header
>>4) & 0x0F;
1639 curPkt
.word_en
= cur_header
& 0x0F;
1642 curPkt
.word_cnts
= Efuse_CalculateWordCnts(curPkt
.word_en
);
1643 /* if same header is found but no data followed */
1644 /* write some part of data followed by the header. */
1646 (curPkt
.offset
== pTargetPkt
->offset
) &&
1647 (hal_EfuseCheckIfDatafollowed(padapter
, curPkt
.word_cnts
, startAddr
+1, bPseudoTest
) == false) &&
1648 wordEnMatched(pTargetPkt
, &curPkt
, &matched_wden
) == true
1650 DBG_8192C("%s: Need to partial write data by the previous wrote header\n", __func__
);
1651 /* Here to write partial data */
1652 badworden
= Efuse_WordEnableDataWrite(padapter
, startAddr
+1, matched_wden
, pTargetPkt
->data
, bPseudoTest
);
1653 if (badworden
!= 0x0F) {
1654 u32 PgWriteSuccess
= 0;
1655 /* if write fail on some words, write these bad words again */
1656 if (efuseType
== EFUSE_WIFI
)
1657 PgWriteSuccess
= Efuse_PgPacketWrite(padapter
, pTargetPkt
->offset
, badworden
, pTargetPkt
->data
, bPseudoTest
);
1659 PgWriteSuccess
= Efuse_PgPacketWrite_BT(padapter
, pTargetPkt
->offset
, badworden
, pTargetPkt
->data
, bPseudoTest
);
1661 if (!PgWriteSuccess
) {
1662 bRet
= false; /* write fail, return */
1666 /* partial write ok, update the target packet for later use */
1667 for (i
= 0; i
< 4; i
++) {
1668 if ((matched_wden
& (0x1<<i
)) == 0) { /* this word has been written */
1669 pTargetPkt
->word_en
|= (0x1<<i
); /* disable the word */
1672 pTargetPkt
->word_cnts
= Efuse_CalculateWordCnts(pTargetPkt
->word_en
);
1674 /* read from next header */
1675 startAddr
= startAddr
+ (curPkt
.word_cnts
*2) + 1;
1678 /* not used header, 0xff */
1680 /* DBG_8192C("%s: Started from unused header offset =%d\n", __func__, startAddr)); */
1689 static u8
hal_EfusePgPacketWrite1ByteHeader(
1690 struct adapter
*padapter
,
1693 PPGPKT_STRUCT pTargetPkt
,
1697 u8 pg_header
= 0, tmp_header
= 0;
1698 u16 efuse_addr
= *pAddr
;
1702 /* DBG_8192C("%s\n", __func__); */
1703 pg_header
= ((pTargetPkt
->offset
<< 4) & 0xf0) | pTargetPkt
->word_en
;
1706 efuse_OneByteWrite(padapter
, efuse_addr
, pg_header
, bPseudoTest
);
1707 efuse_OneByteRead(padapter
, efuse_addr
, &tmp_header
, bPseudoTest
);
1708 if (tmp_header
!= 0xFF)
1710 if (repeatcnt
++ > EFUSE_REPEAT_THRESHOLD_
) {
1711 DBG_8192C("%s: Repeat over limit for pg_header!!\n", __func__
);
1716 if (tmp_header
!= pg_header
) {
1717 DBG_8192C(KERN_ERR
"%s: PG Header Fail!!(pg = 0x%02X read = 0x%02X)\n", __func__
, pg_header
, tmp_header
);
1721 *pAddr
= efuse_addr
;
1726 static u8
hal_EfusePgPacketWrite2ByteHeader(
1727 struct adapter
*padapter
,
1730 PPGPKT_STRUCT pTargetPkt
,
1734 u16 efuse_addr
, efuse_max_available_len
= 0;
1735 u8 pg_header
= 0, tmp_header
= 0;
1739 /* DBG_8192C("%s\n", __func__); */
1740 EFUSE_GetEfuseDefinition(padapter
, efuseType
, TYPE_AVAILABLE_EFUSE_BYTES_BANK
, &efuse_max_available_len
, bPseudoTest
);
1742 efuse_addr
= *pAddr
;
1743 if (efuse_addr
>= efuse_max_available_len
) {
1744 DBG_8192C("%s: addr(%d) over available (%d)!!\n", __func__
,
1745 efuse_addr
, efuse_max_available_len
);
1749 pg_header
= ((pTargetPkt
->offset
& 0x07) << 5) | 0x0F;
1750 /* DBG_8192C("%s: pg_header = 0x%x\n", __func__, pg_header); */
1753 efuse_OneByteWrite(padapter
, efuse_addr
, pg_header
, bPseudoTest
);
1754 efuse_OneByteRead(padapter
, efuse_addr
, &tmp_header
, bPseudoTest
);
1755 if (tmp_header
!= 0xFF)
1757 if (repeatcnt
++ > EFUSE_REPEAT_THRESHOLD_
) {
1758 DBG_8192C("%s: Repeat over limit for pg_header!!\n", __func__
);
1763 if (tmp_header
!= pg_header
) {
1764 DBG_8192C(KERN_ERR
"%s: PG Header Fail!!(pg = 0x%02X read = 0x%02X)\n", __func__
, pg_header
, tmp_header
);
1768 /* to write ext_header */
1770 pg_header
= ((pTargetPkt
->offset
& 0x78) << 1) | pTargetPkt
->word_en
;
1773 efuse_OneByteWrite(padapter
, efuse_addr
, pg_header
, bPseudoTest
);
1774 efuse_OneByteRead(padapter
, efuse_addr
, &tmp_header
, bPseudoTest
);
1775 if (tmp_header
!= 0xFF)
1777 if (repeatcnt
++ > EFUSE_REPEAT_THRESHOLD_
) {
1778 DBG_8192C("%s: Repeat over limit for ext_header!!\n", __func__
);
1783 if (tmp_header
!= pg_header
) { /* offset PG fail */
1784 DBG_8192C(KERN_ERR
"%s: PG EXT Header Fail!!(pg = 0x%02X read = 0x%02X)\n", __func__
, pg_header
, tmp_header
);
1788 *pAddr
= efuse_addr
;
1793 static u8
hal_EfusePgPacketWriteHeader(
1794 struct adapter
*padapter
,
1797 PPGPKT_STRUCT pTargetPkt
,
1803 if (pTargetPkt
->offset
>= EFUSE_MAX_SECTION_BASE
)
1804 bRet
= hal_EfusePgPacketWrite2ByteHeader(padapter
, efuseType
, pAddr
, pTargetPkt
, bPseudoTest
);
1806 bRet
= hal_EfusePgPacketWrite1ByteHeader(padapter
, efuseType
, pAddr
, pTargetPkt
, bPseudoTest
);
1811 static u8
hal_EfusePgPacketWriteData(
1812 struct adapter
*padapter
,
1815 PPGPKT_STRUCT pTargetPkt
,
1823 efuse_addr
= *pAddr
;
1824 badworden
= Efuse_WordEnableDataWrite(padapter
, efuse_addr
+1, pTargetPkt
->word_en
, pTargetPkt
->data
, bPseudoTest
);
1825 if (badworden
!= 0x0F) {
1826 DBG_8192C("%s: Fail!!\n", __func__
);
1830 /* DBG_8192C("%s: ok\n", __func__); */
1834 static s32
Hal_EfusePgPacketWrite(
1835 struct adapter
*padapter
,
1842 PGPKT_STRUCT targetPkt
;
1844 u8 efuseType
= EFUSE_WIFI
;
1846 if (!hal_EfusePgCheckAvailableAddr(padapter
, efuseType
, bPseudoTest
))
1849 hal_EfuseConstructPGPkt(offset
, word_en
, pData
, &targetPkt
);
1851 if (!hal_EfusePartialWriteCheck(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1854 if (!hal_EfusePgPacketWriteHeader(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1857 if (!hal_EfusePgPacketWriteData(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1863 static bool Hal_EfusePgPacketWrite_BT(
1864 struct adapter
*padapter
,
1871 PGPKT_STRUCT targetPkt
;
1873 u8 efuseType
= EFUSE_BT
;
1875 if (!hal_EfusePgCheckAvailableAddr(padapter
, efuseType
, bPseudoTest
))
1878 hal_EfuseConstructPGPkt(offset
, word_en
, pData
, &targetPkt
);
1880 if (!hal_EfusePartialWriteCheck(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1883 if (!hal_EfusePgPacketWriteHeader(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1886 if (!hal_EfusePgPacketWriteData(padapter
, efuseType
, &startAddr
, &targetPkt
, bPseudoTest
))
1892 static HAL_VERSION
ReadChipVersion8723B(struct adapter
*padapter
)
1895 HAL_VERSION ChipVersion
;
1896 struct hal_com_data
*pHalData
;
1898 /* YJ, TODO, move read chip type here */
1899 pHalData
= GET_HAL_DATA(padapter
);
1901 value32
= rtw_read32(padapter
, REG_SYS_CFG
);
1902 ChipVersion
.ICType
= CHIP_8723B
;
1903 ChipVersion
.ChipType
= ((value32
& RTL_ID
) ? TEST_CHIP
: NORMAL_CHIP
);
1904 ChipVersion
.RFType
= RF_TYPE_1T1R
;
1905 ChipVersion
.VendorType
= ((value32
& VENDOR_ID
) ? CHIP_VENDOR_UMC
: CHIP_VENDOR_TSMC
);
1906 ChipVersion
.CUTVersion
= (value32
& CHIP_VER_RTL_MASK
)>>CHIP_VER_RTL_SHIFT
; /* IC version (CUT) */
1908 /* For regulator mode. by tynli. 2011.01.14 */
1909 pHalData
->RegulatorMode
= ((value32
& SPS_SEL
) ? RT_LDO_REGULATOR
: RT_SWITCHING_REGULATOR
);
1911 value32
= rtw_read32(padapter
, REG_GPIO_OUTSTS
);
1912 ChipVersion
.ROMVer
= ((value32
& RF_RL_ID
) >> 20); /* ROM code version. */
1914 /* For multi-function consideration. Added by Roger, 2010.10.06. */
1915 pHalData
->MultiFunc
= RT_MULTI_FUNC_NONE
;
1916 value32
= rtw_read32(padapter
, REG_MULTI_FUNC_CTRL
);
1917 pHalData
->MultiFunc
|= ((value32
& WL_FUNC_EN
) ? RT_MULTI_FUNC_WIFI
: 0);
1918 pHalData
->MultiFunc
|= ((value32
& BT_FUNC_EN
) ? RT_MULTI_FUNC_BT
: 0);
1919 pHalData
->MultiFunc
|= ((value32
& GPS_FUNC_EN
) ? RT_MULTI_FUNC_GPS
: 0);
1920 pHalData
->PolarityCtl
= ((value32
& WL_HWPDN_SL
) ? RT_POLARITY_HIGH_ACT
: RT_POLARITY_LOW_ACT
);
1922 dump_chip_info(ChipVersion
);
1924 pHalData
->VersionID
= ChipVersion
;
1925 if (IS_1T2R(ChipVersion
))
1926 pHalData
->rf_type
= RF_1T2R
;
1927 else if (IS_2T2R(ChipVersion
))
1928 pHalData
->rf_type
= RF_2T2R
;
1930 pHalData
->rf_type
= RF_1T1R
;
1932 MSG_8192C("RF_Type is %x!!\n", pHalData
->rf_type
);
1937 static void rtl8723b_read_chip_version(struct adapter
*padapter
)
1939 ReadChipVersion8723B(padapter
);
1942 void rtl8723b_InitBeaconParameters(struct adapter
*padapter
)
1944 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
1950 val16
= val8
| (val8
<< 8); /* port0 and port1 */
1952 /* Enable prot0 beacon function for PSTDMA */
1953 val16
|= EN_BCN_FUNCTION
;
1955 rtw_write16(padapter
, REG_BCN_CTRL
, val16
);
1957 /* TODO: Remove these magic number */
1958 rtw_write16(padapter
, REG_TBTT_PROHIBIT
, 0x6404);/* ms */
1959 /* Firmware will control REG_DRVERLYINT when power saving is enable, */
1960 /* so don't set this register on STA mode. */
1961 if (check_fwstate(&padapter
->mlmepriv
, WIFI_STATION_STATE
) == false)
1962 rtw_write8(padapter
, REG_DRVERLYINT
, DRIVER_EARLY_INT_TIME_8723B
); /* 5ms */
1963 rtw_write8(padapter
, REG_BCNDMATIM
, BCN_DMA_ATIME_INT_TIME_8723B
); /* 2ms */
1965 /* Suggested by designer timchen. Change beacon AIFS to the largest number */
1966 /* beacause test chip does not contension before sending beacon. by tynli. 2009.11.03 */
1967 rtw_write16(padapter
, REG_BCNTCFG
, 0x660F);
1969 pHalData
->RegBcnCtrlVal
= rtw_read8(padapter
, REG_BCN_CTRL
);
1970 pHalData
->RegTxPause
= rtw_read8(padapter
, REG_TXPAUSE
);
1971 pHalData
->RegFwHwTxQCtrl
= rtw_read8(padapter
, REG_FWHW_TXQ_CTRL
+2);
1972 pHalData
->RegReg542
= rtw_read8(padapter
, REG_TBTT_PROHIBIT
+2);
1973 pHalData
->RegCR_1
= rtw_read8(padapter
, REG_CR
+1);
1976 void _InitBurstPktLen_8723BS(struct adapter
*Adapter
)
1978 struct hal_com_data
*pHalData
= GET_HAL_DATA(Adapter
);
1980 rtw_write8(Adapter
, 0x4c7, rtw_read8(Adapter
, 0x4c7)|BIT(7)); /* enable single pkt ampdu */
1981 rtw_write8(Adapter
, REG_RX_PKT_LIMIT_8723B
, 0x18); /* for VHT packet length 11K */
1982 rtw_write8(Adapter
, REG_MAX_AGGR_NUM_8723B
, 0x1F);
1983 rtw_write8(Adapter
, REG_PIFS_8723B
, 0x00);
1984 rtw_write8(Adapter
, REG_FWHW_TXQ_CTRL_8723B
, rtw_read8(Adapter
, REG_FWHW_TXQ_CTRL
)&(~BIT(7)));
1985 if (pHalData
->AMPDUBurstMode
)
1986 rtw_write8(Adapter
, REG_AMPDU_BURST_MODE_8723B
, 0x5F);
1987 rtw_write8(Adapter
, REG_AMPDU_MAX_TIME_8723B
, 0x70);
1989 /* ARFB table 9 for 11ac 5G 2SS */
1990 rtw_write32(Adapter
, REG_ARFR0_8723B
, 0x00000010);
1991 if (IS_NORMAL_CHIP(pHalData
->VersionID
))
1992 rtw_write32(Adapter
, REG_ARFR0_8723B
+4, 0xfffff000);
1994 rtw_write32(Adapter
, REG_ARFR0_8723B
+4, 0x3e0ff000);
1996 /* ARFB table 10 for 11ac 5G 1SS */
1997 rtw_write32(Adapter
, REG_ARFR1_8723B
, 0x00000010);
1998 rtw_write32(Adapter
, REG_ARFR1_8723B
+4, 0x003ff000);
2001 static void ResumeTxBeacon(struct adapter
*padapter
)
2003 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2006 /* 2010.03.01. Marked by tynli. No need to call workitem beacause we record the value */
2007 /* which should be read from register to a global variable. */
2009 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("+ResumeTxBeacon\n"));
2011 pHalData
->RegFwHwTxQCtrl
|= BIT(6);
2012 rtw_write8(padapter
, REG_FWHW_TXQ_CTRL
+2, pHalData
->RegFwHwTxQCtrl
);
2013 rtw_write8(padapter
, REG_TBTT_PROHIBIT
+1, 0xff);
2014 pHalData
->RegReg542
|= BIT(0);
2015 rtw_write8(padapter
, REG_TBTT_PROHIBIT
+2, pHalData
->RegReg542
);
2018 static void StopTxBeacon(struct adapter
*padapter
)
2020 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2023 /* 2010.03.01. Marked by tynli. No need to call workitem beacause we record the value */
2024 /* which should be read from register to a global variable. */
2026 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("+StopTxBeacon\n"));
2028 pHalData
->RegFwHwTxQCtrl
&= ~BIT(6);
2029 rtw_write8(padapter
, REG_FWHW_TXQ_CTRL
+2, pHalData
->RegFwHwTxQCtrl
);
2030 rtw_write8(padapter
, REG_TBTT_PROHIBIT
+1, 0x64);
2031 pHalData
->RegReg542
&= ~BIT(0);
2032 rtw_write8(padapter
, REG_TBTT_PROHIBIT
+2, pHalData
->RegReg542
);
2034 CheckFwRsvdPageContent(padapter
); /* 2010.06.23. Added by tynli. */
2037 static void _BeaconFunctionEnable(struct adapter
*padapter
, u8 Enable
, u8 Linked
)
2039 rtw_write8(padapter
, REG_BCN_CTRL
, DIS_TSF_UDT
| EN_BCN_FUNCTION
| DIS_BCNQ_SUB
);
2040 rtw_write8(padapter
, REG_RD_CTRL
+1, 0x6F);
2043 static void rtl8723b_SetBeaconRelatedRegisters(struct adapter
*padapter
)
2047 struct mlme_ext_priv
*pmlmeext
= &padapter
->mlmeextpriv
;
2048 struct mlme_ext_info
*pmlmeinfo
= &pmlmeext
->mlmext_info
;
2051 /* reset TSF, enable update TSF, correcting TSF On Beacon */
2053 /* REG_BCN_INTERVAL */
2056 /* REG_TBTT_PROHIBIT */
2057 /* REG_DRVERLYINT */
2058 /* REG_BCN_MAX_ERR */
2059 /* REG_BCNTCFG (0x510) */
2060 /* REG_DUAL_TSF_RST */
2061 /* REG_BCN_CTRL (0x550) */
2064 bcn_ctrl_reg
= REG_BCN_CTRL
;
2069 rtw_write16(padapter
, REG_ATIMWND
, 2);
2072 /* Beacon interval (in unit of TU). */
2074 rtw_write16(padapter
, REG_BCN_INTERVAL
, pmlmeinfo
->bcn_interval
);
2076 rtl8723b_InitBeaconParameters(padapter
);
2078 rtw_write8(padapter
, REG_SLOT
, 0x09);
2081 /* Reset TSF Timer to zero, added by Roger. 2008.06.24 */
2083 value32
= rtw_read32(padapter
, REG_TCR
);
2085 rtw_write32(padapter
, REG_TCR
, value32
);
2088 rtw_write32(padapter
, REG_TCR
, value32
);
2090 /* NOTE: Fix test chip's bug (about contention windows's randomness) */
2091 if (check_fwstate(&padapter
->mlmepriv
, WIFI_ADHOC_STATE
|WIFI_ADHOC_MASTER_STATE
|WIFI_AP_STATE
) == true) {
2092 rtw_write8(padapter
, REG_RXTSF_OFFSET_CCK
, 0x50);
2093 rtw_write8(padapter
, REG_RXTSF_OFFSET_OFDM
, 0x50);
2096 _BeaconFunctionEnable(padapter
, true, true);
2098 ResumeTxBeacon(padapter
);
2099 val8
= rtw_read8(padapter
, bcn_ctrl_reg
);
2100 val8
|= DIS_BCNQ_SUB
;
2101 rtw_write8(padapter
, bcn_ctrl_reg
, val8
);
2104 static void rtl8723b_GetHalODMVar(
2105 struct adapter
*Adapter
,
2106 enum HAL_ODM_VARIABLE eVariable
,
2111 GetHalODMVar(Adapter
, eVariable
, pValue1
, pValue2
);
2114 static void rtl8723b_SetHalODMVar(
2115 struct adapter
*Adapter
,
2116 enum HAL_ODM_VARIABLE eVariable
,
2121 SetHalODMVar(Adapter
, eVariable
, pValue1
, bSet
);
2124 static void hal_notch_filter_8723b(struct adapter
*adapter
, bool enable
)
2127 DBG_871X("Enable notch filter\n");
2128 rtw_write8(adapter
, rOFDM0_RxDSP
+1, rtw_read8(adapter
, rOFDM0_RxDSP
+1) | BIT1
);
2130 DBG_871X("Disable notch filter\n");
2131 rtw_write8(adapter
, rOFDM0_RxDSP
+1, rtw_read8(adapter
, rOFDM0_RxDSP
+1) & ~BIT1
);
2135 static void UpdateHalRAMask8723B(struct adapter
*padapter
, u32 mac_id
, u8 rssi_level
)
2137 u32 mask
, rate_bitmap
;
2138 u8 shortGIrate
= false;
2139 struct sta_info
*psta
;
2140 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2141 struct dm_priv
*pdmpriv
= &pHalData
->dmpriv
;
2142 struct mlme_ext_priv
*pmlmeext
= &padapter
->mlmeextpriv
;
2143 struct mlme_ext_info
*pmlmeinfo
= &(pmlmeext
->mlmext_info
);
2145 DBG_871X("%s(): mac_id =%d rssi_level =%d\n", __func__
, mac_id
, rssi_level
);
2147 if (mac_id
>= NUM_STA
) /* CAM_SIZE */
2150 psta
= pmlmeinfo
->FW_sta_info
[mac_id
].psta
;
2154 shortGIrate
= query_ra_short_GI(psta
);
2156 mask
= psta
->ra_mask
;
2158 rate_bitmap
= 0xffffffff;
2159 rate_bitmap
= ODM_Get_Rate_Bitmap(&pHalData
->odmpriv
, mac_id
, mask
, rssi_level
);
2160 DBG_871X("%s => mac_id:%d, networkType:0x%02x, mask:0x%08x\n\t ==> rssi_level:%d, rate_bitmap:0x%08x\n",
2161 __func__
, mac_id
, psta
->wireless_mode
, mask
, rssi_level
, rate_bitmap
);
2163 mask
&= rate_bitmap
;
2165 rate_bitmap
= rtw_btcoex_GetRaMask(padapter
);
2166 mask
&= ~rate_bitmap
;
2168 #ifdef CONFIG_CMCC_TEST
2169 if (pmlmeext
->cur_wireless_mode
& WIRELESS_11G
) {
2171 DBG_871X("CMCC_BT update raid entry, mask = 0x%x\n", mask
);
2172 mask
&= 0xffffff00; /* disable CCK & <24M OFDM rate for 11G mode for CMCC */
2173 DBG_871X("CMCC_BT update raid entry, mask = 0x%x\n", mask
);
2178 if (pHalData
->fw_ractrl
== true) {
2179 rtl8723b_set_FwMacIdConfig_cmd(padapter
, mac_id
, psta
->raid
, psta
->bw_mode
, shortGIrate
, mask
);
2182 /* set correct initial date rate for each mac_id */
2183 pdmpriv
->INIDATA_RATE
[mac_id
] = psta
->init_rate
;
2184 DBG_871X("%s(): mac_id =%d raid = 0x%x bw =%d mask = 0x%x init_rate = 0x%x\n", __func__
, mac_id
, psta
->raid
, psta
->bw_mode
, mask
, psta
->init_rate
);
2188 void rtl8723b_set_hal_ops(struct hal_ops
*pHalFunc
)
2190 pHalFunc
->free_hal_data
= &rtl8723b_free_hal_data
;
2192 pHalFunc
->dm_init
= &rtl8723b_init_dm_priv
;
2194 pHalFunc
->read_chip_version
= &rtl8723b_read_chip_version
;
2196 pHalFunc
->UpdateRAMaskHandler
= &UpdateHalRAMask8723B
;
2198 pHalFunc
->set_bwmode_handler
= &PHY_SetBWMode8723B
;
2199 pHalFunc
->set_channel_handler
= &PHY_SwChnl8723B
;
2200 pHalFunc
->set_chnl_bw_handler
= &PHY_SetSwChnlBWMode8723B
;
2202 pHalFunc
->set_tx_power_level_handler
= &PHY_SetTxPowerLevel8723B
;
2203 pHalFunc
->get_tx_power_level_handler
= &PHY_GetTxPowerLevel8723B
;
2205 pHalFunc
->hal_dm_watchdog
= &rtl8723b_HalDmWatchDog
;
2206 pHalFunc
->hal_dm_watchdog_in_lps
= &rtl8723b_HalDmWatchDog_in_LPS
;
2209 pHalFunc
->SetBeaconRelatedRegistersHandler
= &rtl8723b_SetBeaconRelatedRegisters
;
2211 pHalFunc
->Add_RateATid
= &rtl8723b_Add_RateATid
;
2213 pHalFunc
->run_thread
= &rtl8723b_start_thread
;
2214 pHalFunc
->cancel_thread
= &rtl8723b_stop_thread
;
2216 pHalFunc
->read_bbreg
= &PHY_QueryBBReg_8723B
;
2217 pHalFunc
->write_bbreg
= &PHY_SetBBReg_8723B
;
2218 pHalFunc
->read_rfreg
= &PHY_QueryRFReg_8723B
;
2219 pHalFunc
->write_rfreg
= &PHY_SetRFReg_8723B
;
2221 /* Efuse related function */
2222 pHalFunc
->BTEfusePowerSwitch
= &Hal_BT_EfusePowerSwitch
;
2223 pHalFunc
->EfusePowerSwitch
= &Hal_EfusePowerSwitch
;
2224 pHalFunc
->ReadEFuse
= &Hal_ReadEFuse
;
2225 pHalFunc
->EFUSEGetEfuseDefinition
= &Hal_GetEfuseDefinition
;
2226 pHalFunc
->EfuseGetCurrentSize
= &Hal_EfuseGetCurrentSize
;
2227 pHalFunc
->Efuse_PgPacketRead
= &Hal_EfusePgPacketRead
;
2228 pHalFunc
->Efuse_PgPacketWrite
= &Hal_EfusePgPacketWrite
;
2229 pHalFunc
->Efuse_WordEnableDataWrite
= &Hal_EfuseWordEnableDataWrite
;
2230 pHalFunc
->Efuse_PgPacketWrite_BT
= &Hal_EfusePgPacketWrite_BT
;
2232 pHalFunc
->GetHalODMVarHandler
= &rtl8723b_GetHalODMVar
;
2233 pHalFunc
->SetHalODMVarHandler
= &rtl8723b_SetHalODMVar
;
2235 pHalFunc
->xmit_thread_handler
= &hal_xmit_handler
;
2236 pHalFunc
->hal_notch_filter
= &hal_notch_filter_8723b
;
2238 pHalFunc
->c2h_handler
= c2h_handler_8723b
;
2239 pHalFunc
->c2h_id_filter_ccx
= c2h_id_filter_ccx_8723b
;
2241 pHalFunc
->fill_h2c_cmd
= &FillH2CCmd8723B
;
2244 void rtl8723b_InitAntenna_Selection(struct adapter
*padapter
)
2246 struct hal_com_data
*pHalData
;
2250 pHalData
= GET_HAL_DATA(padapter
);
2252 val
= rtw_read8(padapter
, REG_LEDCFG2
);
2253 /* Let 8051 take control antenna settting */
2254 val
|= BIT(7); /* DPDT_SEL_EN, 0x4C[23] */
2255 rtw_write8(padapter
, REG_LEDCFG2
, val
);
2258 void rtl8723b_init_default_value(struct adapter
*padapter
)
2260 struct hal_com_data
*pHalData
;
2261 struct dm_priv
*pdmpriv
;
2265 pHalData
= GET_HAL_DATA(padapter
);
2266 pdmpriv
= &pHalData
->dmpriv
;
2268 padapter
->registrypriv
.wireless_mode
= WIRELESS_11BG_24N
;
2270 /* init default value */
2271 pHalData
->fw_ractrl
= false;
2272 pHalData
->bIQKInitialized
= false;
2273 if (!adapter_to_pwrctl(padapter
)->bkeepfwalive
)
2274 pHalData
->LastHMEBoxNum
= 0;
2276 pHalData
->bIQKInitialized
= false;
2278 /* init dm default value */
2279 pdmpriv
->TM_Trigger
= 0;/* for IQK */
2280 /* pdmpriv->binitialized = false; */
2281 /* pdmpriv->prv_traffic_idx = 3; */
2282 /* pdmpriv->initialize = 0; */
2284 pdmpriv
->ThermalValue_HP_index
= 0;
2285 for (i
= 0; i
< HP_THERMAL_NUM
; i
++)
2286 pdmpriv
->ThermalValue_HP
[i
] = 0;
2288 /* init Efuse variables */
2289 pHalData
->EfuseUsedBytes
= 0;
2290 pHalData
->EfuseUsedPercentage
= 0;
2291 #ifdef HAL_EFUSE_MEMORY
2292 pHalData
->EfuseHal
.fakeEfuseBank
= 0;
2293 pHalData
->EfuseHal
.fakeEfuseUsedBytes
= 0;
2294 memset(pHalData
->EfuseHal
.fakeEfuseContent
, 0xFF, EFUSE_MAX_HW_SIZE
);
2295 memset(pHalData
->EfuseHal
.fakeEfuseInitMap
, 0xFF, EFUSE_MAX_MAP_LEN
);
2296 memset(pHalData
->EfuseHal
.fakeEfuseModifiedMap
, 0xFF, EFUSE_MAX_MAP_LEN
);
2297 pHalData
->EfuseHal
.BTEfuseUsedBytes
= 0;
2298 pHalData
->EfuseHal
.BTEfuseUsedPercentage
= 0;
2299 memset(pHalData
->EfuseHal
.BTEfuseContent
, 0xFF, EFUSE_MAX_BT_BANK
*EFUSE_MAX_HW_SIZE
);
2300 memset(pHalData
->EfuseHal
.BTEfuseInitMap
, 0xFF, EFUSE_BT_MAX_MAP_LEN
);
2301 memset(pHalData
->EfuseHal
.BTEfuseModifiedMap
, 0xFF, EFUSE_BT_MAX_MAP_LEN
);
2302 pHalData
->EfuseHal
.fakeBTEfuseUsedBytes
= 0;
2303 memset(pHalData
->EfuseHal
.fakeBTEfuseContent
, 0xFF, EFUSE_MAX_BT_BANK
*EFUSE_MAX_HW_SIZE
);
2304 memset(pHalData
->EfuseHal
.fakeBTEfuseInitMap
, 0xFF, EFUSE_BT_MAX_MAP_LEN
);
2305 memset(pHalData
->EfuseHal
.fakeBTEfuseModifiedMap
, 0xFF, EFUSE_BT_MAX_MAP_LEN
);
2309 u8
GetEEPROMSize8723B(struct adapter
*padapter
)
2314 cr
= rtw_read16(padapter
, REG_9346CR
);
2315 /* 6: EEPROM used is 93C46, 4: boot from E-Fuse. */
2316 size
= (cr
& BOOT_FROM_EEPROM
) ? 6 : 4;
2318 MSG_8192C("EEPROM type is %s\n", size
== 4 ? "E-FUSE" : "93C46");
2325 /* LLT R/W/Init function */
2328 s32
rtl8723b_InitLLTTable(struct adapter
*padapter
)
2330 unsigned long start
, passing_time
;
2337 val32
= rtw_read32(padapter
, REG_AUTO_LLT
);
2338 val32
|= BIT_AUTO_INIT_LLT
;
2339 rtw_write32(padapter
, REG_AUTO_LLT
, val32
);
2344 val32
= rtw_read32(padapter
, REG_AUTO_LLT
);
2345 if (!(val32
& BIT_AUTO_INIT_LLT
)) {
2350 passing_time
= jiffies_to_msecs(jiffies
- start
);
2351 if (passing_time
> 1000) {
2353 "%s: FAIL!! REG_AUTO_LLT(0x%X) =%08x\n",
2367 static bool Hal_GetChnlGroup8723B(u8 Channel
, u8
*pGroup
)
2371 if (Channel
<= 14) {
2374 if (1 <= Channel
&& Channel
<= 2)
2376 else if (3 <= Channel
&& Channel
<= 5)
2378 else if (6 <= Channel
&& Channel
<= 8)
2380 else if (9 <= Channel
&& Channel
<= 11)
2382 else if (12 <= Channel
&& Channel
<= 14)
2385 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("==>Hal_GetChnlGroup8723B in 2.4 G, but Channel %d in Group not found\n", Channel
));
2390 if (36 <= Channel
&& Channel
<= 42)
2392 else if (44 <= Channel
&& Channel
<= 48)
2394 else if (50 <= Channel
&& Channel
<= 58)
2396 else if (60 <= Channel
&& Channel
<= 64)
2398 else if (100 <= Channel
&& Channel
<= 106)
2400 else if (108 <= Channel
&& Channel
<= 114)
2402 else if (116 <= Channel
&& Channel
<= 122)
2404 else if (124 <= Channel
&& Channel
<= 130)
2406 else if (132 <= Channel
&& Channel
<= 138)
2408 else if (140 <= Channel
&& Channel
<= 144)
2410 else if (149 <= Channel
&& Channel
<= 155)
2412 else if (157 <= Channel
&& Channel
<= 161)
2414 else if (165 <= Channel
&& Channel
<= 171)
2416 else if (173 <= Channel
&& Channel
<= 177)
2419 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("==>Hal_GetChnlGroup8723B in 5G, but Channel %d in Group not found\n", Channel
));
2424 _module_hci_hal_init_c_
,
2427 "<==Hal_GetChnlGroup8723B, (%s) Channel = %d, Group =%d,\n",
2428 bIn24G
? "2.4G" : "5G",
2436 void Hal_InitPGData(struct adapter
*padapter
, u8
*PROMContent
)
2438 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(padapter
);
2440 if (false == pEEPROM
->bautoload_fail_flag
) { /* autoload OK. */
2441 if (!pEEPROM
->EepromOrEfuse
) {
2442 /* Read EFUSE real map to shadow. */
2443 EFUSE_ShadowMapUpdate(padapter
, EFUSE_WIFI
, false);
2444 memcpy((void *)PROMContent
, (void *)pEEPROM
->efuse_eeprom_data
, HWSET_MAX_SIZE_8723B
);
2446 } else {/* autoload fail */
2447 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("AutoLoad Fail reported from CR9346!!\n"));
2448 if (false == pEEPROM
->EepromOrEfuse
)
2449 EFUSE_ShadowMapUpdate(padapter
, EFUSE_WIFI
, false);
2450 memcpy((void *)PROMContent
, (void *)pEEPROM
->efuse_eeprom_data
, HWSET_MAX_SIZE_8723B
);
2454 void Hal_EfuseParseIDCode(struct adapter
*padapter
, u8
*hwinfo
)
2456 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(padapter
);
2457 /* struct hal_com_data *pHalData = GET_HAL_DATA(padapter); */
2461 /* Checl 0x8129 again for making sure autoload status!! */
2462 EEPROMId
= le16_to_cpu(*((__le16
*)hwinfo
));
2463 if (EEPROMId
!= RTL_EEPROM_ID
) {
2464 DBG_8192C("EEPROM ID(%#x) is invalid!!\n", EEPROMId
);
2465 pEEPROM
->bautoload_fail_flag
= true;
2467 pEEPROM
->bautoload_fail_flag
= false;
2469 RT_TRACE(_module_hal_init_c_
, _drv_notice_
, ("EEPROM ID = 0x%04x\n", EEPROMId
));
2472 static void Hal_ReadPowerValueFromPROM_8723B(
2473 struct adapter
*Adapter
,
2474 struct TxPowerInfo24G
*pwrInfo24G
,
2479 struct hal_com_data
*pHalData
= GET_HAL_DATA(Adapter
);
2480 u32 rfPath
, eeAddr
= EEPROM_TX_PWR_INX_8723B
, group
, TxCount
= 0;
2482 memset(pwrInfo24G
, 0, sizeof(struct TxPowerInfo24G
));
2484 if (0xFF == PROMContent
[eeAddr
+1])
2485 AutoLoadFail
= true;
2488 DBG_871X("%s(): Use Default value!\n", __func__
);
2489 for (rfPath
= 0; rfPath
< MAX_RF_PATH
; rfPath
++) {
2490 /* 2.4G default value */
2491 for (group
= 0; group
< MAX_CHNL_GROUP_24G
; group
++) {
2492 pwrInfo24G
->IndexCCK_Base
[rfPath
][group
] = EEPROM_DEFAULT_24G_INDEX
;
2493 pwrInfo24G
->IndexBW40_Base
[rfPath
][group
] = EEPROM_DEFAULT_24G_INDEX
;
2496 for (TxCount
= 0; TxCount
< MAX_TX_COUNT
; TxCount
++) {
2498 pwrInfo24G
->BW20_Diff
[rfPath
][0] = EEPROM_DEFAULT_24G_HT20_DIFF
;
2499 pwrInfo24G
->OFDM_Diff
[rfPath
][0] = EEPROM_DEFAULT_24G_OFDM_DIFF
;
2501 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2502 pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2503 pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2504 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2512 pHalData
->bTXPowerDataReadFromEEPORM
= true; /* YJ, move, 120316 */
2514 for (rfPath
= 0; rfPath
< MAX_RF_PATH
; rfPath
++) {
2515 /* 2 2.4G default value */
2516 for (group
= 0; group
< MAX_CHNL_GROUP_24G
; group
++) {
2517 pwrInfo24G
->IndexCCK_Base
[rfPath
][group
] = PROMContent
[eeAddr
++];
2518 if (pwrInfo24G
->IndexCCK_Base
[rfPath
][group
] == 0xFF)
2519 pwrInfo24G
->IndexCCK_Base
[rfPath
][group
] = EEPROM_DEFAULT_24G_INDEX
;
2522 for (group
= 0; group
< MAX_CHNL_GROUP_24G
-1; group
++) {
2523 pwrInfo24G
->IndexBW40_Base
[rfPath
][group
] = PROMContent
[eeAddr
++];
2524 if (pwrInfo24G
->IndexBW40_Base
[rfPath
][group
] == 0xFF)
2525 pwrInfo24G
->IndexBW40_Base
[rfPath
][group
] = EEPROM_DEFAULT_24G_INDEX
;
2528 for (TxCount
= 0; TxCount
< MAX_TX_COUNT
; TxCount
++) {
2530 pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] = 0;
2531 if (PROMContent
[eeAddr
] == 0xFF)
2532 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_24G_HT20_DIFF
;
2534 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0xf0)>>4;
2535 if (pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2536 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] |= 0xF0;
2539 if (PROMContent
[eeAddr
] == 0xFF)
2540 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_24G_OFDM_DIFF
;
2542 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0x0f);
2543 if (pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2544 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] |= 0xF0;
2546 pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] = 0;
2549 if (PROMContent
[eeAddr
] == 0xFF)
2550 pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2552 pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0xf0)>>4;
2553 if (pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2554 pwrInfo24G
->BW40_Diff
[rfPath
][TxCount
] |= 0xF0;
2557 if (PROMContent
[eeAddr
] == 0xFF)
2558 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2560 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0x0f);
2561 if (pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2562 pwrInfo24G
->BW20_Diff
[rfPath
][TxCount
] |= 0xF0;
2566 if (PROMContent
[eeAddr
] == 0xFF)
2567 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2569 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0xf0)>>4;
2570 if (pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2571 pwrInfo24G
->OFDM_Diff
[rfPath
][TxCount
] |= 0xF0;
2574 if (PROMContent
[eeAddr
] == 0xFF)
2575 pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] = EEPROM_DEFAULT_DIFF
;
2577 pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] = (PROMContent
[eeAddr
]&0x0f);
2578 if (pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] & BIT3
) /* 4bit sign number to 8 bit sign number */
2579 pwrInfo24G
->CCK_Diff
[rfPath
][TxCount
] |= 0xF0;
2588 void Hal_EfuseParseTxPowerInfo_8723B(
2589 struct adapter
*padapter
, u8
*PROMContent
, bool AutoLoadFail
2592 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2593 struct TxPowerInfo24G pwrInfo24G
;
2594 u8 rfPath
, ch
, TxCount
= 1;
2596 Hal_ReadPowerValueFromPROM_8723B(padapter
, &pwrInfo24G
, PROMContent
, AutoLoadFail
);
2597 for (rfPath
= 0 ; rfPath
< MAX_RF_PATH
; rfPath
++) {
2598 for (ch
= 0 ; ch
< CHANNEL_MAX_NUMBER
; ch
++) {
2601 Hal_GetChnlGroup8723B(ch
+1, &group
);
2604 pHalData
->Index24G_CCK_Base
[rfPath
][ch
] = pwrInfo24G
.IndexCCK_Base
[rfPath
][5];
2605 pHalData
->Index24G_BW40_Base
[rfPath
][ch
] = pwrInfo24G
.IndexBW40_Base
[rfPath
][group
];
2607 pHalData
->Index24G_CCK_Base
[rfPath
][ch
] = pwrInfo24G
.IndexCCK_Base
[rfPath
][group
];
2608 pHalData
->Index24G_BW40_Base
[rfPath
][ch
] = pwrInfo24G
.IndexBW40_Base
[rfPath
][group
];
2611 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("======= Path %d, ChannelIndex %d, Group %d =======\n", rfPath
, ch
, group
));
2612 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("Index24G_CCK_Base[%d][%d] = 0x%x\n", rfPath
, ch
, pHalData
->Index24G_CCK_Base
[rfPath
][ch
]));
2613 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("Index24G_BW40_Base[%d][%d] = 0x%x\n", rfPath
, ch
, pHalData
->Index24G_BW40_Base
[rfPath
][ch
]));
2617 for (TxCount
= 0; TxCount
< MAX_TX_COUNT
; TxCount
++) {
2618 pHalData
->CCK_24G_Diff
[rfPath
][TxCount
] = pwrInfo24G
.CCK_Diff
[rfPath
][TxCount
];
2619 pHalData
->OFDM_24G_Diff
[rfPath
][TxCount
] = pwrInfo24G
.OFDM_Diff
[rfPath
][TxCount
];
2620 pHalData
->BW20_24G_Diff
[rfPath
][TxCount
] = pwrInfo24G
.BW20_Diff
[rfPath
][TxCount
];
2621 pHalData
->BW40_24G_Diff
[rfPath
][TxCount
] = pwrInfo24G
.BW40_Diff
[rfPath
][TxCount
];
2624 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("--------------------------------------- 2.4G ---------------------------------------\n"));
2625 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("CCK_24G_Diff[%d][%d]= %d\n", rfPath
, TxCount
, pHalData
->CCK_24G_Diff
[rfPath
][TxCount
]));
2626 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("OFDM_24G_Diff[%d][%d]= %d\n", rfPath
, TxCount
, pHalData
->OFDM_24G_Diff
[rfPath
][TxCount
]));
2627 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("BW20_24G_Diff[%d][%d]= %d\n", rfPath
, TxCount
, pHalData
->BW20_24G_Diff
[rfPath
][TxCount
]));
2628 RT_TRACE(_module_hci_hal_init_c_
, _drv_info_
, ("BW40_24G_Diff[%d][%d]= %d\n", rfPath
, TxCount
, pHalData
->BW40_24G_Diff
[rfPath
][TxCount
]));
2633 /* 2010/10/19 MH Add Regulator recognize for CU. */
2634 if (!AutoLoadFail
) {
2635 pHalData
->EEPROMRegulatory
= (PROMContent
[EEPROM_RF_BOARD_OPTION_8723B
]&0x7); /* bit0~2 */
2636 if (PROMContent
[EEPROM_RF_BOARD_OPTION_8723B
] == 0xFF)
2637 pHalData
->EEPROMRegulatory
= (EEPROM_DEFAULT_BOARD_OPTION
&0x7); /* bit0~2 */
2639 pHalData
->EEPROMRegulatory
= 0;
2641 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("EEPROMRegulatory = 0x%x\n", pHalData
->EEPROMRegulatory
));
2644 void Hal_EfuseParseBTCoexistInfo_8723B(
2645 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2648 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2652 if (!AutoLoadFail
) {
2653 tmpu4
= rtw_read32(padapter
, REG_MULTI_FUNC_CTRL
);
2654 if (tmpu4
& BT_FUNC_EN
)
2655 pHalData
->EEPROMBluetoothCoexist
= true;
2657 pHalData
->EEPROMBluetoothCoexist
= false;
2659 pHalData
->EEPROMBluetoothType
= BT_RTL8723B
;
2661 tempval
= hwinfo
[EEPROM_RF_BT_SETTING_8723B
];
2662 if (tempval
!= 0xFF) {
2663 pHalData
->EEPROMBluetoothAntNum
= tempval
& BIT(0);
2664 /* EFUSE_0xC3[6] == 0, S1(Main)-ODM_RF_PATH_A; */
2665 /* EFUSE_0xC3[6] == 1, S0(Aux)-ODM_RF_PATH_B */
2666 pHalData
->ant_path
= (tempval
& BIT(6))?ODM_RF_PATH_B
:ODM_RF_PATH_A
;
2668 pHalData
->EEPROMBluetoothAntNum
= Ant_x1
;
2669 if (pHalData
->PackageType
== PACKAGE_QFN68
)
2670 pHalData
->ant_path
= ODM_RF_PATH_B
;
2672 pHalData
->ant_path
= ODM_RF_PATH_A
;
2675 pHalData
->EEPROMBluetoothCoexist
= false;
2676 pHalData
->EEPROMBluetoothType
= BT_RTL8723B
;
2677 pHalData
->EEPROMBluetoothAntNum
= Ant_x1
;
2678 pHalData
->ant_path
= ODM_RF_PATH_A
;
2681 if (padapter
->registrypriv
.ant_num
> 0) {
2683 "%s: Apply driver defined antenna number(%d) to replace origin(%d)\n",
2685 padapter
->registrypriv
.ant_num
,
2686 pHalData
->EEPROMBluetoothAntNum
== Ant_x2
? 2 : 1
2689 switch (padapter
->registrypriv
.ant_num
) {
2691 pHalData
->EEPROMBluetoothAntNum
= Ant_x1
;
2694 pHalData
->EEPROMBluetoothAntNum
= Ant_x2
;
2698 "%s: Discard invalid driver defined antenna number(%d)!\n",
2700 padapter
->registrypriv
.ant_num
2706 rtw_btcoex_SetBTCoexist(padapter
, pHalData
->EEPROMBluetoothCoexist
);
2707 rtw_btcoex_SetChipType(padapter
, pHalData
->EEPROMBluetoothType
);
2708 rtw_btcoex_SetPGAntNum(padapter
, pHalData
->EEPROMBluetoothAntNum
== Ant_x2
? 2 : 1);
2709 if (pHalData
->EEPROMBluetoothAntNum
== Ant_x1
)
2710 rtw_btcoex_SetSingleAntPath(padapter
, pHalData
->ant_path
);
2713 "%s: %s BT-coex, ant_num =%d\n",
2715 pHalData
->EEPROMBluetoothCoexist
== true ? "Enable" : "Disable",
2716 pHalData
->EEPROMBluetoothAntNum
== Ant_x2
? 2 : 1
2720 void Hal_EfuseParseEEPROMVer_8723B(
2721 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2724 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2726 /* RT_TRACE(_module_hci_hal_init_c_, _drv_notice_, ("%s(): AutoLoadFail = %d\n", __func__, AutoLoadFail)); */
2728 pHalData
->EEPROMVersion
= hwinfo
[EEPROM_VERSION_8723B
];
2730 pHalData
->EEPROMVersion
= 1;
2731 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("Hal_EfuseParseEEPROMVer(), EEVer = %d\n",
2732 pHalData
->EEPROMVersion
));
2737 void Hal_EfuseParsePackageType_8723B(
2738 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2741 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2745 Efuse_PowerSwitch(padapter
, false, true);
2746 efuse_OneByteRead(padapter
, 0x1FB, &efuseContent
, false);
2747 DBG_871X("%s phy efuse read 0x1FB =%x\n", __func__
, efuseContent
);
2748 Efuse_PowerSwitch(padapter
, false, false);
2750 package
= efuseContent
& 0x7;
2753 pHalData
->PackageType
= PACKAGE_TFBGA79
;
2756 pHalData
->PackageType
= PACKAGE_TFBGA90
;
2759 pHalData
->PackageType
= PACKAGE_QFN68
;
2762 pHalData
->PackageType
= PACKAGE_TFBGA80
;
2766 pHalData
->PackageType
= PACKAGE_DEFAULT
;
2770 DBG_871X("PackageType = 0x%X\n", pHalData
->PackageType
);
2774 void Hal_EfuseParseVoltage_8723B(
2775 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2778 struct eeprom_priv
*pEEPROM
= GET_EEPROM_EFUSE_PRIV(padapter
);
2780 /* memcpy(pEEPROM->adjuseVoltageVal, &hwinfo[EEPROM_Voltage_ADDR_8723B], 1); */
2781 DBG_871X("%s hwinfo[EEPROM_Voltage_ADDR_8723B] =%02x\n", __func__
, hwinfo
[EEPROM_Voltage_ADDR_8723B
]);
2782 pEEPROM
->adjuseVoltageVal
= (hwinfo
[EEPROM_Voltage_ADDR_8723B
] & 0xf0) >> 4;
2783 DBG_871X("%s pEEPROM->adjuseVoltageVal =%x\n", __func__
, pEEPROM
->adjuseVoltageVal
);
2786 void Hal_EfuseParseChnlPlan_8723B(
2787 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2790 padapter
->mlmepriv
.ChannelPlan
= hal_com_config_channel_plan(
2792 hwinfo
? hwinfo
[EEPROM_ChannelPlan_8723B
] : 0xFF,
2793 padapter
->registrypriv
.channel_plan
,
2794 RT_CHANNEL_DOMAIN_WORLD_NULL
,
2798 Hal_ChannelPlanToRegulation(padapter
, padapter
->mlmepriv
.ChannelPlan
);
2800 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("EEPROM ChannelPlan = 0x%02x\n", padapter
->mlmepriv
.ChannelPlan
));
2803 void Hal_EfuseParseCustomerID_8723B(
2804 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2807 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2809 /* RT_TRACE(_module_hci_hal_init_c_, _drv_notice_, ("%s(): AutoLoadFail = %d\n", __func__, AutoLoadFail)); */
2811 pHalData
->EEPROMCustomerID
= hwinfo
[EEPROM_CustomID_8723B
];
2813 pHalData
->EEPROMCustomerID
= 0;
2815 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("EEPROM Customer ID: 0x%2x\n", pHalData
->EEPROMCustomerID
));
2818 void Hal_EfuseParseAntennaDiversity_8723B(
2819 struct adapter
*padapter
,
2826 void Hal_EfuseParseXtal_8723B(
2827 struct adapter
*padapter
, u8
*hwinfo
, bool AutoLoadFail
2830 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2832 /* RT_TRACE(_module_hci_hal_init_c_, _drv_notice_, ("%s(): AutoLoadFail = %d\n", __func__, AutoLoadFail)); */
2833 if (!AutoLoadFail
) {
2834 pHalData
->CrystalCap
= hwinfo
[EEPROM_XTAL_8723B
];
2835 if (pHalData
->CrystalCap
== 0xFF)
2836 pHalData
->CrystalCap
= EEPROM_Default_CrystalCap_8723B
; /* what value should 8812 set? */
2838 pHalData
->CrystalCap
= EEPROM_Default_CrystalCap_8723B
;
2840 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("EEPROM CrystalCap: 0x%2x\n", pHalData
->CrystalCap
));
2844 void Hal_EfuseParseThermalMeter_8723B(
2845 struct adapter
*padapter
, u8
*PROMContent
, u8 AutoLoadFail
2848 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
2850 /* RT_TRACE(_module_hci_hal_init_c_, _drv_notice_, ("%s(): AutoLoadFail = %d\n", __func__, AutoLoadFail)); */
2852 /* ThermalMeter from EEPROM */
2854 if (false == AutoLoadFail
)
2855 pHalData
->EEPROMThermalMeter
= PROMContent
[EEPROM_THERMAL_METER_8723B
];
2857 pHalData
->EEPROMThermalMeter
= EEPROM_Default_ThermalMeter_8723B
;
2859 if ((pHalData
->EEPROMThermalMeter
== 0xff) || (true == AutoLoadFail
)) {
2860 pHalData
->bAPKThermalMeterIgnore
= true;
2861 pHalData
->EEPROMThermalMeter
= EEPROM_Default_ThermalMeter_8723B
;
2864 RT_TRACE(_module_hci_hal_init_c_
, _drv_notice_
, ("EEPROM ThermalMeter = 0x%x\n", pHalData
->EEPROMThermalMeter
));
2868 void Hal_ReadRFGainOffset(
2869 struct adapter
*Adapter
, u8
*PROMContent
, bool AutoloadFail
2873 /* BB_RF Gain Offset from EEPROM */
2876 if (!AutoloadFail
) {
2877 Adapter
->eeprompriv
.EEPROMRFGainOffset
= PROMContent
[EEPROM_RF_GAIN_OFFSET
];
2878 DBG_871X("AutoloadFail =%x,\n", AutoloadFail
);
2879 Adapter
->eeprompriv
.EEPROMRFGainVal
= EFUSE_Read1Byte(Adapter
, EEPROM_RF_GAIN_VAL
);
2880 DBG_871X("Adapter->eeprompriv.EEPROMRFGainVal =%x\n", Adapter
->eeprompriv
.EEPROMRFGainVal
);
2882 Adapter
->eeprompriv
.EEPROMRFGainOffset
= 0;
2883 Adapter
->eeprompriv
.EEPROMRFGainVal
= 0xFF;
2884 DBG_871X("else AutoloadFail =%x,\n", AutoloadFail
);
2886 DBG_871X("EEPRORFGainOffset = 0x%02x\n", Adapter
->eeprompriv
.EEPROMRFGainOffset
);
2889 u8
BWMapping_8723B(struct adapter
*Adapter
, struct pkt_attrib
*pattrib
)
2891 u8 BWSettingOfDesc
= 0;
2892 struct hal_com_data
*pHalData
= GET_HAL_DATA(Adapter
);
2894 /* DBG_871X("BWMapping pHalData->CurrentChannelBW %d, pattrib->bwmode %d\n", pHalData->CurrentChannelBW, pattrib->bwmode); */
2896 if (pHalData
->CurrentChannelBW
== CHANNEL_WIDTH_80
) {
2897 if (pattrib
->bwmode
== CHANNEL_WIDTH_80
)
2898 BWSettingOfDesc
= 2;
2899 else if (pattrib
->bwmode
== CHANNEL_WIDTH_40
)
2900 BWSettingOfDesc
= 1;
2902 BWSettingOfDesc
= 0;
2903 } else if (pHalData
->CurrentChannelBW
== CHANNEL_WIDTH_40
) {
2904 if ((pattrib
->bwmode
== CHANNEL_WIDTH_40
) || (pattrib
->bwmode
== CHANNEL_WIDTH_80
))
2905 BWSettingOfDesc
= 1;
2907 BWSettingOfDesc
= 0;
2909 BWSettingOfDesc
= 0;
2911 /* if (pTcb->bBTTxPacket) */
2912 /* BWSettingOfDesc = 0; */
2914 return BWSettingOfDesc
;
2917 u8
SCMapping_8723B(struct adapter
*Adapter
, struct pkt_attrib
*pattrib
)
2919 u8 SCSettingOfDesc
= 0;
2920 struct hal_com_data
*pHalData
= GET_HAL_DATA(Adapter
);
2922 /* DBG_871X("SCMapping: pHalData->CurrentChannelBW %d, pHalData->nCur80MhzPrimeSC %d, pHalData->nCur40MhzPrimeSC %d\n", pHalData->CurrentChannelBW, pHalData->nCur80MhzPrimeSC, pHalData->nCur40MhzPrimeSC); */
2924 if (pHalData
->CurrentChannelBW
== CHANNEL_WIDTH_80
) {
2925 if (pattrib
->bwmode
== CHANNEL_WIDTH_80
) {
2926 SCSettingOfDesc
= VHT_DATA_SC_DONOT_CARE
;
2927 } else if (pattrib
->bwmode
== CHANNEL_WIDTH_40
) {
2928 if (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
)
2929 SCSettingOfDesc
= VHT_DATA_SC_40_LOWER_OF_80MHZ
;
2930 else if (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
)
2931 SCSettingOfDesc
= VHT_DATA_SC_40_UPPER_OF_80MHZ
;
2933 DBG_871X("SCMapping: Not Correct Primary40MHz Setting\n");
2935 if ((pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
) && (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
))
2936 SCSettingOfDesc
= VHT_DATA_SC_20_LOWEST_OF_80MHZ
;
2937 else if ((pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
) && (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
))
2938 SCSettingOfDesc
= VHT_DATA_SC_20_LOWER_OF_80MHZ
;
2939 else if ((pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
) && (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
))
2940 SCSettingOfDesc
= VHT_DATA_SC_20_UPPER_OF_80MHZ
;
2941 else if ((pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
) && (pHalData
->nCur80MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
))
2942 SCSettingOfDesc
= VHT_DATA_SC_20_UPPERST_OF_80MHZ
;
2944 DBG_871X("SCMapping: Not Correct Primary40MHz Setting\n");
2946 } else if (pHalData
->CurrentChannelBW
== CHANNEL_WIDTH_40
) {
2947 /* DBG_871X("SCMapping: HT Case: pHalData->CurrentChannelBW %d, pHalData->nCur40MhzPrimeSC %d\n", pHalData->CurrentChannelBW, pHalData->nCur40MhzPrimeSC); */
2949 if (pattrib
->bwmode
== CHANNEL_WIDTH_40
) {
2950 SCSettingOfDesc
= VHT_DATA_SC_DONOT_CARE
;
2951 } else if (pattrib
->bwmode
== CHANNEL_WIDTH_20
) {
2952 if (pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_UPPER
) {
2953 SCSettingOfDesc
= VHT_DATA_SC_20_UPPER_OF_80MHZ
;
2954 } else if (pHalData
->nCur40MhzPrimeSC
== HAL_PRIME_CHNL_OFFSET_LOWER
) {
2955 SCSettingOfDesc
= VHT_DATA_SC_20_LOWER_OF_80MHZ
;
2957 SCSettingOfDesc
= VHT_DATA_SC_DONOT_CARE
;
2961 SCSettingOfDesc
= VHT_DATA_SC_DONOT_CARE
;
2964 return SCSettingOfDesc
;
2967 static void rtl8723b_cal_txdesc_chksum(struct tx_desc
*ptxdesc
)
2969 u16
*usPtr
= (u16
*)ptxdesc
;
2976 ptxdesc
->txdw7
&= cpu_to_le32(0xffff0000);
2978 /* checksume is always calculated by first 32 bytes, */
2979 /* and it doesn't depend on TX DESC length. */
2980 /* Thomas, Lucas@SD4, 20130515 */
2983 for (index
= 0; index
< count
; index
++) {
2984 checksum
|= le16_to_cpu(*(__le16
*)(usPtr
+ index
));
2987 ptxdesc
->txdw7
|= cpu_to_le32(checksum
& 0x0000ffff);
2990 static u8
fill_txdesc_sectype(struct pkt_attrib
*pattrib
)
2993 if ((pattrib
->encrypt
> 0) && !pattrib
->bswenc
) {
2994 switch (pattrib
->encrypt
) {
3015 static void fill_txdesc_vcs_8723b(struct adapter
*padapter
, struct pkt_attrib
*pattrib
, PTXDESC_8723B ptxdesc
)
3017 /* DBG_8192C("cvs_mode =%d\n", pattrib->vcs_mode); */
3019 if (pattrib
->vcs_mode
) {
3020 switch (pattrib
->vcs_mode
) {
3024 ptxdesc
->hw_rts_en
= 1;
3028 ptxdesc
->cts2self
= 1;
3036 ptxdesc
->rtsrate
= 8; /* RTS Rate =24M */
3037 ptxdesc
->rts_ratefb_lmt
= 0xF;
3039 if (padapter
->mlmeextpriv
.mlmext_info
.preamble_mode
== PREAMBLE_SHORT
)
3040 ptxdesc
->rts_short
= 1;
3044 ptxdesc
->rts_sc
= SCMapping_8723B(padapter
, pattrib
);
3048 static void fill_txdesc_phy_8723b(struct adapter
*padapter
, struct pkt_attrib
*pattrib
, PTXDESC_8723B ptxdesc
)
3050 /* DBG_8192C("bwmode =%d, ch_off =%d\n", pattrib->bwmode, pattrib->ch_offset); */
3052 if (pattrib
->ht_en
) {
3053 ptxdesc
->data_bw
= BWMapping_8723B(padapter
, pattrib
);
3055 ptxdesc
->data_sc
= SCMapping_8723B(padapter
, pattrib
);
3059 static void rtl8723b_fill_default_txdesc(
3060 struct xmit_frame
*pxmitframe
, u8
*pbuf
3063 struct adapter
*padapter
;
3064 struct hal_com_data
*pHalData
;
3065 struct dm_priv
*pdmpriv
;
3066 struct mlme_ext_priv
*pmlmeext
;
3067 struct mlme_ext_info
*pmlmeinfo
;
3068 struct pkt_attrib
*pattrib
;
3069 PTXDESC_8723B ptxdesc
;
3072 memset(pbuf
, 0, TXDESC_SIZE
);
3074 padapter
= pxmitframe
->padapter
;
3075 pHalData
= GET_HAL_DATA(padapter
);
3076 pdmpriv
= &pHalData
->dmpriv
;
3077 pmlmeext
= &padapter
->mlmeextpriv
;
3078 pmlmeinfo
= &(pmlmeext
->mlmext_info
);
3080 pattrib
= &pxmitframe
->attrib
;
3081 bmcst
= IS_MCAST(pattrib
->ra
);
3083 ptxdesc
= (PTXDESC_8723B
)pbuf
;
3085 if (pxmitframe
->frame_tag
== DATA_FRAMETAG
) {
3088 ptxdesc
->macid
= pattrib
->mac_id
; /* CAM_ID(MAC_ID) */
3089 ptxdesc
->rate_id
= pattrib
->raid
;
3090 ptxdesc
->qsel
= pattrib
->qsel
;
3091 ptxdesc
->seq
= pattrib
->seqnum
;
3093 ptxdesc
->sectype
= fill_txdesc_sectype(pattrib
);
3094 fill_txdesc_vcs_8723b(padapter
, pattrib
, ptxdesc
);
3096 if (pattrib
->icmp_pkt
== 1 && padapter
->registrypriv
.wifi_spec
== 1)
3100 (pattrib
->ether_type
!= 0x888e) &&
3101 (pattrib
->ether_type
!= 0x0806) &&
3102 (pattrib
->ether_type
!= 0x88B4) &&
3103 (pattrib
->dhcp_pkt
!= 1) &&
3105 #ifdef CONFIG_AUTO_AP_MODE
3106 && (pattrib
->pctrl
!= true)
3109 /* Non EAP & ARP & DHCP type data packet */
3111 if (pattrib
->ampdu_en
== true) {
3112 ptxdesc
->agg_en
= 1; /* AGG EN */
3113 ptxdesc
->max_agg_num
= 0x1f;
3114 ptxdesc
->ampdu_density
= pattrib
->ampdu_spacing
;
3116 ptxdesc
->bk
= 1; /* AGG BK */
3118 fill_txdesc_phy_8723b(padapter
, pattrib
, ptxdesc
);
3120 ptxdesc
->data_ratefb_lmt
= 0x1F;
3122 if (pHalData
->fw_ractrl
== false) {
3123 ptxdesc
->userate
= 1;
3125 if (pHalData
->dmpriv
.INIDATA_RATE
[pattrib
->mac_id
] & BIT(7))
3126 ptxdesc
->data_short
= 1;
3128 ptxdesc
->datarate
= pHalData
->dmpriv
.INIDATA_RATE
[pattrib
->mac_id
] & 0x7F;
3131 if (padapter
->fix_rate
!= 0xFF) { /* modify data rate by iwpriv */
3132 ptxdesc
->userate
= 1;
3133 if (padapter
->fix_rate
& BIT(7))
3134 ptxdesc
->data_short
= 1;
3136 ptxdesc
->datarate
= (padapter
->fix_rate
& 0x7F);
3137 ptxdesc
->disdatafb
= 1;
3141 ptxdesc
->data_ldpc
= 1;
3143 ptxdesc
->data_stbc
= 1;
3145 #ifdef CONFIG_CMCC_TEST
3146 ptxdesc
->data_short
= 1; /* use cck short premble */
3149 /* EAP data packet and ARP packet. */
3150 /* Use the 1M data rate to send the EAP/ARP packet. */
3151 /* This will maybe make the handshake smooth. */
3153 ptxdesc
->bk
= 1; /* AGG BK */
3154 ptxdesc
->userate
= 1; /* driver uses rate */
3155 if (pmlmeinfo
->preamble_mode
== PREAMBLE_SHORT
)
3156 ptxdesc
->data_short
= 1;/* DATA_SHORT */
3157 ptxdesc
->datarate
= MRateToHwRate(pmlmeext
->tx_rate
);
3158 DBG_871X("YJ: %s(): ARP Data: userate =%d, datarate = 0x%x\n", __func__
, ptxdesc
->userate
, ptxdesc
->datarate
);
3161 ptxdesc
->usb_txagg_num
= pxmitframe
->agg_num
;
3162 } else if (pxmitframe
->frame_tag
== MGNT_FRAMETAG
) {
3163 /* RT_TRACE(_module_hal_xmit_c_, _drv_notice_, ("%s: MGNT_FRAMETAG\n", __func__)); */
3165 ptxdesc
->macid
= pattrib
->mac_id
; /* CAM_ID(MAC_ID) */
3166 ptxdesc
->qsel
= pattrib
->qsel
;
3167 ptxdesc
->rate_id
= pattrib
->raid
; /* Rate ID */
3168 ptxdesc
->seq
= pattrib
->seqnum
;
3169 ptxdesc
->userate
= 1; /* driver uses rate, 1M */
3171 ptxdesc
->mbssid
= pattrib
->mbssid
& 0xF;
3173 ptxdesc
->rty_lmt_en
= 1; /* retry limit enable */
3174 if (pattrib
->retry_ctrl
== true) {
3175 ptxdesc
->data_rt_lmt
= 6;
3177 ptxdesc
->data_rt_lmt
= 12;
3180 ptxdesc
->datarate
= MRateToHwRate(pmlmeext
->tx_rate
);
3182 /* CCX-TXRPT ack for xmit mgmt frames. */
3183 if (pxmitframe
->ack_report
) {
3185 DBG_8192C("%s set spe_rpt\n", __func__
);
3187 ptxdesc
->spe_rpt
= 1;
3188 ptxdesc
->sw_define
= (u8
)(GET_PRIMARY_ADAPTER(padapter
)->xmitpriv
.seq_no
);
3190 } else if (pxmitframe
->frame_tag
== TXAGG_FRAMETAG
) {
3191 RT_TRACE(_module_hal_xmit_c_
, _drv_warning_
, ("%s: TXAGG_FRAMETAG\n", __func__
));
3193 RT_TRACE(_module_hal_xmit_c_
, _drv_warning_
, ("%s: frame_tag = 0x%x\n", __func__
, pxmitframe
->frame_tag
));
3195 ptxdesc
->macid
= pattrib
->mac_id
; /* CAM_ID(MAC_ID) */
3196 ptxdesc
->rate_id
= pattrib
->raid
; /* Rate ID */
3197 ptxdesc
->qsel
= pattrib
->qsel
;
3198 ptxdesc
->seq
= pattrib
->seqnum
;
3199 ptxdesc
->userate
= 1; /* driver uses rate */
3200 ptxdesc
->datarate
= MRateToHwRate(pmlmeext
->tx_rate
);
3203 ptxdesc
->pktlen
= pattrib
->last_txcmdsz
;
3204 ptxdesc
->offset
= TXDESC_SIZE
+ OFFSET_SZ
;
3209 /* 2009.11.05. tynli_test. Suggested by SD4 Filen for FW LPS. */
3210 /* (1) The sequence number of each non-Qos frame / broadcast / multicast / */
3211 /* mgnt frame should be controled by Hw because Fw will also send null data */
3212 /* which we cannot control when Fw LPS enable. */
3213 /* --> default enable non-Qos data sequense number. 2010.06.23. by tynli. */
3214 /* (2) Enable HW SEQ control for beacon packet, because we use Hw beacon. */
3215 /* (3) Use HW Qos SEQ to control the seq num of Ext port non-Qos packets. */
3216 /* 2010.06.23. Added by tynli. */
3217 if (!pattrib
->qos_en
) /* Hw set sequence number */
3218 ptxdesc
->en_hwseq
= 1; /* HWSEQ_EN */
3225 * pxmitframe xmitframe
3226 * pbuf where to fill tx desc
3228 void rtl8723b_update_txdesc(struct xmit_frame
*pxmitframe
, u8
*pbuf
)
3230 struct tx_desc
*pdesc
;
3232 rtl8723b_fill_default_txdesc(pxmitframe
, pbuf
);
3234 pdesc
= (struct tx_desc
*)pbuf
;
3235 pdesc
->txdw0
= pdesc
->txdw0
;
3236 pdesc
->txdw1
= pdesc
->txdw1
;
3237 pdesc
->txdw2
= pdesc
->txdw2
;
3238 pdesc
->txdw3
= pdesc
->txdw3
;
3239 pdesc
->txdw4
= pdesc
->txdw4
;
3240 pdesc
->txdw5
= pdesc
->txdw5
;
3241 pdesc
->txdw6
= pdesc
->txdw6
;
3242 pdesc
->txdw7
= pdesc
->txdw7
;
3243 pdesc
->txdw8
= pdesc
->txdw8
;
3244 pdesc
->txdw9
= pdesc
->txdw9
;
3246 rtl8723b_cal_txdesc_chksum(pdesc
);
3250 /* Description: In normal chip, we should send some packet to Hw which will be used by Fw */
3251 /* in FW LPS mode. The function is to fill the Tx descriptor of this packets, then */
3252 /* Fw can tell Hw to send these packet derectly. */
3253 /* Added by tynli. 2009.10.15. */
3255 /* type1:pspoll, type2:null */
3256 void rtl8723b_fill_fake_txdesc(
3257 struct adapter
*padapter
,
3265 /* Clear all status */
3266 memset(pDesc
, 0, TXDESC_SIZE
);
3268 SET_TX_DESC_FIRST_SEG_8723B(pDesc
, 1); /* bFirstSeg; */
3269 SET_TX_DESC_LAST_SEG_8723B(pDesc
, 1); /* bLastSeg; */
3271 SET_TX_DESC_OFFSET_8723B(pDesc
, 0x28); /* Offset = 32 */
3273 SET_TX_DESC_PKT_SIZE_8723B(pDesc
, BufferLen
); /* Buffer size + command header */
3274 SET_TX_DESC_QUEUE_SEL_8723B(pDesc
, QSLT_MGNT
); /* Fixed queue of Mgnt queue */
3276 /* Set NAVUSEHDR to prevent Ps-poll AId filed to be changed to error vlaue by Hw. */
3277 if (true == IsPsPoll
) {
3278 SET_TX_DESC_NAV_USE_HDR_8723B(pDesc
, 1);
3280 SET_TX_DESC_HWSEQ_EN_8723B(pDesc
, 1); /* Hw set sequence number */
3281 SET_TX_DESC_HWSEQ_SEL_8723B(pDesc
, 0);
3284 if (true == IsBTQosNull
) {
3285 SET_TX_DESC_BT_INT_8723B(pDesc
, 1);
3288 SET_TX_DESC_USE_RATE_8723B(pDesc
, 1); /* use data rate which is set by Sw */
3289 SET_TX_DESC_OWN_8723B((u8
*)pDesc
, 1);
3291 SET_TX_DESC_TX_RATE_8723B(pDesc
, DESC8723B_RATE1M
);
3294 /* Encrypt the data frame if under security mode excepct null data. Suggested by CCW. */
3296 if (true == bDataFrame
) {
3299 EncAlg
= padapter
->securitypriv
.dot11PrivacyAlgrthm
;
3302 SET_TX_DESC_SEC_TYPE_8723B(pDesc
, 0x0);
3307 SET_TX_DESC_SEC_TYPE_8723B(pDesc
, 0x1);
3310 SET_TX_DESC_SEC_TYPE_8723B(pDesc
, 0x2);
3313 SET_TX_DESC_SEC_TYPE_8723B(pDesc
, 0x3);
3316 SET_TX_DESC_SEC_TYPE_8723B(pDesc
, 0x0);
3321 /* USB interface drop packet if the checksum of descriptor isn't correct. */
3322 /* Using this checksum can let hardware recovery from packet bulk out error (e.g. Cancel URC, Bulk out error.). */
3323 rtl8723b_cal_txdesc_chksum((struct tx_desc
*)pDesc
);
3326 static void hw_var_set_opmode(struct adapter
*padapter
, u8 variable
, u8
*val
)
3329 u8 mode
= *((u8
*)val
);
3332 /* disable Port0 TSF update */
3333 val8
= rtw_read8(padapter
, REG_BCN_CTRL
);
3334 val8
|= DIS_TSF_UDT
;
3335 rtw_write8(padapter
, REG_BCN_CTRL
, val8
);
3338 Set_MSR(padapter
, mode
);
3339 DBG_871X("#### %s() -%d iface_type(0) mode = %d ####\n", __func__
, __LINE__
, mode
);
3341 if ((mode
== _HW_STATE_STATION_
) || (mode
== _HW_STATE_NOLINK_
)) {
3343 StopTxBeacon(padapter
);
3344 #ifdef CONFIG_INTERRUPT_BASED_TXBCN
3345 #ifdef CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
3346 rtw_write8(padapter
, REG_DRVERLYINT
, 0x05); /* restore early int time to 5ms */
3347 UpdateInterruptMask8812AU(padapter
, true, 0, IMR_BCNDMAINT0_8723B
);
3348 #endif /* CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT */
3350 #ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
3351 UpdateInterruptMask8812AU(padapter
, true, 0, (IMR_TXBCN0ERR_8723B
|IMR_TXBCN0OK_8723B
));
3352 #endif /* CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR */
3354 #endif /* CONFIG_INTERRUPT_BASED_TXBCN */
3357 /* disable atim wnd */
3358 rtw_write8(padapter
, REG_BCN_CTRL
, DIS_TSF_UDT
|EN_BCN_FUNCTION
|DIS_ATIM
);
3359 /* rtw_write8(padapter, REG_BCN_CTRL, 0x18); */
3360 } else if ((mode
== _HW_STATE_ADHOC_
) /*|| (mode == _HW_STATE_AP_)*/) {
3361 ResumeTxBeacon(padapter
);
3362 rtw_write8(padapter
, REG_BCN_CTRL
, DIS_TSF_UDT
|EN_BCN_FUNCTION
|DIS_BCNQ_SUB
);
3363 } else if (mode
== _HW_STATE_AP_
) {
3364 #ifdef CONFIG_INTERRUPT_BASED_TXBCN
3365 #ifdef CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
3366 UpdateInterruptMask8723BU(padapter
, true, IMR_BCNDMAINT0_8723B
, 0);
3367 #endif /* CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT */
3369 #ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
3370 UpdateInterruptMask8723BU(padapter
, true, (IMR_TXBCN0ERR_8723B
|IMR_TXBCN0OK_8723B
), 0);
3371 #endif /* CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR */
3373 #endif /* CONFIG_INTERRUPT_BASED_TXBCN */
3375 ResumeTxBeacon(padapter
);
3377 rtw_write8(padapter
, REG_BCN_CTRL
, DIS_TSF_UDT
|DIS_BCNQ_SUB
);
3380 rtw_write32(padapter
, REG_RCR
, 0x7000208e);/* CBSSID_DATA must set to 0, reject ICV_ERR packet */
3381 /* enable to rx data frame */
3382 rtw_write16(padapter
, REG_RXFLTMAP2
, 0xFFFF);
3383 /* enable to rx ps-poll */
3384 rtw_write16(padapter
, REG_RXFLTMAP1
, 0x0400);
3386 /* Beacon Control related register for first time */
3387 rtw_write8(padapter
, REG_BCNDMATIM
, 0x02); /* 2ms */
3389 /* rtw_write8(padapter, REG_BCN_MAX_ERR, 0xFF); */
3390 rtw_write8(padapter
, REG_ATIMWND
, 0x0a); /* 10ms */
3391 rtw_write16(padapter
, REG_BCNTCFG
, 0x00);
3392 rtw_write16(padapter
, REG_TBTT_PROHIBIT
, 0xff04);
3393 rtw_write16(padapter
, REG_TSFTR_SYN_OFFSET
, 0x7fff);/* +32767 (~32ms) */
3396 rtw_write8(padapter
, REG_DUAL_TSF_RST
, BIT(0));
3398 /* enable BCN0 Function for if1 */
3399 /* don't enable update TSF0 for if1 (due to TSF update when beacon/probe rsp are received) */
3400 rtw_write8(padapter
, REG_BCN_CTRL
, (DIS_TSF_UDT
|EN_BCN_FUNCTION
|EN_TXBCN_RPT
|DIS_BCNQ_SUB
));
3402 /* SW_BCN_SEL - Port0 */
3403 /* rtw_write8(Adapter, REG_DWBCN1_CTRL_8192E+2, rtw_read8(Adapter, REG_DWBCN1_CTRL_8192E+2) & ~BIT4); */
3404 rtw_hal_set_hwreg(padapter
, HW_VAR_DL_BCN_SEL
, NULL
);
3406 /* select BCN on port 0 */
3409 REG_CCK_CHECK_8723B
,
3410 (rtw_read8(padapter
, REG_CCK_CHECK_8723B
)&~BIT_BCN_PORT_SEL
)
3413 /* dis BCN1 ATIM WND if if2 is station */
3414 val8
= rtw_read8(padapter
, REG_BCN_CTRL_1
);
3416 rtw_write8(padapter
, REG_BCN_CTRL_1
, val8
);
3421 static void hw_var_set_macaddr(struct adapter
*padapter
, u8 variable
, u8
*val
)
3426 reg_macid
= REG_MACID
;
3428 for (idx
= 0 ; idx
< 6; idx
++)
3429 rtw_write8(GET_PRIMARY_ADAPTER(padapter
), (reg_macid
+idx
), val
[idx
]);
3432 static void hw_var_set_bssid(struct adapter
*padapter
, u8 variable
, u8
*val
)
3437 reg_bssid
= REG_BSSID
;
3439 for (idx
= 0 ; idx
< 6; idx
++)
3440 rtw_write8(padapter
, (reg_bssid
+idx
), val
[idx
]);
3443 static void hw_var_set_bcn_func(struct adapter
*padapter
, u8 variable
, u8
*val
)
3447 bcn_ctrl_reg
= REG_BCN_CTRL
;
3450 rtw_write8(padapter
, bcn_ctrl_reg
, (EN_BCN_FUNCTION
| EN_TXBCN_RPT
));
3453 val8
= rtw_read8(padapter
, bcn_ctrl_reg
);
3454 val8
&= ~(EN_BCN_FUNCTION
| EN_TXBCN_RPT
);
3456 /* Always enable port0 beacon function for PSTDMA */
3457 if (REG_BCN_CTRL
== bcn_ctrl_reg
)
3458 val8
|= EN_BCN_FUNCTION
;
3460 rtw_write8(padapter
, bcn_ctrl_reg
, val8
);
3464 static void hw_var_set_correct_tsf(struct adapter
*padapter
, u8 variable
, u8
*val
)
3468 struct mlme_ext_priv
*pmlmeext
;
3469 struct mlme_ext_info
*pmlmeinfo
;
3472 pmlmeext
= &padapter
->mlmeextpriv
;
3473 pmlmeinfo
= &pmlmeext
->mlmext_info
;
3475 tsf
= pmlmeext
->TSFValue
-rtw_modular64(pmlmeext
->TSFValue
, (pmlmeinfo
->bcn_interval
*1024))-1024; /* us */
3478 ((pmlmeinfo
->state
&0x03) == WIFI_FW_ADHOC_STATE
) ||
3479 ((pmlmeinfo
->state
&0x03) == WIFI_FW_AP_STATE
)
3481 StopTxBeacon(padapter
);
3484 /* disable related TSF function */
3485 val8
= rtw_read8(padapter
, REG_BCN_CTRL
);
3486 val8
&= ~EN_BCN_FUNCTION
;
3487 rtw_write8(padapter
, REG_BCN_CTRL
, val8
);
3489 rtw_write32(padapter
, REG_TSFTR
, tsf
);
3490 rtw_write32(padapter
, REG_TSFTR
+4, tsf
>>32);
3492 /* enable related TSF function */
3493 val8
= rtw_read8(padapter
, REG_BCN_CTRL
);
3494 val8
|= EN_BCN_FUNCTION
;
3495 rtw_write8(padapter
, REG_BCN_CTRL
, val8
);
3499 ((pmlmeinfo
->state
&0x03) == WIFI_FW_ADHOC_STATE
) ||
3500 ((pmlmeinfo
->state
&0x03) == WIFI_FW_AP_STATE
)
3502 ResumeTxBeacon(padapter
);
3505 static void hw_var_set_mlme_disconnect(struct adapter
*padapter
, u8 variable
, u8
*val
)
3509 /* Set RCR to not to receive data frame when NO LINK state */
3510 /* rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR) & ~RCR_ADF); */
3511 /* reject all data frames */
3512 rtw_write16(padapter
, REG_RXFLTMAP2
, 0);
3515 rtw_write8(padapter
, REG_DUAL_TSF_RST
, BIT(0));
3517 /* disable update TSF */
3518 val8
= rtw_read8(padapter
, REG_BCN_CTRL
);
3519 val8
|= DIS_TSF_UDT
;
3520 rtw_write8(padapter
, REG_BCN_CTRL
, val8
);
3523 static void hw_var_set_mlme_sitesurvey(struct adapter
*padapter
, u8 variable
, u8
*val
)
3525 u32 value_rcr
, rcr_clear_bit
, reg_bcn_ctl
;
3526 u16 value_rxfltmap2
;
3528 struct hal_com_data
*pHalData
;
3529 struct mlme_priv
*pmlmepriv
;
3532 pHalData
= GET_HAL_DATA(padapter
);
3533 pmlmepriv
= &padapter
->mlmepriv
;
3535 reg_bcn_ctl
= REG_BCN_CTRL
;
3537 rcr_clear_bit
= RCR_CBSSID_BCN
;
3539 /* config RCR to receive different BSSID & not to receive data frame */
3540 value_rxfltmap2
= 0;
3542 if ((check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true))
3543 rcr_clear_bit
= RCR_CBSSID_BCN
;
3545 value_rcr
= rtw_read32(padapter
, REG_RCR
);
3548 /* under sitesurvey */
3549 value_rcr
&= ~(rcr_clear_bit
);
3550 rtw_write32(padapter
, REG_RCR
, value_rcr
);
3552 rtw_write16(padapter
, REG_RXFLTMAP2
, value_rxfltmap2
);
3554 if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
| WIFI_ADHOC_STATE
| WIFI_ADHOC_MASTER_STATE
)) {
3555 /* disable update TSF */
3556 val8
= rtw_read8(padapter
, reg_bcn_ctl
);
3557 val8
|= DIS_TSF_UDT
;
3558 rtw_write8(padapter
, reg_bcn_ctl
, val8
);
3561 /* Save orignal RRSR setting. */
3562 pHalData
->RegRRSR
= rtw_read16(padapter
, REG_RRSR
);
3564 /* sitesurvey done */
3565 if (check_fwstate(pmlmepriv
, (_FW_LINKED
|WIFI_AP_STATE
)))
3566 /* enable to rx data frame */
3567 rtw_write16(padapter
, REG_RXFLTMAP2
, 0xFFFF);
3569 if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
| WIFI_ADHOC_STATE
| WIFI_ADHOC_MASTER_STATE
)) {
3570 /* enable update TSF */
3571 val8
= rtw_read8(padapter
, reg_bcn_ctl
);
3572 val8
&= ~DIS_TSF_UDT
;
3573 rtw_write8(padapter
, reg_bcn_ctl
, val8
);
3576 value_rcr
|= rcr_clear_bit
;
3577 rtw_write32(padapter
, REG_RCR
, value_rcr
);
3579 /* Restore orignal RRSR setting. */
3580 rtw_write16(padapter
, REG_RRSR
, pHalData
->RegRRSR
);
3584 static void hw_var_set_mlme_join(struct adapter
*padapter
, u8 variable
, u8
*val
)
3591 struct hal_com_data
*pHalData
;
3592 struct mlme_priv
*pmlmepriv
;
3593 struct eeprom_priv
*pEEPROM
;
3598 pHalData
= GET_HAL_DATA(padapter
);
3599 pmlmepriv
= &padapter
->mlmepriv
;
3600 pEEPROM
= GET_EEPROM_EFUSE_PRIV(padapter
);
3602 if (type
== 0) { /* prepare to join */
3603 /* enable to rx data frame.Accept all data frame */
3604 /* rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR)|RCR_ADF); */
3605 rtw_write16(padapter
, REG_RXFLTMAP2
, 0xFFFF);
3607 val32
= rtw_read32(padapter
, REG_RCR
);
3608 if (padapter
->in_cta_test
)
3609 val32
&= ~(RCR_CBSSID_DATA
| RCR_CBSSID_BCN
);/* RCR_ADF */
3611 val32
|= RCR_CBSSID_DATA
|RCR_CBSSID_BCN
;
3612 rtw_write32(padapter
, REG_RCR
, val32
);
3614 if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) == true)
3615 RetryLimit
= (pEEPROM
->CustomerID
== RT_CID_CCX
) ? 7 : 48;
3616 else /* Ad-hoc Mode */
3618 } else if (type
== 1) /* joinbss_event call back when join res < 0 */
3619 rtw_write16(padapter
, REG_RXFLTMAP2
, 0x00);
3620 else if (type
== 2) { /* sta add event call back */
3621 /* enable update TSF */
3622 val8
= rtw_read8(padapter
, REG_BCN_CTRL
);
3623 val8
&= ~DIS_TSF_UDT
;
3624 rtw_write8(padapter
, REG_BCN_CTRL
, val8
);
3626 if (check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
|WIFI_ADHOC_MASTER_STATE
))
3630 val16
= (RetryLimit
<< RETRY_LIMIT_SHORT_SHIFT
) | (RetryLimit
<< RETRY_LIMIT_LONG_SHIFT
);
3631 rtw_write16(padapter
, REG_RL
, val16
);
3634 void CCX_FwC2HTxRpt_8723b(struct adapter
*padapter
, u8
*pdata
, u8 len
)
3638 #define GET_8723B_C2H_TX_RPT_LIFE_TIME_OVER(_Header) LE_BITS_TO_1BYTE((_Header + 0), 6, 1)
3639 #define GET_8723B_C2H_TX_RPT_RETRY_OVER(_Header) LE_BITS_TO_1BYTE((_Header + 0), 7, 1)
3641 /* DBG_871X("%s, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", __func__, */
3642 /* *pdata, *(pdata+1), *(pdata+2), *(pdata+3), *(pdata+4), *(pdata+5), *(pdata+6), *(pdata+7)); */
3644 seq_no
= *(pdata
+6);
3646 if (GET_8723B_C2H_TX_RPT_RETRY_OVER(pdata
) | GET_8723B_C2H_TX_RPT_LIFE_TIME_OVER(pdata
)) {
3647 rtw_ack_tx_done(&padapter
->xmitpriv
, RTW_SCTX_DONE_CCX_PKT_FAIL
);
3650 else if (seq_no != padapter->xmitpriv.seq_no) {
3651 DBG_871X("tx_seq_no =%d, rpt_seq_no =%d\n", padapter->xmitpriv.seq_no, seq_no);
3652 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
3656 rtw_ack_tx_done(&padapter
->xmitpriv
, RTW_SCTX_DONE_SUCCESS
);
3659 s32
c2h_id_filter_ccx_8723b(u8
*buf
)
3661 struct c2h_evt_hdr_88xx
*c2h_evt
= (struct c2h_evt_hdr_88xx
*)buf
;
3663 if (c2h_evt
->id
== C2H_CCX_TX_RPT
)
3670 s32
c2h_handler_8723b(struct adapter
*padapter
, u8
*buf
)
3672 struct c2h_evt_hdr_88xx
*pC2hEvent
= (struct c2h_evt_hdr_88xx
*)buf
;
3676 if (pC2hEvent
== NULL
) {
3677 DBG_8192C("%s(): pC2hEventis NULL\n", __func__
);
3682 switch (pC2hEvent
->id
) {
3683 case C2H_AP_RPT_RSP
:
3687 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("c2h_handler_8723b: %s\n", pC2hEvent
->payload
));
3691 case C2H_CCX_TX_RPT
:
3692 /* CCX_FwC2HTxRpt(padapter, QueueID, pC2hEvent->payload); */
3695 case C2H_EXT_RA_RPT
:
3696 /* C2HExtRaRptHandler(padapter, pC2hEvent->payload, C2hEvent.CmdLen); */
3699 case C2H_HW_INFO_EXCH
:
3700 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("[BT], C2H_HW_INFO_EXCH\n"));
3701 for (index
= 0; index
< pC2hEvent
->plen
; index
++) {
3702 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("[BT], tmpBuf[%d]= 0x%x\n", index
, pC2hEvent
->payload
[index
]));
3706 case C2H_8723B_BT_INFO
:
3707 rtw_btcoex_BtInfoNotify(padapter
, pC2hEvent
->plen
, pC2hEvent
->payload
);
3714 /* Clear event to notify FW we have read the command. */
3716 /* If this field isn't clear, the FW won't update the next command message. */
3717 /* rtw_write8(padapter, REG_C2HEVT_CLEAR, C2H_EVT_HOST_CLOSE); */
3722 static void process_c2h_event(struct adapter
*padapter
, PC2H_EVT_HDR pC2hEvent
, u8
*c2hBuf
)
3726 if (c2hBuf
== NULL
) {
3727 DBG_8192C("%s c2hbuff is NULL\n", __func__
);
3731 switch (pC2hEvent
->CmdID
) {
3732 case C2H_AP_RPT_RSP
:
3736 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("C2HCommandHandler: %s\n", c2hBuf
));
3740 case C2H_CCX_TX_RPT
:
3741 /* CCX_FwC2HTxRpt(padapter, QueueID, tmpBuf); */
3744 case C2H_EXT_RA_RPT
:
3745 /* C2HExtRaRptHandler(padapter, tmpBuf, C2hEvent.CmdLen); */
3748 case C2H_HW_INFO_EXCH
:
3749 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("[BT], C2H_HW_INFO_EXCH\n"));
3750 for (index
= 0; index
< pC2hEvent
->CmdLen
; index
++) {
3751 RT_TRACE(_module_hal_init_c_
, _drv_info_
, ("[BT], tmpBuf[%d]= 0x%x\n", index
, c2hBuf
[index
]));
3755 case C2H_8723B_BT_INFO
:
3756 rtw_btcoex_BtInfoNotify(padapter
, pC2hEvent
->CmdLen
, c2hBuf
);
3764 void C2HPacketHandler_8723B(struct adapter
*padapter
, u8
*pbuffer
, u16 length
)
3766 C2H_EVT_HDR C2hEvent
;
3768 #ifdef CONFIG_WOWLAN
3769 struct pwrctrl_priv
*pwrpriv
= adapter_to_pwrctl(padapter
);
3771 if (pwrpriv
->wowlan_mode
== true) {
3772 DBG_871X("%s(): return because wowolan_mode ==true! CMDID =%d\n", __func__
, pbuffer
[0]);
3776 C2hEvent
.CmdID
= pbuffer
[0];
3777 C2hEvent
.CmdSeq
= pbuffer
[1];
3778 C2hEvent
.CmdLen
= length
-2;
3781 /* DBG_871X("%s C2hEvent.CmdID:%x C2hEvent.CmdLen:%x C2hEvent.CmdSeq:%x\n", */
3782 /* __func__, C2hEvent.CmdID, C2hEvent.CmdLen, C2hEvent.CmdSeq); */
3783 RT_PRINT_DATA(_module_hal_init_c_
, _drv_notice_
, "C2HPacketHandler_8723B(): Command Content:\n", tmpBuf
, C2hEvent
.CmdLen
);
3785 process_c2h_event(padapter
, &C2hEvent
, tmpBuf
);
3786 /* c2h_handler_8723b(padapter,&C2hEvent); */
3790 void SetHwReg8723B(struct adapter
*padapter
, u8 variable
, u8
*val
)
3792 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
3797 case HW_VAR_MEDIA_STATUS
:
3798 val8
= rtw_read8(padapter
, MSR
) & 0x0c;
3800 rtw_write8(padapter
, MSR
, val8
);
3803 case HW_VAR_MEDIA_STATUS1
:
3804 val8
= rtw_read8(padapter
, MSR
) & 0x03;
3806 rtw_write8(padapter
, MSR
, val8
);
3809 case HW_VAR_SET_OPMODE
:
3810 hw_var_set_opmode(padapter
, variable
, val
);
3813 case HW_VAR_MAC_ADDR
:
3814 hw_var_set_macaddr(padapter
, variable
, val
);
3818 hw_var_set_bssid(padapter
, variable
, val
);
3821 case HW_VAR_BASIC_RATE
:
3823 struct mlme_ext_info
*mlmext_info
= &padapter
->mlmeextpriv
.mlmext_info
;
3824 u16 input_b
= 0, masked
= 0, ioted
= 0, BrateCfg
= 0;
3825 u16 rrsr_2g_force_mask
= (RRSR_11M
|RRSR_5_5M
|RRSR_1M
);
3826 u16 rrsr_2g_allow_mask
= (RRSR_24M
|RRSR_12M
|RRSR_6M
|RRSR_CCK_RATES
);
3828 HalSetBrateCfg(padapter
, val
, &BrateCfg
);
3831 /* apply force and allow mask */
3832 BrateCfg
|= rrsr_2g_force_mask
;
3833 BrateCfg
&= rrsr_2g_allow_mask
;
3836 #ifdef CONFIG_CMCC_TEST
3837 BrateCfg
|= (RRSR_11M
|RRSR_5_5M
|RRSR_1M
); /* use 11M to send ACK */
3838 BrateCfg
|= (RRSR_24M
|RRSR_18M
|RRSR_12M
); /* CMCC_OFDM_ACK 12/18/24M */
3841 /* IOT consideration */
3842 if (mlmext_info
->assoc_AP_vendor
== HT_IOT_PEER_CISCO
) {
3843 /* if peer is cisco and didn't use ofdm rate, we enable 6M ack */
3844 if ((BrateCfg
& (RRSR_24M
|RRSR_12M
|RRSR_6M
)) == 0)
3845 BrateCfg
|= RRSR_6M
;
3849 pHalData
->BasicRateSet
= BrateCfg
;
3851 DBG_8192C("HW_VAR_BASIC_RATE: %#x -> %#x -> %#x\n", input_b
, masked
, ioted
);
3853 /* Set RRSR rate table. */
3854 rtw_write16(padapter
, REG_RRSR
, BrateCfg
);
3855 rtw_write8(padapter
, REG_RRSR
+2, rtw_read8(padapter
, REG_RRSR
+2)&0xf0);
3859 case HW_VAR_TXPAUSE
:
3860 rtw_write8(padapter
, REG_TXPAUSE
, *val
);
3863 case HW_VAR_BCN_FUNC
:
3864 hw_var_set_bcn_func(padapter
, variable
, val
);
3867 case HW_VAR_CORRECT_TSF
:
3868 hw_var_set_correct_tsf(padapter
, variable
, val
);
3871 case HW_VAR_CHECK_BSSID
:
3874 val32
= rtw_read32(padapter
, REG_RCR
);
3876 val32
|= RCR_CBSSID_DATA
|RCR_CBSSID_BCN
;
3878 val32
&= ~(RCR_CBSSID_DATA
|RCR_CBSSID_BCN
);
3879 rtw_write32(padapter
, REG_RCR
, val32
);
3883 case HW_VAR_MLME_DISCONNECT
:
3884 hw_var_set_mlme_disconnect(padapter
, variable
, val
);
3887 case HW_VAR_MLME_SITESURVEY
:
3888 hw_var_set_mlme_sitesurvey(padapter
, variable
, val
);
3890 rtw_btcoex_ScanNotify(padapter
, *val
?true:false);
3893 case HW_VAR_MLME_JOIN
:
3894 hw_var_set_mlme_join(padapter
, variable
, val
);
3898 /* prepare to join */
3899 rtw_btcoex_ConnectNotify(padapter
, true);
3902 /* joinbss_event callback when join res < 0 */
3903 rtw_btcoex_ConnectNotify(padapter
, false);
3906 /* sta add event callback */
3907 /* rtw_btcoex_MediaStatusNotify(padapter, RT_MEDIA_CONNECT); */
3912 case HW_VAR_ON_RCR_AM
:
3913 val32
= rtw_read32(padapter
, REG_RCR
);
3915 rtw_write32(padapter
, REG_RCR
, val32
);
3916 DBG_8192C("%s, %d, RCR = %x\n", __func__
, __LINE__
, rtw_read32(padapter
, REG_RCR
));
3919 case HW_VAR_OFF_RCR_AM
:
3920 val32
= rtw_read32(padapter
, REG_RCR
);
3922 rtw_write32(padapter
, REG_RCR
, val32
);
3923 DBG_8192C("%s, %d, RCR = %x\n", __func__
, __LINE__
, rtw_read32(padapter
, REG_RCR
));
3926 case HW_VAR_BEACON_INTERVAL
:
3927 rtw_write16(padapter
, REG_BCN_INTERVAL
, *((u16
*)val
));
3930 case HW_VAR_SLOT_TIME
:
3931 rtw_write8(padapter
, REG_SLOT
, *val
);
3934 case HW_VAR_RESP_SIFS
:
3935 /* SIFS_Timer = 0x0a0a0808; */
3936 /* RESP_SIFS for CCK */
3937 rtw_write8(padapter
, REG_RESP_SIFS_CCK
, val
[0]); /* SIFS_T2T_CCK (0x08) */
3938 rtw_write8(padapter
, REG_RESP_SIFS_CCK
+1, val
[1]); /* SIFS_R2T_CCK(0x08) */
3939 /* RESP_SIFS for OFDM */
3940 rtw_write8(padapter
, REG_RESP_SIFS_OFDM
, val
[2]); /* SIFS_T2T_OFDM (0x0a) */
3941 rtw_write8(padapter
, REG_RESP_SIFS_OFDM
+1, val
[3]); /* SIFS_R2T_OFDM(0x0a) */
3944 case HW_VAR_ACK_PREAMBLE
:
3947 u8 bShortPreamble
= *val
;
3949 /* Joseph marked out for Netgear 3500 TKIP channel 7 issue.(Temporarily) */
3950 /* regTmp = (pHalData->nCur40MhzPrimeSC)<<5; */
3954 rtw_write8(padapter
, REG_RRSR
+2, regTmp
);
3958 case HW_VAR_CAM_EMPTY_ENTRY
:
3964 u32 ulEncAlgo
= CAM_AES
;
3966 for (i
= 0; i
< CAM_CONTENT_COUNT
; i
++) {
3967 /* filled id in CAM config 2 byte */
3969 ulContent
|= (ucIndex
& 0x03) | ((u16
)(ulEncAlgo
)<<2);
3970 /* ulContent |= CAM_VALID; */
3974 /* polling bit, and No Write enable, and address */
3975 ulCommand
= CAM_CONTENT_COUNT
*ucIndex
+i
;
3976 ulCommand
= ulCommand
| CAM_POLLINIG
| CAM_WRITE
;
3977 /* write content 0 is equall to mark invalid */
3978 rtw_write32(padapter
, WCAMI
, ulContent
); /* mdelay(40); */
3979 /* RT_TRACE(COMP_SEC, DBG_LOUD, ("CAM_empty_entry(): WRITE A4: %lx\n", ulContent)); */
3980 rtw_write32(padapter
, RWCAM
, ulCommand
); /* mdelay(40); */
3981 /* RT_TRACE(COMP_SEC, DBG_LOUD, ("CAM_empty_entry(): WRITE A0: %lx\n", ulCommand)); */
3986 case HW_VAR_CAM_INVALID_ALL
:
3987 rtw_write32(padapter
, RWCAM
, BIT(31)|BIT(30));
3990 case HW_VAR_CAM_WRITE
:
3993 u32
*cam_val
= (u32
*)val
;
3995 rtw_write32(padapter
, WCAMI
, cam_val
[0]);
3997 cmd
= CAM_POLLINIG
| CAM_WRITE
| cam_val
[1];
3998 rtw_write32(padapter
, RWCAM
, cmd
);
4002 case HW_VAR_AC_PARAM_VO
:
4003 rtw_write32(padapter
, REG_EDCA_VO_PARAM
, *((u32
*)val
));
4006 case HW_VAR_AC_PARAM_VI
:
4007 rtw_write32(padapter
, REG_EDCA_VI_PARAM
, *((u32
*)val
));
4010 case HW_VAR_AC_PARAM_BE
:
4011 pHalData
->AcParam_BE
= ((u32
*)(val
))[0];
4012 rtw_write32(padapter
, REG_EDCA_BE_PARAM
, *((u32
*)val
));
4015 case HW_VAR_AC_PARAM_BK
:
4016 rtw_write32(padapter
, REG_EDCA_BK_PARAM
, *((u32
*)val
));
4019 case HW_VAR_ACM_CTRL
:
4021 u8 ctrl
= *((u8
*)val
);
4025 hwctrl
|= AcmHw_HwEn
;
4027 if (ctrl
& BIT(1)) /* BE */
4028 hwctrl
|= AcmHw_BeqEn
;
4030 if (ctrl
& BIT(2)) /* VI */
4031 hwctrl
|= AcmHw_ViqEn
;
4033 if (ctrl
& BIT(3)) /* VO */
4034 hwctrl
|= AcmHw_VoqEn
;
4037 DBG_8192C("[HW_VAR_ACM_CTRL] Write 0x%02X\n", hwctrl
);
4038 rtw_write8(padapter
, REG_ACMHWCTRL
, hwctrl
);
4042 case HW_VAR_AMPDU_FACTOR
:
4044 u32 AMPDULen
= (*((u8
*)val
));
4046 if (AMPDULen
< HT_AGG_SIZE_32K
)
4047 AMPDULen
= (0x2000 << (*((u8
*)val
)))-1;
4051 rtw_write32(padapter
, REG_AMPDU_MAX_LENGTH_8723B
, AMPDULen
);
4055 case HW_VAR_H2C_FW_PWRMODE
:
4059 /* Forece leave RF low power mode for 1T1R to prevent conficting setting in Fw power */
4060 /* saving sequence. 2010.06.07. Added by tynli. Suggested by SD3 yschang. */
4061 if (psmode
!= PS_MODE_ACTIVE
) {
4062 ODM_RF_Saving(&pHalData
->odmpriv
, true);
4065 /* if (psmode != PS_MODE_ACTIVE) { */
4066 /* rtl8723b_set_lowpwr_lps_cmd(padapter, true); */
4068 /* rtl8723b_set_lowpwr_lps_cmd(padapter, false); */
4070 rtl8723b_set_FwPwrMode_cmd(padapter
, psmode
);
4073 case HW_VAR_H2C_PS_TUNE_PARAM
:
4074 rtl8723b_set_FwPsTuneParam_cmd(padapter
);
4077 case HW_VAR_H2C_FW_JOINBSSRPT
:
4078 rtl8723b_set_FwJoinBssRpt_cmd(padapter
, *val
);
4081 case HW_VAR_INITIAL_GAIN
:
4083 DIG_T
*pDigTable
= &pHalData
->odmpriv
.DM_DigTable
;
4084 u32 rx_gain
= *(u32
*)val
;
4086 if (rx_gain
== 0xff) {/* restore rx gain */
4087 ODM_Write_DIG(&pHalData
->odmpriv
, pDigTable
->BackupIGValue
);
4089 pDigTable
->BackupIGValue
= pDigTable
->CurIGValue
;
4090 ODM_Write_DIG(&pHalData
->odmpriv
, rx_gain
);
4095 case HW_VAR_EFUSE_USAGE
:
4096 pHalData
->EfuseUsedPercentage
= *val
;
4099 case HW_VAR_EFUSE_BYTES
:
4100 pHalData
->EfuseUsedBytes
= *((u16
*)val
);
4103 case HW_VAR_EFUSE_BT_USAGE
:
4104 #ifdef HAL_EFUSE_MEMORY
4105 pHalData
->EfuseHal
.BTEfuseUsedPercentage
= *val
;
4109 case HW_VAR_EFUSE_BT_BYTES
:
4110 #ifdef HAL_EFUSE_MEMORY
4111 pHalData
->EfuseHal
.BTEfuseUsedBytes
= *((u16
*)val
);
4113 BTEfuseUsedBytes
= *((u16
*)val
);
4117 case HW_VAR_FIFO_CLEARN_UP
:
4119 #define RW_RELEASE_EN BIT(18)
4120 #define RXDMA_IDLE BIT(17)
4122 struct pwrctrl_priv
*pwrpriv
= adapter_to_pwrctl(padapter
);
4126 rtw_write8(padapter
, REG_TXPAUSE
, 0xff);
4129 padapter
->xmitpriv
.nqos_ssn
= rtw_read16(padapter
, REG_NQOS_SEQ
);
4131 if (pwrpriv
->bkeepfwalive
!= true) {
4133 val32
= rtw_read32(padapter
, REG_RXPKT_NUM
);
4134 val32
|= RW_RELEASE_EN
;
4135 rtw_write32(padapter
, REG_RXPKT_NUM
, val32
);
4137 val32
= rtw_read32(padapter
, REG_RXPKT_NUM
);
4138 val32
&= RXDMA_IDLE
;
4142 DBG_871X("%s: [HW_VAR_FIFO_CLEARN_UP] val =%x times:%d\n", __func__
, val32
, trycnt
);
4146 DBG_8192C("[HW_VAR_FIFO_CLEARN_UP] Stop RX DMA failed......\n");
4150 rtw_write16(padapter
, REG_RQPN_NPQ
, 0);
4151 rtw_write32(padapter
, REG_RQPN
, 0x80000000);
4157 case HW_VAR_APFM_ON_MAC
:
4158 pHalData
->bMacPwrCtrlOn
= *val
;
4159 DBG_8192C("%s: bMacPwrCtrlOn =%d\n", __func__
, pHalData
->bMacPwrCtrlOn
);
4162 case HW_VAR_NAV_UPPER
:
4164 u32 usNavUpper
= *((u32
*)val
);
4166 if (usNavUpper
> HAL_NAV_UPPER_UNIT_8723B
* 0xFF) {
4167 RT_TRACE(_module_hal_init_c_
, _drv_notice_
, ("The setting value (0x%08X us) of NAV_UPPER is larger than (%d * 0xFF)!!!\n", usNavUpper
, HAL_NAV_UPPER_UNIT_8723B
));
4171 /* The value of ((usNavUpper + HAL_NAV_UPPER_UNIT_8723B - 1) / HAL_NAV_UPPER_UNIT_8723B) */
4172 /* is getting the upper integer. */
4173 usNavUpper
= (usNavUpper
+ HAL_NAV_UPPER_UNIT_8723B
- 1) / HAL_NAV_UPPER_UNIT_8723B
;
4174 rtw_write8(padapter
, REG_NAV_UPPER
, (u8
)usNavUpper
);
4178 case HW_VAR_H2C_MEDIA_STATUS_RPT
:
4180 u16 mstatus_rpt
= (*(u16
*)val
);
4183 mstatus
= (u8
) (mstatus_rpt
& 0xFF);
4184 macId
= (u8
)(mstatus_rpt
>> 8);
4185 rtl8723b_set_FwMediaStatusRpt_cmd(padapter
, mstatus
, macId
);
4188 case HW_VAR_BCN_VALID
:
4190 /* BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2, write 1 to clear, Clear by sw */
4191 val8
= rtw_read8(padapter
, REG_TDECTRL
+2);
4193 rtw_write8(padapter
, REG_TDECTRL
+2, val8
);
4197 case HW_VAR_DL_BCN_SEL
:
4199 /* SW_BCN_SEL - Port0 */
4200 val8
= rtw_read8(padapter
, REG_DWBCN1_CTRL_8723B
+2);
4202 rtw_write8(padapter
, REG_DWBCN1_CTRL_8723B
+2, val8
);
4207 pHalData
->bNeedIQK
= true;
4210 case HW_VAR_DL_RSVD_PAGE
:
4211 if (check_fwstate(&padapter
->mlmepriv
, WIFI_AP_STATE
) == true)
4212 rtl8723b_download_BTCoex_AP_mode_rsvd_page(padapter
);
4214 rtl8723b_download_rsvd_page(padapter
, RT_MEDIA_CONNECT
);
4217 case HW_VAR_MACID_SLEEP
:
4218 /* Input is MACID */
4219 val32
= *(u32
*)val
;
4221 DBG_8192C(FUNC_ADPT_FMT
": [HW_VAR_MACID_SLEEP] Invalid macid(%d)\n",
4222 FUNC_ADPT_ARG(padapter
), val32
);
4225 val8
= (u8
)val32
; /* macid is between 0~31 */
4227 val32
= rtw_read32(padapter
, REG_MACID_SLEEP
);
4228 DBG_8192C(FUNC_ADPT_FMT
": [HW_VAR_MACID_SLEEP] macid =%d, org MACID_SLEEP = 0x%08X\n",
4229 FUNC_ADPT_ARG(padapter
), val8
, val32
);
4230 if (val32
& BIT(val8
))
4233 rtw_write32(padapter
, REG_MACID_SLEEP
, val32
);
4236 case HW_VAR_MACID_WAKEUP
:
4237 /* Input is MACID */
4238 val32
= *(u32
*)val
;
4240 DBG_8192C(FUNC_ADPT_FMT
": [HW_VAR_MACID_WAKEUP] Invalid macid(%d)\n",
4241 FUNC_ADPT_ARG(padapter
), val32
);
4244 val8
= (u8
)val32
; /* macid is between 0~31 */
4246 val32
= rtw_read32(padapter
, REG_MACID_SLEEP
);
4247 DBG_8192C(FUNC_ADPT_FMT
": [HW_VAR_MACID_WAKEUP] macid =%d, org MACID_SLEEP = 0x%08X\n",
4248 FUNC_ADPT_ARG(padapter
), val8
, val32
);
4249 if (!(val32
& BIT(val8
)))
4251 val32
&= ~BIT(val8
);
4252 rtw_write32(padapter
, REG_MACID_SLEEP
, val32
);
4256 SetHwReg(padapter
, variable
, val
);
4261 void GetHwReg8723B(struct adapter
*padapter
, u8 variable
, u8
*val
)
4263 struct hal_com_data
*pHalData
= GET_HAL_DATA(padapter
);
4268 case HW_VAR_TXPAUSE
:
4269 *val
= rtw_read8(padapter
, REG_TXPAUSE
);
4272 case HW_VAR_BCN_VALID
:
4274 /* BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2 */
4275 val8
= rtw_read8(padapter
, REG_TDECTRL
+2);
4276 *val
= (BIT(0) & val8
) ? true : false;
4280 case HW_VAR_FWLPS_RF_ON
:
4282 /* When we halt NIC, we should check if FW LPS is leave. */
4286 (padapter
->bSurpriseRemoved
== true) ||
4287 (adapter_to_pwrctl(padapter
)->rf_pwrstate
== rf_off
)
4289 /* If it is in HW/SW Radio OFF or IPS state, we do not check Fw LPS Leave, */
4290 /* because Fw is unload. */
4293 valRCR
= rtw_read32(padapter
, REG_RCR
);
4294 valRCR
&= 0x00070000;
4303 case HW_VAR_EFUSE_USAGE
:
4304 *val
= pHalData
->EfuseUsedPercentage
;
4307 case HW_VAR_EFUSE_BYTES
:
4308 *((u16
*)val
) = pHalData
->EfuseUsedBytes
;
4311 case HW_VAR_EFUSE_BT_USAGE
:
4312 #ifdef HAL_EFUSE_MEMORY
4313 *val
= pHalData
->EfuseHal
.BTEfuseUsedPercentage
;
4317 case HW_VAR_EFUSE_BT_BYTES
:
4318 #ifdef HAL_EFUSE_MEMORY
4319 *((u16
*)val
) = pHalData
->EfuseHal
.BTEfuseUsedBytes
;
4321 *((u16
*)val
) = BTEfuseUsedBytes
;
4325 case HW_VAR_APFM_ON_MAC
:
4326 *val
= pHalData
->bMacPwrCtrlOn
;
4328 case HW_VAR_CHK_HI_QUEUE_EMPTY
:
4329 val16
= rtw_read16(padapter
, REG_TXPKT_EMPTY
);
4330 *val
= (val16
& BIT(10)) ? true:false;
4332 #ifdef CONFIG_WOWLAN
4333 case HW_VAR_RPWM_TOG
:
4334 *val
= rtw_read8(padapter
, SDIO_LOCAL_BASE
|SDIO_REG_HRPWM1
) & BIT7
;
4336 case HW_VAR_WAKEUP_REASON
:
4337 *val
= rtw_read8(padapter
, REG_WOWLAN_WAKE_REASON
);
4341 case HW_VAR_SYS_CLKR
:
4342 *val
= rtw_read8(padapter
, REG_SYS_CLKR
);
4346 GetHwReg(padapter
, variable
, val
);
4353 * Change default setting of specified variable.
4355 u8
SetHalDefVar8723B(struct adapter
*padapter
, enum HAL_DEF_VARIABLE variable
, void *pval
)
4357 struct hal_com_data
*pHalData
;
4361 pHalData
= GET_HAL_DATA(padapter
);
4366 bResult
= SetHalDefVar(padapter
, variable
, pval
);
4375 * Query setting of specified variable.
4377 u8
GetHalDefVar8723B(struct adapter
*padapter
, enum HAL_DEF_VARIABLE variable
, void *pval
)
4379 struct hal_com_data
*pHalData
;
4383 pHalData
= GET_HAL_DATA(padapter
);
4387 case HAL_DEF_MAX_RECVBUF_SZ
:
4388 *((u32
*)pval
) = MAX_RECVBUF_SZ
;
4391 case HAL_DEF_RX_PACKET_OFFSET
:
4392 *((u32
*)pval
) = RXDESC_SIZE
+ DRVINFO_SZ
*8;
4395 case HW_VAR_MAX_RX_AMPDU_FACTOR
:
4396 /* Stanley@BB.SD3 suggests 16K can get stable performance */
4397 /* The experiment was done on SDIO interface */
4398 /* coding by Lucas@20130730 */
4399 *(u32
*)pval
= MAX_AMPDU_FACTOR_16K
;
4401 case HAL_DEF_TX_LDPC
:
4402 case HAL_DEF_RX_LDPC
:
4403 *((u8
*)pval
) = false;
4405 case HAL_DEF_TX_STBC
:
4408 case HAL_DEF_RX_STBC
:
4411 case HAL_DEF_EXPLICIT_BEAMFORMER
:
4412 case HAL_DEF_EXPLICIT_BEAMFORMEE
:
4413 *((u8
*)pval
) = false;
4416 case HW_DEF_RA_INFO_DUMP
:
4418 u8 mac_id
= *(u8
*)pval
;
4420 u32 ra_info1
, ra_info2
;
4421 u32 rate_mask1
, rate_mask2
;
4422 u8 curr_tx_rate
, curr_tx_sgi
, hight_rate
, lowest_rate
;
4424 DBG_8192C("============ RA status check Mac_id:%d ===================\n", mac_id
);
4426 cmd
= 0x40000100 | mac_id
;
4427 rtw_write32(padapter
, REG_HMEBOX_DBG_2_8723B
, cmd
);
4429 ra_info1
= rtw_read32(padapter
, 0x2F0);
4430 curr_tx_rate
= ra_info1
&0x7F;
4431 curr_tx_sgi
= (ra_info1
>>7)&0x01;
4432 DBG_8192C("[ ra_info1:0x%08x ] =>cur_tx_rate = %s, cur_sgi:%d, PWRSTS = 0x%02x \n",
4434 HDATA_RATE(curr_tx_rate
),
4436 (ra_info1
>>8) & 0x07);
4438 cmd
= 0x40000400 | mac_id
;
4439 rtw_write32(padapter
, REG_HMEBOX_DBG_2_8723B
, cmd
);
4441 ra_info1
= rtw_read32(padapter
, 0x2F0);
4442 ra_info2
= rtw_read32(padapter
, 0x2F4);
4443 rate_mask1
= rtw_read32(padapter
, 0x2F8);
4444 rate_mask2
= rtw_read32(padapter
, 0x2FC);
4445 hight_rate
= ra_info2
&0xFF;
4446 lowest_rate
= (ra_info2
>>8) & 0xFF;
4448 DBG_8192C("[ ra_info1:0x%08x ] =>RSSI =%d, BW_setting = 0x%02x, DISRA = 0x%02x, VHT_EN = 0x%02x\n",
4451 (ra_info1
>>8) & 0xFF,
4452 (ra_info1
>>16) & 0xFF,
4453 (ra_info1
>>24) & 0xFF);
4455 DBG_8192C("[ ra_info2:0x%08x ] =>hight_rate =%s, lowest_rate =%s, SGI = 0x%02x, RateID =%d\n",
4457 HDATA_RATE(hight_rate
),
4458 HDATA_RATE(lowest_rate
),
4459 (ra_info2
>>16) & 0xFF,
4460 (ra_info2
>>24) & 0xFF);
4462 DBG_8192C("rate_mask2 = 0x%08x, rate_mask1 = 0x%08x\n", rate_mask2
, rate_mask1
);
4467 case HAL_DEF_TX_PAGE_BOUNDARY
:
4468 if (!padapter
->registrypriv
.wifi_spec
) {
4469 *(u8
*)pval
= TX_PAGE_BOUNDARY_8723B
;
4471 *(u8
*)pval
= WMM_NORMAL_TX_PAGE_BOUNDARY_8723B
;
4475 case HAL_DEF_MACID_SLEEP
:
4476 *(u8
*)pval
= true; /* support macid sleep */
4480 bResult
= GetHalDefVar(padapter
, variable
, pval
);
4487 #ifdef CONFIG_WOWLAN
4488 void Hal_DetectWoWMode(struct adapter
*padapter
)
4490 adapter_to_pwrctl(padapter
)->bSupportRemoteWakeup
= true;
4491 DBG_871X("%s\n", __func__
);
4493 #endif /* CONFIG_WOWLAN */
4495 void rtl8723b_start_thread(struct adapter
*padapter
)
4497 #ifndef CONFIG_SDIO_TX_TASKLET
4498 struct xmit_priv
*xmitpriv
= &padapter
->xmitpriv
;
4500 xmitpriv
->SdioXmitThread
= kthread_run(rtl8723bs_xmit_thread
, padapter
, "RTWHALXT");
4501 if (IS_ERR(xmitpriv
->SdioXmitThread
)) {
4502 RT_TRACE(_module_hal_xmit_c_
, _drv_err_
, ("%s: start rtl8723bs_xmit_thread FAIL!!\n", __func__
));
4507 void rtl8723b_stop_thread(struct adapter
*padapter
)
4509 #ifndef CONFIG_SDIO_TX_TASKLET
4510 struct xmit_priv
*xmitpriv
= &padapter
->xmitpriv
;
4512 /* stop xmit_buf_thread */
4513 if (xmitpriv
->SdioXmitThread
) {
4514 up(&xmitpriv
->SdioXmitSema
);
4515 down(&xmitpriv
->SdioXmitTerminateSema
);
4516 xmitpriv
->SdioXmitThread
= NULL
;
4521 #if defined(CONFIG_CHECK_BT_HANG)
4522 extern void check_bt_status_work(void *data
);
4523 void rtl8723bs_init_checkbthang_workqueue(struct adapter
*adapter
)
4525 adapter
->priv_checkbt_wq
= alloc_workqueue("sdio_wq", 0, 0);
4526 INIT_DELAYED_WORK(&adapter
->checkbt_work
, (void *)check_bt_status_work
);
4529 void rtl8723bs_free_checkbthang_workqueue(struct adapter
*adapter
)
4531 if (adapter
->priv_checkbt_wq
) {
4532 cancel_delayed_work_sync(&adapter
->checkbt_work
);
4533 flush_workqueue(adapter
->priv_checkbt_wq
);
4534 destroy_workqueue(adapter
->priv_checkbt_wq
);
4535 adapter
->priv_checkbt_wq
= NULL
;
4539 void rtl8723bs_cancle_checkbthang_workqueue(struct adapter
*adapter
)
4541 if (adapter
->priv_checkbt_wq
)
4542 cancel_delayed_work_sync(&adapter
->checkbt_work
);
4545 void rtl8723bs_hal_check_bt_hang(struct adapter
*adapter
)
4547 if (adapter
->priv_checkbt_wq
)
4548 queue_delayed_work(adapter
->priv_checkbt_wq
, &(adapter
->checkbt_work
), 0);