Moved, renamed, and deleted files

The original directory structure was scattered and unorganized.
Changes are basically to make it look like kernel structure.

15 files changed, 18532 insertions, 0 deletions

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/Hal8188EPwrSeq.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/Hal8188EPwrSeq.c
new file mode 100644
index 00000000..c38c25a0
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/Hal8188EPwrSeq.c
@@ -0,0 +1,97 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *                                        

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+

+#include "Hal8188EPwrSeq.h"

+#include <rtl8188e_hal.h>

+

+/* 

+    drivers should parse below arrays and do the corresponding actions

+*/

+//3 Power on  Array

+WLAN_PWR_CFG rtl8188E_power_on_flow[RTL8188E_TRANS_CARDEMU_TO_ACT_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_CARDEMU_TO_ACT

+	RTL8188E_TRANS_END

+};

+

+//3Radio off Array

+WLAN_PWR_CFG rtl8188E_radio_off_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_ACT_TO_CARDEMU

+	RTL8188E_TRANS_END

+};

+

+//3Card Disable Array

+WLAN_PWR_CFG rtl8188E_card_disable_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_CARDEMU_TO_PDN_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_ACT_TO_CARDEMU

+	RTL8188E_TRANS_CARDEMU_TO_CARDDIS

+	RTL8188E_TRANS_END

+};

+

+//3 Card Enable Array

+WLAN_PWR_CFG rtl8188E_card_enable_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_CARDEMU_TO_PDN_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_CARDDIS_TO_CARDEMU

+	RTL8188E_TRANS_CARDEMU_TO_ACT

+	RTL8188E_TRANS_END

+};

+

+//3Suspend Array

+WLAN_PWR_CFG rtl8188E_suspend_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_CARDEMU_TO_SUS_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_ACT_TO_CARDEMU

+	RTL8188E_TRANS_CARDEMU_TO_SUS

+	RTL8188E_TRANS_END

+};

+

+//3 Resume Array

+WLAN_PWR_CFG rtl8188E_resume_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_CARDEMU_TO_SUS_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_SUS_TO_CARDEMU

+	RTL8188E_TRANS_CARDEMU_TO_ACT

+	RTL8188E_TRANS_END

+};

+

+

+//3HWPDN Array

+WLAN_PWR_CFG rtl8188E_hwpdn_flow[RTL8188E_TRANS_ACT_TO_CARDEMU_STEPS+RTL8188E_TRANS_CARDEMU_TO_PDN_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	RTL8188E_TRANS_ACT_TO_CARDEMU

+	RTL8188E_TRANS_CARDEMU_TO_PDN	

+	RTL8188E_TRANS_END

+};

+

+//3 Enter LPS 

+WLAN_PWR_CFG rtl8188E_enter_lps_flow[RTL8188E_TRANS_ACT_TO_LPS_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	//FW behavior

+	RTL8188E_TRANS_ACT_TO_LPS	

+	RTL8188E_TRANS_END

+};

+

+//3 Leave LPS 

+WLAN_PWR_CFG rtl8188E_leave_lps_flow[RTL8188E_TRANS_LPS_TO_ACT_STEPS+RTL8188E_TRANS_END_STEPS]=

+{

+	//FW behavior

+	RTL8188E_TRANS_LPS_TO_ACT

+	RTL8188E_TRANS_END

+};

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_cmd.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_cmd.c
new file mode 100644
index 00000000..70b22c19
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_cmd.c
@@ -0,0 +1,1482 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+#define _RTL8188E_CMD_C_

+

+#include <drv_types.h>

+#include <rtl8188e_hal.h>

+#include "hal_com_h2c.h"

+

+#define CONFIG_H2C_EF

+

+#define RTL88E_MAX_H2C_BOX_NUMS	4

+#define RTL88E_MAX_CMD_LEN	7

+#define RTL88E_MESSAGE_BOX_SIZE		4

+#define RTL88E_EX_MESSAGE_BOX_SIZE	4

+

+static u8 _is_fw_read_cmd_down(_adapter* padapter, u8 msgbox_num)

+{

+	u8	read_down = _FALSE;

+	int	retry_cnts = 100;

+

+	u8 valid;

+

+	//DBG_8192C(" _is_fw_read_cmd_down ,reg_1cc(%x),msg_box(%d)...\n",rtw_read8(padapter,REG_HMETFR),msgbox_num);

+

+	do{

+		valid = rtw_read8(padapter,REG_HMETFR) & BIT(msgbox_num);

+		if(0 == valid ){

+			read_down = _TRUE;

+		}

+#ifdef CONFIG_WOWLAN

+		rtw_msleep_os(2);

+#endif

+	}while( (!read_down) && (retry_cnts--));

+

+	return read_down;

+

+}

+

+

+/*****************************************

+* H2C Msg format :

+* 0x1DF - 0x1D0

+*| 31 - 8	| 7-5 	 4 - 0	|

+*| h2c_msg 	|Class_ID CMD_ID	|

+*

+* Extend 0x1FF - 0x1F0

+*|31 - 0	  |

+*|ext_msg|

+******************************************/

+static s32 FillH2CCmd_88E(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)

+{

+	struct dvobj_priv *dvobj =  adapter_to_dvobj(padapter);

+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);

+	u8 h2c_box_num;

+	u32	msgbox_addr;

+	u32 msgbox_ex_addr;

+	u8 cmd_idx,ext_cmd_len;

+	u32	h2c_cmd = 0;

+	u32	h2c_cmd_ex = 0;

+	s32 ret = _FAIL;

+

+_func_enter_;

+

+	padapter = GET_PRIMARY_ADAPTER(padapter);		

+	pHalData = GET_HAL_DATA(padapter);

+

+	if(padapter->bFWReady == _FALSE)

+	{

+		DBG_8192C("FillH2CCmd_88E(): return H2C cmd because fw is not ready\n");

+		return ret;

+	}

+

+	_enter_critical_mutex(&(dvobj->h2c_fwcmd_mutex), NULL);

+

+	if (!pCmdBuffer) {

+		goto exit;

+	}

+	if (CmdLen > RTL88E_MAX_CMD_LEN) {

+		goto exit;

+	}

+	if (padapter->bSurpriseRemoved == _TRUE)

+		goto exit;

+

+	//pay attention to if  race condition happened in  H2C cmd setting.

+	do{

+		h2c_box_num = pHalData->LastHMEBoxNum;

+

+		if(!_is_fw_read_cmd_down(padapter, h2c_box_num)){

+			DBG_8192C(" fw read cmd failed...\n");

+			goto exit;

+		}

+

+		*(u8*)(&h2c_cmd) = ElementID;

+

+		if(CmdLen<=3)

+		{

+			_rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer, CmdLen );

+		}

+		else{			

+			_rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer,3);

+			ext_cmd_len = CmdLen-3;	

+			_rtw_memcpy((u8*)(&h2c_cmd_ex), pCmdBuffer+3,ext_cmd_len );

+

+			//Write Ext command

+			msgbox_ex_addr = REG_HMEBOX_EXT_0 + (h2c_box_num *RTL88E_EX_MESSAGE_BOX_SIZE);

+			#ifdef CONFIG_H2C_EF

+			for(cmd_idx=0;cmd_idx<ext_cmd_len;cmd_idx++ ){

+				rtw_write8(padapter,msgbox_ex_addr+cmd_idx,*((u8*)(&h2c_cmd_ex)+cmd_idx));

+			}

+			#else

+			h2c_cmd_ex = le32_to_cpu( h2c_cmd_ex );

+			rtw_write32(padapter, msgbox_ex_addr, h2c_cmd_ex);

+			#endif

+		}

+		// Write command

+		msgbox_addr =REG_HMEBOX_0 + (h2c_box_num *RTL88E_MESSAGE_BOX_SIZE);

+		#ifdef CONFIG_H2C_EF

+		for(cmd_idx=0;cmd_idx<RTL88E_MESSAGE_BOX_SIZE;cmd_idx++ ){

+			rtw_write8(padapter,msgbox_addr+cmd_idx,*((u8*)(&h2c_cmd)+cmd_idx));

+		}

+		#else

+		h2c_cmd = le32_to_cpu( h2c_cmd );

+		rtw_write32(padapter,msgbox_addr, h2c_cmd);

+		#endif

+		

+

+	//	DBG_8192C("MSG_BOX:%d,CmdLen(%d), reg:0x%x =>h2c_cmd:0x%x, reg:0x%x =>h2c_cmd_ex:0x%x ..\n"

+	//	 	,pHalData->LastHMEBoxNum ,CmdLen,msgbox_addr,h2c_cmd,msgbox_ex_addr,h2c_cmd_ex);

+

+		pHalData->LastHMEBoxNum = (h2c_box_num+1) % RTL88E_MAX_H2C_BOX_NUMS;

+

+	}while(0);

+

+	ret = _SUCCESS;

+

+exit:

+

+	_exit_critical_mutex(&(dvobj->h2c_fwcmd_mutex), NULL);

+

+_func_exit_;

+

+	return ret;

+}

+

+u8 rtl8192c_h2c_msg_hdl(_adapter *padapter, unsigned char *pbuf)

+{

+	u8 ElementID, CmdLen;

+	u8 *pCmdBuffer;

+	struct cmd_msg_parm  *pcmdmsg;

+

+	if(!pbuf)

+		return H2C_PARAMETERS_ERROR;

+

+	pcmdmsg = (struct cmd_msg_parm*)pbuf;

+	ElementID = pcmdmsg->eid;

+	CmdLen = pcmdmsg->sz;

+	pCmdBuffer = pcmdmsg->buf;

+

+	FillH2CCmd_88E(padapter, ElementID, CmdLen, pCmdBuffer);

+

+	return H2C_SUCCESS;

+}

+/*

+#if defined(CONFIG_AUTOSUSPEND) && defined(SUPPORT_HW_RFOFF_DETECTED)

+u8 rtl8192c_set_FwSelectSuspend_cmd(_adapter *padapter ,u8 bfwpoll, u16 period)

+{

+	u8	res=_SUCCESS;

+	struct H2C_SS_RFOFF_PARAM param;

+	DBG_8192C("==>%s bfwpoll(%x)\n",__FUNCTION__,bfwpoll);

+	param.gpio_period = period;//Polling GPIO_11 period time

+	param.ROFOn = (_TRUE == bfwpoll)?1:0;

+	FillH2CCmd_88E(padapter, SELECTIVE_SUSPEND_ROF_CMD, sizeof(param), (u8*)(&param));		

+	return res;

+}

+#endif //CONFIG_AUTOSUSPEND && SUPPORT_HW_RFOFF_DETECTED

+*/

+u8 rtl8188e_set_rssi_cmd(_adapter*padapter, u8 *param)

+{

+	u8	res=_SUCCESS;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+_func_enter_;

+

+	if(pHalData->fw_ractrl == _TRUE){

+		#if 0

+	*((u32*) param ) = cpu_to_le32( *((u32*) param ) );

+

+		FillH2CCmd_88E(padapter, RSSI_SETTING_EID, 3, param);

+		#endif

+	}else{

+		DBG_8192C("==>%s fw dont support RA \n",__FUNCTION__);

+		res=_FAIL;

+	}

+

+_func_exit_;

+

+	return res;

+}

+

+u8 rtl8188e_set_raid_cmd(_adapter*padapter, u32 mask)

+{

+	u8	buf[3];

+	u8	res=_SUCCESS;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+_func_enter_;

+	if(pHalData->fw_ractrl == _TRUE){

+		_rtw_memset(buf, 0, 3);

+		mask = cpu_to_le32( mask );

+		_rtw_memcpy(buf, &mask, 3);		

+

+		FillH2CCmd_88E(padapter, H2C_DM_MACID_CFG, 3, buf);

+	}else{

+		DBG_8192C("==>%s fw dont support RA \n",__FUNCTION__);

+		res=_FAIL;

+	}	

+

+_func_exit_;

+

+	return res;

+

+}

+

+//bitmap[0:27] = tx_rate_bitmap

+//bitmap[28:31]= Rate Adaptive id

+//arg[0:4] = macid

+//arg[5] = Short GI

+void rtl8188e_Add_RateATid(PADAPTER pAdapter, u32 bitmap, u8* arg, u8 rssi_level)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	u8 macid, init_rate, raid, shortGIrate=_FALSE;

+

+	macid = arg[0];

+	raid = arg[1];

+	shortGIrate = arg[2];

+	init_rate = arg[3];

+

+	bitmap &=0x0fffffff;	

+	

+	if(rssi_level != DM_RATR_STA_INIT)

+		bitmap = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, macid, bitmap, rssi_level);		

+

+	if (shortGIrate==_TRUE)

+		init_rate |= BIT(6);

+

+	bitmap &= 0x0fffffff;

+	

+	DBG_871X("%s=> mac_id:%d , raid:%d , ra_bitmap=0x%x, shortGIrate=0x%02x\n", 

+			__FUNCTION__,macid ,raid ,bitmap, shortGIrate);

+

+

+#if(RATE_ADAPTIVE_SUPPORT == 1)

+	ODM_RA_UpdateRateInfo_8188E(

+			&(pHalData->odmpriv),

+			macid,

+			raid, 

+			bitmap,

+			shortGIrate

+			);

+#endif	

+

+}

+

+void rtl8188e_set_FwPwrMode_cmd(PADAPTER padapter, u8 Mode)

+{

+	SETPWRMODE_PARM H2CSetPwrMode;

+	struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);

+	u8	RLBM = 0; // 0:Min, 1:Max , 2:User define

+_func_enter_;

+

+	DBG_871X("%s: Mode=%d SmartPS=%d UAPSD=%d\n", __FUNCTION__,

+			Mode, pwrpriv->smart_ps, padapter->registrypriv.uapsd_enable);

+

+	H2CSetPwrMode.AwakeInterval = 2;	//DTIM = 1

+

+	switch(Mode)

+	{

+		case PS_MODE_ACTIVE:

+			H2CSetPwrMode.Mode = 0;

+			break;

+		case PS_MODE_MIN:

+			H2CSetPwrMode.Mode = 1;

+			break;

+		case PS_MODE_MAX:

+			RLBM = 1;

+			H2CSetPwrMode.Mode = 1;

+			break;

+		case PS_MODE_DTIM:

+			RLBM = 2;

+			H2CSetPwrMode.AwakeInterval = 3; //DTIM = 2

+			H2CSetPwrMode.Mode = 1;

+			break;

+		case PS_MODE_UAPSD_WMM:

+			H2CSetPwrMode.Mode = 2;

+			break;

+		default:

+			H2CSetPwrMode.Mode = 0;

+			break;

+	}

+

+	//H2CSetPwrMode.Mode = Mode;

+

+	H2CSetPwrMode.SmartPS_RLBM = (((pwrpriv->smart_ps<<4)&0xf0) | (RLBM & 0x0f));

+

+	H2CSetPwrMode.bAllQueueUAPSD = padapter->registrypriv.uapsd_enable;

+

+	if(Mode > 0)

+	{

+		H2CSetPwrMode.PwrState = 0x00;// AllON(0x0C), RFON(0x04), RFOFF(0x00)

+#ifdef CONFIG_EXT_CLK

+		H2CSetPwrMode.Mode |= BIT(7);//supporting 26M XTAL CLK_Request feature.

+#endif //CONFIG_EXT_CLK

+	}

+	else

+		H2CSetPwrMode.PwrState = 0x0C;// AllON(0x0C), RFON(0x04), RFOFF(0x00)

+

+	FillH2CCmd_88E(padapter, H2C_PS_PWR_MODE, sizeof(H2CSetPwrMode), (u8 *)&H2CSetPwrMode);

+	

+

+_func_exit_;

+}

+

+void rtl8188e_set_FwMediaStatus_cmd(PADAPTER padapter, u16 mstatus_rpt )

+{

+	u8 opmode,macid;

+	u16 mst_rpt = cpu_to_le16 (mstatus_rpt);

+	u32 reg_macid_no_link = REG_MACID_NO_LINK_0;

+	opmode = (u8) mst_rpt;

+	macid = (u8)(mst_rpt >> 8)  ;

+	DBG_871X("### %s: MStatus=%x MACID=%d \n", __FUNCTION__,opmode,macid);

+	FillH2CCmd_88E(padapter, H2C_COM_MEDIA_STATUS_RPT, sizeof(mst_rpt), (u8 *)&mst_rpt);	

+

+	if(macid > 31){

+		macid = macid-32;

+		reg_macid_no_link = REG_MACID_NO_LINK_1;

+	}

+	

+	//Delete select macid (MACID 0~63) from queue list.

+	if(opmode == 1)// 1:connect

+	{

+		rtw_write32(padapter,reg_macid_no_link, (rtw_read32(padapter,reg_macid_no_link) & (~BIT(macid))));

+	}

+	else//0: disconnect

+	{

+		rtw_write32(padapter,reg_macid_no_link, (rtw_read32(padapter,reg_macid_no_link)|BIT(macid)));

+	}

+	

+	

+	

+}

+

+void ConstructBeacon(_adapter *padapter, u8 *pframe, u32 *pLength)

+{

+	struct rtw_ieee80211_hdr	*pwlanhdr;

+	u16					*fctrl;

+	u32					rate_len, pktlen;

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+	WLAN_BSSID_EX 		*cur_network = &(pmlmeinfo->network);

+	u8	bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

+

+

+	//DBG_871X("%s\n", __FUNCTION__);

+

+	pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;

+

+	fctrl = &(pwlanhdr->frame_ctl);

+	*(fctrl) = 0;

+

+	_rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);

+

+	SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);

+	//pmlmeext->mgnt_seq++;

+	SetFrameSubType(pframe, WIFI_BEACON);

+

+	pframe += sizeof(struct rtw_ieee80211_hdr_3addr);

+	pktlen = sizeof (struct rtw_ieee80211_hdr_3addr);

+

+	//timestamp will be inserted by hardware

+	pframe += 8;

+	pktlen += 8;

+

+	// beacon interval: 2 bytes

+	_rtw_memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);

+

+	pframe += 2;

+	pktlen += 2;

+

+	// capability info: 2 bytes

+	_rtw_memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);

+

+	pframe += 2;

+	pktlen += 2;

+

+	if( (pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)

+	{

+		//DBG_871X("ie len=%d\n", cur_network->IELength);

+		pktlen += cur_network->IELength - sizeof(NDIS_802_11_FIXED_IEs);

+		_rtw_memcpy(pframe, cur_network->IEs+sizeof(NDIS_802_11_FIXED_IEs), pktlen);

+

+		goto _ConstructBeacon;

+	}

+

+	//below for ad-hoc mode

+

+	// SSID

+	pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pktlen);

+

+	// supported rates...

+	rate_len = rtw_get_rateset_len(cur_network->SupportedRates);

+	pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8)? 8: rate_len), cur_network->SupportedRates, &pktlen);

+

+	// DS parameter set

+	pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pktlen);

+

+	if( (pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE)

+	{

+		u32 ATIMWindow;

+		// IBSS Parameter Set...

+		//ATIMWindow = cur->Configuration.ATIMWindow;

+		ATIMWindow = 0;

+		pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pktlen);

+	}

+

+

+	//todo: ERP IE

+

+

+	// EXTERNDED SUPPORTED RATE

+	if (rate_len > 8)

+	{

+		pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pktlen);

+	}

+

+

+	//todo:HT for adhoc

+

+_ConstructBeacon:

+

+	if ((pktlen + TXDESC_SIZE) > 512)

+	{

+		DBG_871X("beacon frame too large\n");

+		return;

+	}

+

+	*pLength = pktlen;

+

+	//DBG_871X("%s bcn_sz=%d\n", __FUNCTION__, pktlen);

+

+}

+

+void ConstructPSPoll(_adapter *padapter, u8 *pframe, u32 *pLength)

+{

+	struct rtw_ieee80211_hdr	*pwlanhdr;

+	u16					*fctrl;

+	u32					pktlen;

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+

+	//DBG_871X("%s\n", __FUNCTION__);

+

+	pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;

+

+	// Frame control.

+	fctrl = &(pwlanhdr->frame_ctl);

+	*(fctrl) = 0;

+	SetPwrMgt(fctrl);

+	SetFrameSubType(pframe, WIFI_PSPOLL);

+

+	// AID.

+	SetDuration(pframe, (pmlmeinfo->aid | 0xc000));

+

+	// BSSID.

+	_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+

+	// TA.

+	_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);

+

+	*pLength = 16;

+}

+

+void ConstructNullFunctionData(

+	PADAPTER padapter,

+	u8		*pframe,

+	u32		*pLength,

+	u8		*StaAddr,

+	u8		bQoS,

+	u8		AC,

+	u8		bEosp,

+	u8		bForcePowerSave)

+{

+	struct rtw_ieee80211_hdr	*pwlanhdr;

+	u16						*fctrl;

+	u32						pktlen;

+	struct mlme_priv		*pmlmepriv = &padapter->mlmepriv;

+	struct wlan_network		*cur_network = &pmlmepriv->cur_network;

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+

+

+	//DBG_871X("%s:%d\n", __FUNCTION__, bForcePowerSave);

+

+	pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;

+

+	fctrl = &pwlanhdr->frame_ctl;

+	*(fctrl) = 0;

+	if (bForcePowerSave)

+	{

+		SetPwrMgt(fctrl);

+	}

+

+	switch(cur_network->network.InfrastructureMode)

+	{

+		case Ndis802_11Infrastructure:

+			SetToDs(fctrl);

+			_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);

+			break;

+		case Ndis802_11APMode:

+			SetFrDs(fctrl);

+			_rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);

+			break;

+		case Ndis802_11IBSS:

+		default:

+			_rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);

+			_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+			break;

+	}

+

+	SetSeqNum(pwlanhdr, 0);

+

+	if (bQoS == _TRUE) {

+		struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;

+

+		SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);

+

+		pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos*)pframe;

+		SetPriority(&pwlanqoshdr->qc, AC);

+		SetEOSP(&pwlanqoshdr->qc, bEosp);

+

+		pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);

+	} else {

+		SetFrameSubType(pframe, WIFI_DATA_NULL);

+

+		pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);

+	}

+

+	*pLength = pktlen;

+}

+

+#ifdef CONFIG_WOWLAN

+//

+// Description:

+//	Construct the ARP response packet to support ARP offload.

+//

+static void ConstructARPResponse(

+	PADAPTER padapter,

+	u8			*pframe,

+	u32			*pLength,

+	u8			*pIPAddress

+	)

+{

+	struct rtw_ieee80211_hdr	*pwlanhdr;

+	struct mlme_priv		*pmlmepriv = &padapter->mlmepriv;

+	struct wlan_network		*cur_network = &pmlmepriv->cur_network;

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+	struct security_priv 	*psecuritypriv = &padapter->securitypriv;

+	static u8				ARPLLCHeader[8] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06};

+

+	u16		*fctrl;

+	u32		pktlen;

+	u8		*pARPRspPkt = pframe;

+	//for TKIP Cal MIC

+	u8		*payload = pframe;

+	u8		EncryptionHeadOverhead = 0;

+

+	pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;

+

+	fctrl = &pwlanhdr->frame_ctl;

+	*(fctrl) = 0;

+

+	//-------------------------------------------------------------------------

+	// MAC Header.

+	//-------------------------------------------------------------------------

+	SetFrameType(fctrl, WIFI_DATA);

+	//SetFrameSubType(fctrl, 0);

+	SetToDs(fctrl);

+	_rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);

+

+	SetSeqNum(pwlanhdr, 0);

+	SetDuration(pwlanhdr, 0);

+	//SET_80211_HDR_FRAME_CONTROL(pARPRspPkt, 0);

+	//SET_80211_HDR_TYPE_AND_SUBTYPE(pARPRspPkt, Type_Data);

+	//SET_80211_HDR_TO_DS(pARPRspPkt, 1);

+	//SET_80211_HDR_ADDRESS1(pARPRspPkt, pMgntInfo->Bssid);

+	//SET_80211_HDR_ADDRESS2(pARPRspPkt, Adapter->CurrentAddress);

+	//SET_80211_HDR_ADDRESS3(pARPRspPkt, pMgntInfo->Bssid);

+

+	//SET_80211_HDR_DURATION(pARPRspPkt, 0);

+	//SET_80211_HDR_FRAGMENT_SEQUENCE(pARPRspPkt, 0);

+#ifdef CONFIG_WAPI_SUPPORT

+	*pLength = sMacHdrLng;

+#else

+	*pLength = 24;

+#endif

+

+

+//YJ,del,120503

+#if 0

+	//-------------------------------------------------------------------------

+	// Qos Header: leave space for it if necessary.

+	//-------------------------------------------------------------------------

+	if(pStaQos->CurrentQosMode > QOS_DISABLE)

+	{

+		SET_80211_HDR_QOS_EN(pARPRspPkt, 1);

+		PlatformZeroMemory(&(Buffer[*pLength]), sQoSCtlLng);

+		*pLength += sQoSCtlLng;

+	}

+#endif

+	//-------------------------------------------------------------------------

+	// Security Header: leave space for it if necessary.

+	//-------------------------------------------------------------------------

+

+	switch (psecuritypriv->dot11PrivacyAlgrthm)

+	{

+		case _WEP40_:

+		case _WEP104_:

+			EncryptionHeadOverhead = 4;

+			break;

+		case _TKIP_:

+			EncryptionHeadOverhead = 8;

+			break;

+		case _AES_:

+			EncryptionHeadOverhead = 8;

+			break;

+#ifdef CONFIG_WAPI_SUPPORT

+		case _SMS4_:

+			EncryptionHeadOverhead = 18;

+			break;

+#endif

+		default:

+			EncryptionHeadOverhead = 0;

+	}

+

+	if(EncryptionHeadOverhead > 0)

+	{

+		_rtw_memset(&(pframe[*pLength]), 0,EncryptionHeadOverhead);

+	       	*pLength += EncryptionHeadOverhead;

+		//SET_80211_HDR_WEP(pARPRspPkt, 1);  //Suggested by CCW.

+		SetPrivacy(fctrl);

+	}

+

+	//-------------------------------------------------------------------------

+	// Frame Body.

+	//-------------------------------------------------------------------------

+	pARPRspPkt =  (u8*)(pframe+ *pLength);

+	// LLC header

+	_rtw_memcpy(pARPRspPkt, ARPLLCHeader, 8);

+	*pLength += 8;

+

+	// ARP element

+	pARPRspPkt += 8;

+	SET_ARP_PKT_HW(pARPRspPkt, 0x0100);

+	SET_ARP_PKT_PROTOCOL(pARPRspPkt, 0x0008);	// IP protocol

+	SET_ARP_PKT_HW_ADDR_LEN(pARPRspPkt, 6);

+	SET_ARP_PKT_PROTOCOL_ADDR_LEN(pARPRspPkt, 4);

+	SET_ARP_PKT_OPERATION(pARPRspPkt, 0x0200); // ARP response

+	SET_ARP_PKT_SENDER_MAC_ADDR(pARPRspPkt, myid(&(padapter->eeprompriv)));

+	SET_ARP_PKT_SENDER_IP_ADDR(pARPRspPkt, pIPAddress);

+	#ifdef CONFIG_ARP_KEEP_ALIVE

+	if (rtw_gw_addr_query(padapter)==0) {

+		SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, pmlmepriv->gw_mac_addr);

+		SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pmlmepriv->gw_ip);

+	}

+	else

+#endif

+	{

+		SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, get_my_bssid(&(pmlmeinfo->network)));

+		SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pIPAddress);

+		DBG_871X("%s Target Mac Addr:" MAC_FMT "\n", __FUNCTION__, MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));

+		DBG_871X("%s Target IP Addr" IP_FMT "\n", __FUNCTION__, IP_ARG(pIPAddress));

+	}

+	*pLength += 28;

+	if (psecuritypriv->dot11PrivacyAlgrthm == _TKIP_)

+	{

+		u8	mic[8];

+		struct mic_data	micdata;

+		struct sta_info	*psta = NULL;

+		u8	priority[4]={0x0,0x0,0x0,0x0};

+		u8	null_key[16]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};

+

+		DBG_871X("%s(): Add MIC\n",__FUNCTION__);

+

+		psta = rtw_get_stainfo(&padapter->stapriv, get_my_bssid(&(pmlmeinfo->network)));

+		if (psta != NULL) {

+			if(_rtw_memcmp(&psta->dot11tkiptxmickey.skey[0],null_key, 16)==_TRUE){

+				DBG_871X("%s(): STA dot11tkiptxmickey==0\n",__FUNCTION__);

+			}

+			//start to calculate the mic code

+			rtw_secmicsetkey(&micdata, &psta->dot11tkiptxmickey.skey[0]);

+		}

+

+		rtw_secmicappend(&micdata, pwlanhdr->addr3, 6);  //DA

+

+		rtw_secmicappend(&micdata, pwlanhdr->addr2, 6); //SA

+

+		priority[0]=0;

+		rtw_secmicappend(&micdata, &priority[0], 4);

+

+		rtw_secmicappend(&micdata, payload, 36); //payload length = 8 + 28

+

+		rtw_secgetmic(&micdata,&(mic[0]));

+

+		pARPRspPkt += 28;

+		_rtw_memcpy(pARPRspPkt, &(mic[0]),8);

+

+		*pLength += 8;

+	}

+}

+#endif

+

+void ConstructProbeRsp(_adapter *padapter, u8 *pframe, u32 *pLength, u8 *StaAddr, BOOLEAN bHideSSID)

+{

+	struct rtw_ieee80211_hdr	*pwlanhdr;

+	u16					*fctrl;

+	u8					*mac, *bssid;

+	u32					pktlen;

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+	WLAN_BSSID_EX 		*cur_network = &(pmlmeinfo->network);

+

+

+	//DBG_871X("%s\n", __FUNCTION__);

+

+	pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;

+

+	mac = myid(&(padapter->eeprompriv));

+	bssid = cur_network->MacAddress;

+

+	fctrl = &(pwlanhdr->frame_ctl);

+	*(fctrl) = 0;

+	_rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);

+	_rtw_memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);

+

+	SetSeqNum(pwlanhdr, 0);

+	SetFrameSubType(fctrl, WIFI_PROBERSP);

+

+	pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);

+	pframe += pktlen;

+

+	if(cur_network->IELength>MAX_IE_SZ)

+		return;

+

+	_rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);

+	pframe += cur_network->IELength;

+	pktlen += cur_network->IELength;

+

+	*pLength = pktlen;

+}

+

+void rtl8188e_set_FwRsvdPage_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc)

+{

+    u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN]={0};

+    u8 u1H2CAoacRsvdPageParm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};

+

+    //DBG_871X("8188RsvdPageLoc: PsPoll=%d Null=%d QoSNull=%d\n", 

+	//	rsvdpageloc->LocPsPoll, rsvdpageloc->LocNullData, rsvdpageloc->LocQosNull);

+

+    SET_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1H2CRsvdPageParm, rsvdpageloc->LocPsPoll);

+    SET_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocNullData);

+    SET_H2CCMD_RSVDPAGE_LOC_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocQosNull);

+    

+    FillH2CCmd_88E(padapter, H2C_COM_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);

+

+#ifdef CONFIG_WOWLAN    

+    //DBG_871X("8188E_AOACRsvdPageLoc: RWC=%d ArpRsp=%d\n", rsvdpageloc->LocRemoteCtrlInfo, rsvdpageloc->LocArpRsp);

+    SET_H2CCMD_AOAC_RSVDPAGE_LOC_REMOTE_WAKE_CTRL_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocRemoteCtrlInfo);

+    SET_H2CCMD_AOAC_RSVDPAGE_LOC_ARP_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocArpRsp);

+

+    FillH2CCmd_88E(padapter, H2C_COM_AOAC_RSVD_PAGE, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);

+#endif

+}

+

+// To check if reserved page content is destroyed by beacon beacuse beacon is too large.

+// 2010.06.23. Added by tynli.

+VOID

+CheckFwRsvdPageContent(

+	IN	PADAPTER		Adapter

+)

+{

+	HAL_DATA_TYPE*	pHalData = GET_HAL_DATA(Adapter);

+	u32	MaxBcnPageNum;

+

+ 	if(pHalData->FwRsvdPageStartOffset != 0)

+ 	{

+ 		/*MaxBcnPageNum = PageNum_128(pMgntInfo->MaxBeaconSize);

+		RT_ASSERT((MaxBcnPageNum <= pHalData->FwRsvdPageStartOffset),

+			("CheckFwRsvdPageContent(): The reserved page content has been"\

+			"destroyed by beacon!!! MaxBcnPageNum(%d) FwRsvdPageStartOffset(%d)\n!",

+			MaxBcnPageNum, pHalData->FwRsvdPageStartOffset));*/

+ 	}

+}

+

+//

+// Description: Fill the reserved packets that FW will use to RSVD page.

+//			Now we just send 4 types packet to rsvd page.

+//			(1)Beacon, (2)Ps-poll, (3)Null data, (4)ProbeRsp.

+//	Input:

+//	    bDLFinished - FALSE: At the first time we will send all the packets as a large packet to Hw,

+//				 		so we need to set the packet length to total lengh.

+//			      TRUE: At the second time, we should send the first packet (default:beacon)

+//						to Hw again and set the lengh in descriptor to the real beacon lengh.

+// 2009.10.15 by tynli.

+static void SetFwRsvdPagePkt(PADAPTER padapter, BOOLEAN bDLFinished)

+{

+	PHAL_DATA_TYPE pHalData;

+	struct xmit_frame	*pcmdframe;

+	struct pkt_attrib	*pattrib;

+	struct xmit_priv	*pxmitpriv;

+	struct mlme_ext_priv	*pmlmeext;

+	struct mlme_ext_info	*pmlmeinfo;

+	u32	BeaconLength, ProbeRspLength, PSPollLength;

+	u32	NullDataLength, QosNullLength, BTQosNullLength;

+	u8	*ReservedPagePacket;

+	u8	RsvdPageNum = 0;

+	u8	PageNum, PageNeed, TxDescLen;

+	u16	BufIndex, PageSize = 128;

+	u32	TotalPacketLen, MaxRsvdPageBufSize=0;

+	RSVDPAGE_LOC	RsvdPageLoc;

+#ifdef CONFIG_WOWLAN

+	u32	ARPLegnth = 0;

+	struct security_priv *psecuritypriv = &padapter->securitypriv; //added by xx

+	u8 currentip[4];

+	u8 cur_dot11txpn[8];

+#endif

+

+	DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));

+

+#ifdef CONFIG_WOWLAN

+	RsvdPageNum = BCNQ_PAGE_NUM_88E + WOWLAN_PAGE_NUM_88E;

+#else

+	RsvdPageNum = BCNQ_PAGE_NUM_88E;

+#endif

+	printk("RsvdPageNum: %d\n", RsvdPageNum);

+

+	MaxRsvdPageBufSize = RsvdPageNum*PageSize;

+

+	ReservedPagePacket = (u8*)rtw_zmalloc(MaxRsvdPageBufSize);

+

+	if (ReservedPagePacket == NULL) {

+		DBG_871X("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);

+	}

+

+	pHalData = GET_HAL_DATA(padapter);

+	pxmitpriv = &padapter->xmitpriv;

+	pmlmeext = &padapter->mlmeextpriv;

+	pmlmeinfo = &pmlmeext->mlmext_info;

+

+	TxDescLen = TXDESC_SIZE;

+	PageNum = 0;

+

+	//3 (1) beacon * 2 pages

+	BufIndex = TXDESC_OFFSET;

+	ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);

+

+	// When we count the first page size, we need to reserve description size for the RSVD

+	// packet, it will be filled in front of the packet in TXPKTBUF.

+	PageNeed = (u8)PageNum_128(TxDescLen + BeaconLength);

+	// To reserved 2 pages for beacon buffer. 2010.06.24.

+	if (PageNeed == 1)

+		PageNeed += 1;

+	PageNum += PageNeed;

+	pHalData->FwRsvdPageStartOffset = PageNum;

+

+	BufIndex += PageNeed * PageSize;

+

+	//3 (2) ps-poll *1 page

+	RsvdPageLoc.LocPsPoll = PageNum;

+	ConstructPSPoll(padapter, &ReservedPagePacket[BufIndex], &PSPollLength);

+	rtl8188e_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], PSPollLength, _TRUE, _FALSE);

+

+	PageNeed = (u8)PageNum_128(TxDescLen + PSPollLength);

+	PageNum += PageNeed;

+

+	BufIndex += PageNeed * PageSize;

+

+	//3 (3) null data * 1 page

+	RsvdPageLoc.LocNullData = PageNum;

+	ConstructNullFunctionData(

+		padapter,

+		&ReservedPagePacket[BufIndex],

+		&NullDataLength,

+		get_my_bssid(&pmlmeinfo->network),

+		_FALSE, 0, 0, _FALSE);

+	rtl8188e_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], NullDataLength, _FALSE, _FALSE);

+

+	PageNeed = (u8)PageNum_128(TxDescLen + NullDataLength);

+	PageNum += PageNeed;

+

+	BufIndex += PageNeed * PageSize;

+

+	//3 (5) Qos null data

+	RsvdPageLoc.LocQosNull = PageNum;

+	ConstructNullFunctionData(

+		padapter,

+		&ReservedPagePacket[BufIndex],

+		&QosNullLength,

+		get_my_bssid(&pmlmeinfo->network),

+		_TRUE, 0, 0, _FALSE);

+	rtl8188e_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], QosNullLength, _FALSE, _FALSE);

+

+	PageNeed = (u8)PageNum_128(TxDescLen + QosNullLength);

+	PageNum += PageNeed;

+

+	BufIndex += PageNeed * PageSize;

+

+/*

+	//3 (6) BT Qos null data

+	RsvdPageLoc.LocBTQosNull = PageNum;

+	ConstructNullFunctionData(

+		padapter, 

+		&ReservedPagePacket[BufIndex],

+		&BTQosNullLength,

+		get_my_bssid(&pmlmeinfo->network),

+		_TRUE, 0, 0, _FALSE);

+	rtl8188e_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, _FALSE, _TRUE);

+

+	TotalPacketLen = BufIndex + BTQosNullLength;

+*/

+

+#ifdef CONFIG_WOWLAN

+	//3(7) ARP

+	rtw_get_current_ip_address(padapter, currentip);

+	RsvdPageLoc.LocArpRsp = PageNum;

+	ConstructARPResponse(

+		padapter,

+		&ReservedPagePacket[BufIndex],

+		&ARPLegnth,

+		currentip

+		);

+	rtl8188e_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], ARPLegnth, _FALSE, _FALSE);

+

+	PageNeed = (u8)PageNum_128(TxDescLen + ARPLegnth);

+	PageNum += PageNeed;

+

+	BufIndex += PageNeed * PageSize;

+

+	//3(8) sec IV

+	rtw_get_sec_iv(padapter, cur_dot11txpn, get_my_bssid(&pmlmeinfo->network));

+	RsvdPageLoc.LocRemoteCtrlInfo = PageNum;

+	_rtw_memcpy(ReservedPagePacket+BufIndex-TxDescLen, cur_dot11txpn, 8);

+

+	TotalPacketLen = BufIndex-TxDescLen + sizeof (union pn48); //IV len

+#else

+	TotalPacketLen = BufIndex + QosNullLength;

+#endif

+

+	pcmdframe = alloc_mgtxmitframe(pxmitpriv);

+	if (pcmdframe == NULL)

+		goto exit;

+

+	// update attribute

+	pattrib = &pcmdframe->attrib;

+	update_mgntframe_attrib(padapter, pattrib);

+	pattrib->qsel = 0x10;

+	pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TXDESC_OFFSET;

+

+	if (TotalPacketLen < MaxRsvdPageBufSize)

+		_rtw_memcpy(pcmdframe->buf_addr, ReservedPagePacket, TotalPacketLen);

+	else

+		DBG_871X("%s: memory copy fail at Line:%d\n", __FUNCTION__, __LINE__);

+

+	rtw_hal_mgnt_xmit(padapter, pcmdframe);

+

+	DBG_871X("%s: Set RSVD page location to Fw ,TotalPacketLen(%d)\n", __FUNCTION__,TotalPacketLen);

+	rtl8188e_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);

+exit:

+	rtw_mfree(ReservedPagePacket, MaxRsvdPageBufSize);

+}

+

+void rtl8188e_set_FwJoinBssReport_cmd(PADAPTER padapter, u8 mstatus)

+{

+	JOINBSSRPT_PARM_88E	JoinBssRptParm;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);

+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);

+#ifdef CONFIG_WOWLAN

+	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;

+	struct sta_info *psta = NULL;

+#endif

+	BOOLEAN		bSendBeacon=_FALSE;

+	BOOLEAN		bcn_valid = _FALSE;

+	u8	DLBcnCount=0;

+	u32 poll = 0;

+

+_func_enter_;

+

+	DBG_871X("%s mstatus(%x)\n", __FUNCTION__,mstatus);

+

+	if(mstatus == 1)

+	{

+		// We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C.

+		// Suggested by filen. Added by tynli.

+		rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));

+		// Do not set TSF again here or vWiFi beacon DMA INT will not work.

+		//correct_TSF(padapter, pmlmeext);

+		// Hw sequende enable by dedault. 2010.06.23. by tynli.

+		//rtw_write16(padapter, REG_NQOS_SEQ, ((pmlmeext->mgnt_seq+100)&0xFFF));

+		//rtw_write8(padapter, REG_HWSEQ_CTRL, 0xFF);

+

+		//Set REG_CR bit 8. DMA beacon by SW.

+		pHalData->RegCR_1 |= BIT0;

+		rtw_write8(padapter,  REG_CR+1, pHalData->RegCR_1);

+

+		// Disable Hw protection for a time which revserd for Hw sending beacon.

+		// Fix download reserved page packet fail that access collision with the protection time.

+		// 2010.05.11. Added by tynli.

+		//SetBcnCtrlReg(padapter, 0, BIT3);

+		//SetBcnCtrlReg(padapter, BIT4, 0);

+		rtw_write8(padapter, REG_BCN_CTRL, rtw_read8(padapter, REG_BCN_CTRL)&(~BIT(3)));

+		rtw_write8(padapter, REG_BCN_CTRL, rtw_read8(padapter, REG_BCN_CTRL)|BIT(4));

+

+		if(pHalData->RegFwHwTxQCtrl&BIT6)

+		{

+			DBG_871X("HalDownloadRSVDPage(): There is an Adapter is sending beacon.\n");

+			bSendBeacon = _TRUE;

+		}

+

+		// Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame.

+		rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, (pHalData->RegFwHwTxQCtrl&(~BIT6)));

+		pHalData->RegFwHwTxQCtrl &= (~BIT6);

+

+		// Clear beacon valid check bit.

+		rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);

+		DLBcnCount = 0;

+		poll = 0;

+		do

+		{

+			// download rsvd page.

+			SetFwRsvdPagePkt(padapter, _FALSE);

+			DLBcnCount++;

+			do

+			{

+				rtw_yield_os();

+				//rtw_mdelay_os(10);

+				// check rsvd page download OK.

+				rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8*)(&bcn_valid));

+				poll++;

+			} while(!bcn_valid && (poll%10)!=0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);

+			

+		}while(!bcn_valid && DLBcnCount<=100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);

+		

+		//RT_ASSERT(bcn_valid, ("HalDownloadRSVDPage88ES(): 1 Download RSVD page failed!\n"));

+		if(padapter->bSurpriseRemoved || padapter->bDriverStopped)

+		{

+		}

+		else if(!bcn_valid)

+			DBG_871X(ADPT_FMT": 1 DL RSVD page failed! DLBcnCount:%u, poll:%u\n",

+				ADPT_ARG(padapter) ,DLBcnCount, poll);

+		else {

+			struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);

+			pwrctl->fw_psmode_iface_id = padapter->iface_id;

+			DBG_871X(ADPT_FMT": 1 DL RSVD page success! DLBcnCount:%u, poll:%u\n",

+				ADPT_ARG(padapter), DLBcnCount, poll);

+		}

+		//

+		// We just can send the reserved page twice during the time that Tx thread is stopped (e.g. pnpsetpower)

+		// becuase we need to free the Tx BCN Desc which is used by the first reserved page packet.

+		// At run time, we cannot get the Tx Desc until it is released in TxHandleInterrupt() so we will return

+		// the beacon TCB in the following code. 2011.11.23. by tynli.

+		//

+		//if(bcn_valid && padapter->bEnterPnpSleep)

+		if(0)

+		{

+			if(bSendBeacon)

+			{

+				rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);

+				DLBcnCount = 0;

+				poll = 0;

+				do

+				{

+					SetFwRsvdPagePkt(padapter, _TRUE);

+					DLBcnCount++;

+					

+					do

+					{

+						rtw_yield_os();

+						//rtw_mdelay_os(10);

+						// check rsvd page download OK.

+						rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8*)(&bcn_valid));

+						poll++;

+					} while(!bcn_valid && (poll%10)!=0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);

+				}while(!bcn_valid && DLBcnCount<=100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);

+				

+				//RT_ASSERT(bcn_valid, ("HalDownloadRSVDPage(): 2 Download RSVD page failed!\n"));

+				if(padapter->bSurpriseRemoved || padapter->bDriverStopped)

+				{

+				}

+				else if(!bcn_valid)

+					DBG_871X("%s: 2 Download RSVD page failed! DLBcnCount:%u, poll:%u\n", __FUNCTION__ ,DLBcnCount, poll);

+				else

+					DBG_871X("%s: 2 Download RSVD success! DLBcnCount:%u, poll:%u\n", __FUNCTION__, DLBcnCount, poll);

+			}

+		}

+

+		// Enable Bcn

+		//SetBcnCtrlReg(padapter, BIT3, 0);

+		//SetBcnCtrlReg(padapter, 0, BIT4);

+		rtw_write8(padapter, REG_BCN_CTRL, rtw_read8(padapter, REG_BCN_CTRL)|BIT(3));

+		rtw_write8(padapter, REG_BCN_CTRL, rtw_read8(padapter, REG_BCN_CTRL)&(~BIT(4)));

+

+		// To make sure that if there exists an adapter which would like to send beacon.

+		// If exists, the origianl value of 0x422[6] will be 1, we should check this to

+		// prevent from setting 0x422[6] to 0 after download reserved page, or it will cause 

+		// the beacon cannot be sent by HW.

+		// 2010.06.23. Added by tynli.

+		if(bSendBeacon)

+		{

+			rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, (pHalData->RegFwHwTxQCtrl|BIT6));

+			pHalData->RegFwHwTxQCtrl |= BIT6;

+		}

+

+		//

+		// Update RSVD page location H2C to Fw.

+		//

+		if(bcn_valid)

+		{

+			rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);

+			DBG_871X("Set RSVD page location to Fw.\n");

+			//FillH2CCmd88E(Adapter, H2C_88E_RSVDPAGE, H2C_RSVDPAGE_LOC_LENGTH, pMgntInfo->u1RsvdPageLoc);

+		}

+		

+		// Do not enable HW DMA BCN or it will cause Pcie interface hang by timing issue. 2011.11.24. by tynli.

+		//if(!padapter->bEnterPnpSleep)

+		{

+			// Clear CR[8] or beacon packet will not be send to TxBuf anymore.

+			pHalData->RegCR_1 &= (~BIT0);

+			rtw_write8(padapter,  REG_CR+1, pHalData->RegCR_1);

+		}

+	}

+#ifdef CONFIG_WOWLAN

+	if (adapter_to_pwrctl(padapter)->wowlan_mode){

+		JoinBssRptParm.OpMode = mstatus;

+		psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(pmlmepriv));

+		if (psta != NULL) {

+			JoinBssRptParm.MacID = psta->mac_id;

+		} else {

+			JoinBssRptParm.MacID = 0;

+		}

+		FillH2CCmd_88E(padapter, H2C_COM_MEDIA_STATUS_RPT, sizeof(JoinBssRptParm), (u8 *)&JoinBssRptParm);

+		DBG_871X_LEVEL(_drv_info_, "%s opmode:%d MacId:%d\n", __func__, JoinBssRptParm.OpMode, JoinBssRptParm.MacID);

+	} else {

+		DBG_871X_LEVEL(_drv_info_, "%s wowlan_mode is off\n", __func__);

+	}

+#endif //CONFIG_WOWLAN

+_func_exit_;

+}

+

+#ifdef CONFIG_P2P_PS

+void rtl8188e_set_p2p_ps_offload_cmd(_adapter* padapter, u8 p2p_ps_state)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	struct pwrctrl_priv		*pwrpriv = adapter_to_pwrctl(padapter);

+	struct wifidirect_info	*pwdinfo = &( padapter->wdinfo );

+	struct P2P_PS_Offload_t	*p2p_ps_offload = (struct P2P_PS_Offload_t	*)(&pHalData->p2p_ps_offload);

+	u8	i;

+

+_func_enter_;

+

+#if 1

+	switch(p2p_ps_state)

+	{

+		case P2P_PS_DISABLE:

+			DBG_8192C("P2P_PS_DISABLE \n");

+			_rtw_memset(p2p_ps_offload, 0 ,1);

+			break;

+		case P2P_PS_ENABLE:

+			DBG_8192C("P2P_PS_ENABLE \n");

+			// update CTWindow value.

+			if( pwdinfo->ctwindow > 0 )

+			{

+				p2p_ps_offload->CTWindow_En = 1;

+				rtw_write8(padapter, REG_P2P_CTWIN, pwdinfo->ctwindow);

+			}

+

+			// hw only support 2 set of NoA

+			for( i=0 ; i<pwdinfo->noa_num ; i++)

+			{

+				// To control the register setting for which NOA

+				rtw_write8(padapter, REG_NOA_DESC_SEL, (i << 4));

+				if(i == 0)

+					p2p_ps_offload->NoA0_En = 1;

+				else

+					p2p_ps_offload->NoA1_En = 1;

+

+				// config P2P NoA Descriptor Register

+				//DBG_8192C("%s(): noa_duration = %x\n",__FUNCTION__,pwdinfo->noa_duration[i]);

+				rtw_write32(padapter, REG_NOA_DESC_DURATION, pwdinfo->noa_duration[i]);

+

+				//DBG_8192C("%s(): noa_interval = %x\n",__FUNCTION__,pwdinfo->noa_interval[i]);

+				rtw_write32(padapter, REG_NOA_DESC_INTERVAL, pwdinfo->noa_interval[i]);

+

+				//DBG_8192C("%s(): start_time = %x\n",__FUNCTION__,pwdinfo->noa_start_time[i]);

+				rtw_write32(padapter, REG_NOA_DESC_START, pwdinfo->noa_start_time[i]);

+

+				//DBG_8192C("%s(): noa_count = %x\n",__FUNCTION__,pwdinfo->noa_count[i]);

+				rtw_write8(padapter, REG_NOA_DESC_COUNT, pwdinfo->noa_count[i]);

+			}

+

+			if( (pwdinfo->opp_ps == 1) || (pwdinfo->noa_num > 0) )

+			{

+				// rst p2p circuit

+				rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(4));

+

+				p2p_ps_offload->Offload_En = 1;

+

+				if(pwdinfo->role == P2P_ROLE_GO)

+				{

+					p2p_ps_offload->role= 1;

+					p2p_ps_offload->AllStaSleep = 0;

+				}

+				else

+				{

+					p2p_ps_offload->role= 0;

+				}

+

+				p2p_ps_offload->discovery = 0;

+			}

+			break;

+		case P2P_PS_SCAN:

+			DBG_8192C("P2P_PS_SCAN \n");

+			p2p_ps_offload->discovery = 1;

+			break;

+		case P2P_PS_SCAN_DONE:

+			DBG_8192C("P2P_PS_SCAN_DONE \n");

+			p2p_ps_offload->discovery = 0;

+			pwdinfo->p2p_ps_state = P2P_PS_ENABLE;

+			break;

+		default:

+			break;

+	}

+

+	FillH2CCmd_88E(padapter, H2C_PS_P2P_OFFLOAD, 1, (u8 *)p2p_ps_offload);

+#endif

+

+_func_exit_;

+

+}

+#endif //CONFIG_P2P_PS

+

+#ifdef CONFIG_TSF_RESET_OFFLOAD

+/*

+	ask FW to Reset sync register at Beacon early interrupt

+*/

+u8 rtl8188e_reset_tsf(_adapter *padapter, u8 reset_port )

+{	

+	u8	buf[2];

+	u8	res=_SUCCESS;

+

+	s32 ret;

+_func_enter_;

+	if (IFACE_PORT0==reset_port) {

+		buf[0] = 0x1; buf[1] = 0;

+	} else{

+		buf[0] = 0x0; buf[1] = 0x1;

+	}

+

+	ret = FillH2CCmd_88E(padapter, H2C_RESET_TSF, 2, buf);

+

+_func_exit_;

+

+	return res;

+}

+

+int reset_tsf(PADAPTER Adapter, u8 reset_port )

+{

+	u8 reset_cnt_before = 0, reset_cnt_after = 0, loop_cnt = 0;

+	u32 reg_reset_tsf_cnt = (IFACE_PORT0==reset_port) ?

+				REG_FW_RESET_TSF_CNT_0:REG_FW_RESET_TSF_CNT_1;

+	u32 reg_bcncrtl = (IFACE_PORT0==reset_port) ?

+				REG_BCN_CTRL_1:REG_BCN_CTRL;

+

+	rtw_scan_abort(Adapter->pbuddy_adapter);	/*	site survey will cause reset_tsf fail	*/

+	reset_cnt_after = reset_cnt_before = rtw_read8(Adapter,reg_reset_tsf_cnt);

+	rtl8188e_reset_tsf(Adapter, reset_port);

+

+	while ((reset_cnt_after == reset_cnt_before ) && (loop_cnt < 10)) {

+		rtw_msleep_os(100);

+		loop_cnt++;

+		reset_cnt_after = rtw_read8(Adapter, reg_reset_tsf_cnt);

+	}

+

+	return(loop_cnt >= 10) ? _FAIL : _TRUE;

+}

+

+

+#endif	// CONFIG_TSF_RESET_OFFLOAD

+

+#ifdef CONFIG_WOWLAN

+#ifdef CONFIG_GPIO_WAKEUP

+void rtl8188es_set_output_gpio(_adapter* padapter, u8 index, u8 outputval)

+{

+	if ( index <= 7 ) {

+		/* config GPIO mode */

+		rtw_write8(padapter, REG_GPIO_PIN_CTRL + 3, rtw_read8(padapter, REG_GPIO_PIN_CTRL + 3) & ~BIT(index) );

+

+		/* config GPIO Sel */

+		/* 0: input */

+		/* 1: output */

+		rtw_write8(padapter, REG_GPIO_PIN_CTRL + 2, rtw_read8(padapter, REG_GPIO_PIN_CTRL + 2) | BIT(index));

+

+		/* set output value */

+		if ( outputval ) {

+			rtw_write8(padapter, REG_GPIO_PIN_CTRL + 1, rtw_read8(padapter, REG_GPIO_PIN_CTRL + 1) | BIT(index));

+		} else {

+			rtw_write8(padapter, REG_GPIO_PIN_CTRL + 1, rtw_read8(padapter, REG_GPIO_PIN_CTRL + 1) & ~BIT(index));

+		}

+	} else {

+		/* 88C Series: */

+		/* index: 11~8 transform to 3~0 */

+		/* 8723 Series: */

+		/* index: 12~8 transform to 4~0 */  

+		index -= 8;

+

+		/* config GPIO mode */

+		rtw_write8(padapter, REG_GPIO_PIN_CTRL_2 + 3, rtw_read8(padapter, REG_GPIO_PIN_CTRL_2 + 3) & ~BIT(index) );

+

+		/* config GPIO Sel */

+		/* 0: input */

+		/* 1: output */

+		rtw_write8(padapter, REG_GPIO_PIN_CTRL_2 + 2, rtw_read8(padapter, REG_GPIO_PIN_CTRL_2 + 2) | BIT(index));

+

+		/* set output value */

+		if ( outputval ) {

+			rtw_write8(padapter, REG_GPIO_PIN_CTRL_2 + 1, rtw_read8(padapter, REG_GPIO_PIN_CTRL_2 + 1) | BIT(index));

+		} else {

+			rtw_write8(padapter, REG_GPIO_PIN_CTRL_2 + 1, rtw_read8(padapter, REG_GPIO_PIN_CTRL_2 + 1) & ~BIT(index));

+		}

+	}

+}

+#endif //CONFIG_GPIO_WAKEUP

+

+void rtl8188es_set_wowlan_cmd(_adapter* padapter, u8 enable)

+{

+	u8		res=_SUCCESS;

+	u32		test=0;

+	struct recv_priv	*precvpriv = &padapter->recvpriv;

+	SETWOWLAN_PARM		pwowlan_parm;

+	SETAOAC_GLOBAL_INFO     paoac_global_info_parm;

+	struct pwrctrl_priv	*pwrpriv = adapter_to_pwrctl(padapter);

+	struct security_priv *psecpriv = &padapter->securitypriv;

+#ifdef CONFIG_GPIO_WAKEUP

+	u8		gpio_wake_pin = 7;

+	u8		gpio_high_active = 0;	//default low active

+#endif

+

+_func_enter_;

+		DBG_871X_LEVEL(_drv_always_, "+%s+\n", __func__);

+

+		pwowlan_parm.mode =0;

+		pwowlan_parm.gpio_index=0;

+		pwowlan_parm.gpio_duration=0;

+		pwowlan_parm.second_mode =0;

+		pwowlan_parm.reserve=0;

+

+		if(enable){

+

+			pwowlan_parm.mode |=FW_WOWLAN_FUN_EN;

+			pwrpriv->wowlan_magic =_TRUE;

+			if (psecpriv->dot11PrivacyAlgrthm == _WEP40_ || psecpriv->dot11PrivacyAlgrthm == _WEP104_)

+				pwrpriv->wowlan_unicast =_TRUE;

+

+			if(pwrpriv->wowlan_pattern ==_TRUE){

+				pwowlan_parm.mode |= FW_WOWLAN_PATTERN_MATCH;

+				DBG_871X_LEVEL(_drv_info_, "%s 2.pwowlan_parm.mode=0x%x \n",__FUNCTION__,pwowlan_parm.mode );

+			}

+			if(pwrpriv->wowlan_magic ==_TRUE){

+				pwowlan_parm.mode |=FW_WOWLAN_MAGIC_PKT;

+				DBG_871X_LEVEL(_drv_info_, "%s 3.pwowlan_parm.mode=0x%x \n",__FUNCTION__,pwowlan_parm.mode );

+			}

+			if(pwrpriv->wowlan_unicast ==_TRUE){

+				pwowlan_parm.mode |=FW_WOWLAN_UNICAST;

+				DBG_871X_LEVEL(_drv_info_, "%s 4.pwowlan_parm.mode=0x%x \n",__FUNCTION__,pwowlan_parm.mode );

+			}

+

+			pwowlan_parm.mode |=FW_WOWLAN_REKEY_WAKEUP;

+			pwowlan_parm.mode |=FW_WOWLAN_DEAUTH_WAKEUP;

+

+			//DataPinWakeUp

+#ifdef CONFIG_USB_HCI

+			pwowlan_parm.gpio_index=0x0;

+#endif //CONFIG_USB_HCI

+

+#ifdef CONFIG_SDIO_HCI

+			pwowlan_parm.gpio_index = 0x80;

+#endif //CONFIG_SDIO_HCI

+

+#ifdef CONFIG_GPIO_WAKEUP

+			pwowlan_parm.gpio_index = gpio_wake_pin;

+

+			//WOWLAN_GPIO_ACTIVE means GPIO high active

+			//pwowlan_parm.mode |=FW_WOWLAN_GPIO_ACTIVE;

+			if (gpio_high_active)

+				pwowlan_parm.mode |=FW_WOWLAN_GPIO_ACTIVE;

+#endif //CONFIG_GPIO_WAKEUP

+

+			DBG_871X_LEVEL(_drv_info_, "%s 5.pwowlan_parm.mode=0x%x \n",__FUNCTION__,pwowlan_parm.mode);

+			DBG_871X_LEVEL(_drv_info_, "%s 6.pwowlan_parm.index=0x%x \n",__FUNCTION__,pwowlan_parm.gpio_index);

+			res = FillH2CCmd_88E(padapter, H2C_COM_WWLAN, 2, (u8 *)&pwowlan_parm);

+

+			rtw_msleep_os(2);

+

+			//disconnect decision

+			pwowlan_parm.mode =1;

+			pwowlan_parm.gpio_index=0;

+			pwowlan_parm.gpio_duration=0;

+			FillH2CCmd_88E(padapter, H2C_COM_DISCNT_DECISION, 3, (u8 *)&pwowlan_parm);

+

+			//keep alive period = 10 * 10 BCN interval

+			pwowlan_parm.mode = FW_WOWLAN_KEEP_ALIVE_EN | FW_ADOPT_USER | FW_WOWLAN_KEEP_ALIVE_PKT_TYPE;

+			pwowlan_parm.gpio_index = 5;

+			res = FillH2CCmd_88E(padapter, H2C_COM_KEEP_ALIVE, 2, (u8 *)&pwowlan_parm);

+

+			rtw_msleep_os(2);

+			//Configure STA security information for GTK rekey wakeup event.

+			paoac_global_info_parm.pairwiseEncAlg =

+					padapter->securitypriv.dot11PrivacyAlgrthm;

+			paoac_global_info_parm.groupEncAlg =

+					padapter->securitypriv.dot118021XGrpPrivacy;

+			FillH2CCmd_88E(padapter, H2C_COM_AOAC_GLOBAL_INFO, 2, (u8 *)&paoac_global_info_parm);

+

+			rtw_msleep_os(2);

+			//enable Remote wake ctrl

+			pwowlan_parm.mode = FW_REMOTE_WAKE_CTRL_EN | FW_WOW_FW_UNICAST_EN | FW_ARP_EN;

+			if (psecpriv->dot11PrivacyAlgrthm == _AES_ || psecpriv->dot11PrivacyAlgrthm == _NO_PRIVACY_)

+			{

+				pwowlan_parm.gpio_index=0;

+			} else {

+				pwowlan_parm.gpio_index=1;

+			}

+			pwowlan_parm.gpio_duration=0;

+

+			res = FillH2CCmd_88E(padapter, H2C_COM_REMOTE_WAKE_CTRL, 3, (u8 *)&pwowlan_parm);

+		} else {

+			pwrpriv->wowlan_magic =_FALSE;

+#ifdef CONFIG_GPIO_WAKEUP

+			rtl8188es_set_output_gpio(padapter, gpio_wake_pin, !gpio_high_active);

+#endif //CONFIG_GPIO_WAKEUP

+			res = FillH2CCmd_88E(padapter, H2C_COM_WWLAN, 2, (u8 *)&pwowlan_parm);

+			rtw_msleep_os(2);

+			res = FillH2CCmd_88E(padapter, H2C_COM_REMOTE_WAKE_CTRL, 3, (u8 *)&pwowlan_parm);

+		}

+_func_exit_;

+		DBG_871X_LEVEL(_drv_always_, "-%s res:%d-\n", __func__, res);

+		return ;

+}

+#endif  //CONFIG_WOWLAN

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_dm.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_dm.c
new file mode 100644
index 00000000..dc966775
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_dm.c
@@ -0,0 +1,628 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+//============================================================

+// Description:

+//

+// This file is for 92CE/92CU dynamic mechanism only

+//

+//

+//============================================================

+#define _RTL8188E_DM_C_

+

+//============================================================

+// include files

+//============================================================

+#include <drv_types.h>

+#include <rtl8188e_hal.h>

+

+//============================================================

+// Global var

+//============================================================

+

+

+static VOID

+dm_CheckProtection(

+	IN	PADAPTER	Adapter

+	)

+{

+#if 0

+	PMGNT_INFO		pMgntInfo = &(Adapter->MgntInfo);

+	u1Byte			CurRate, RateThreshold;

+

+	if(pMgntInfo->pHTInfo->bCurBW40MHz)

+		RateThreshold = MGN_MCS1;

+	else

+		RateThreshold = MGN_MCS3;

+

+	if(Adapter->TxStats.CurrentInitTxRate <= RateThreshold)

+	{

+		pMgntInfo->bDmDisableProtect = TRUE;

+		DbgPrint("Forced disable protect: %x\n", Adapter->TxStats.CurrentInitTxRate);

+	}

+	else

+	{

+		pMgntInfo->bDmDisableProtect = FALSE;

+		DbgPrint("Enable protect: %x\n", Adapter->TxStats.CurrentInitTxRate);

+	}

+#endif

+}

+

+static VOID

+dm_CheckStatistics(

+	IN	PADAPTER	Adapter

+	)

+{

+#if 0

+	if(!Adapter->MgntInfo.bMediaConnect)

+		return;

+

+	//2008.12.10 tynli Add for getting Current_Tx_Rate_Reg flexibly.

+	rtw_hal_get_hwreg( Adapter, HW_VAR_INIT_TX_RATE, (pu1Byte)(&Adapter->TxStats.CurrentInitTxRate) );

+

+	// Calculate current Tx Rate(Successful transmited!!)

+

+	// Calculate current Rx Rate(Successful received!!)

+

+	//for tx tx retry count

+	rtw_hal_get_hwreg( Adapter, HW_VAR_RETRY_COUNT, (pu1Byte)(&Adapter->TxStats.NumTxRetryCount) );

+#endif

+}

+

+#ifdef CONFIG_SUPPORT_HW_WPS_PBC

+static void dm_CheckPbcGPIO(_adapter *padapter)

+{

+	u8	tmp1byte;

+	u8	bPbcPressed = _FALSE;

+

+	if(!padapter->registrypriv.hw_wps_pbc)

+		return;

+

+#ifdef CONFIG_USB_HCI

+	tmp1byte = rtw_read8(padapter, GPIO_IO_SEL);

+	tmp1byte |= (HAL_8188E_HW_GPIO_WPS_BIT);

+	rtw_write8(padapter, GPIO_IO_SEL, tmp1byte);	//enable GPIO[2] as output mode

+

+	tmp1byte &= ~(HAL_8188E_HW_GPIO_WPS_BIT);

+	rtw_write8(padapter,  GPIO_IN, tmp1byte);		//reset the floating voltage level

+

+	tmp1byte = rtw_read8(padapter, GPIO_IO_SEL);

+	tmp1byte &= ~(HAL_8188E_HW_GPIO_WPS_BIT);

+	rtw_write8(padapter, GPIO_IO_SEL, tmp1byte);	//enable GPIO[2] as input mode

+

+	tmp1byte =rtw_read8(padapter, GPIO_IN);

+

+	if (tmp1byte == 0xff)

+		return ;

+

+	if (tmp1byte&HAL_8188E_HW_GPIO_WPS_BIT)

+	{

+		bPbcPressed = _TRUE;

+	}

+#else

+	tmp1byte = rtw_read8(padapter, GPIO_IN);

+	//RT_TRACE(COMP_IO, DBG_TRACE, ("dm_CheckPbcGPIO - %x\n", tmp1byte));

+

+	if (tmp1byte == 0xff || padapter->init_adpt_in_progress)

+		return ;

+

+	if((tmp1byte&HAL_8188E_HW_GPIO_WPS_BIT)==0)

+	{

+		bPbcPressed = _TRUE;

+	}

+#endif

+

+	if( _TRUE == bPbcPressed)

+	{

+		// Here we only set bPbcPressed to true

+		// After trigger PBC, the variable will be set to false

+		DBG_8192C("CheckPbcGPIO - PBC is pressed\n");

+		rtw_request_wps_pbc_event(padapter);

+	}

+}

+#endif//#ifdef CONFIG_SUPPORT_HW_WPS_PBC

+

+#ifdef CONFIG_PCI_HCI

+//

+//	Description:

+//		Perform interrupt migration dynamically to reduce CPU utilization.

+//

+//	Assumption:

+//		1. Do not enable migration under WIFI test.

+//

+//	Created by Roger, 2010.03.05.

+//

+VOID

+dm_InterruptMigration(

+	IN	PADAPTER	Adapter

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);

+	BOOLEAN			bCurrentIntMt, bCurrentACIntDisable;

+	BOOLEAN			IntMtToSet = _FALSE;

+	BOOLEAN			ACIntToSet = _FALSE;

+

+

+	// Retrieve current interrupt migration and Tx four ACs IMR settings first.

+	bCurrentIntMt = pHalData->bInterruptMigration;

+	bCurrentACIntDisable = pHalData->bDisableTxInt;

+

+	//

+	// <Roger_Notes> Currently we use busy traffic for reference instead of RxIntOK counts to prevent non-linear Rx statistics

+	// when interrupt migration is set before. 2010.03.05.

+	//

+	if(!Adapter->registrypriv.wifi_spec &&

+		(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) &&

+		pmlmepriv->LinkDetectInfo.bHigherBusyTraffic)

+	{

+		IntMtToSet = _TRUE;

+

+		// To check whether we should disable Tx interrupt or not.

+		if(pmlmepriv->LinkDetectInfo.bHigherBusyRxTraffic )

+			ACIntToSet = _TRUE;

+	}

+

+	//Update current settings.

+	if( bCurrentIntMt != IntMtToSet ){

+		DBG_8192C("%s(): Update interrrupt migration(%d)\n",__FUNCTION__,IntMtToSet);

+		if(IntMtToSet)

+		{

+			//

+			// <Roger_Notes> Set interrrupt migration timer and corresponging Tx/Rx counter.

+			// timer 25ns*0xfa0=100us for 0xf packets.

+			// 2010.03.05.

+			//

+			rtw_write32(Adapter, REG_INT_MIG, 0xff000fa0);// 0x306:Rx, 0x307:Tx

+			pHalData->bInterruptMigration = IntMtToSet;

+		}

+		else

+		{

+			// Reset all interrupt migration settings.

+			rtw_write32(Adapter, REG_INT_MIG, 0);

+			pHalData->bInterruptMigration = IntMtToSet;

+		}

+	}

+

+	/*if( bCurrentACIntDisable != ACIntToSet ){

+		DBG_8192C("%s(): Update AC interrrupt(%d)\n",__FUNCTION__,ACIntToSet);

+		if(ACIntToSet) // Disable four ACs interrupts.

+		{

+			//

+			// <Roger_Notes> Disable VO, VI, BE and BK four AC interrupts to gain more efficient CPU utilization.

+			// When extremely highly Rx OK occurs, we will disable Tx interrupts.

+			// 2010.03.05.

+			//

+			UpdateInterruptMask8192CE( Adapter, 0, RT_AC_INT_MASKS );

+			pHalData->bDisableTxInt = ACIntToSet;

+		}

+		else// Enable four ACs interrupts.

+		{

+			UpdateInterruptMask8192CE( Adapter, RT_AC_INT_MASKS, 0 );

+			pHalData->bDisableTxInt = ACIntToSet;

+		}

+	}*/

+

+}

+

+#endif

+

+//

+// Initialize GPIO setting registers

+//

+static void

+dm_InitGPIOSetting(

+	IN	PADAPTER	Adapter

+	)

+{

+	PHAL_DATA_TYPE		pHalData = GET_HAL_DATA(Adapter);

+

+	u8	tmp1byte;

+

+	tmp1byte = rtw_read8(Adapter, REG_GPIO_MUXCFG);

+	tmp1byte &= (GPIOSEL_GPIO | ~GPIOSEL_ENBT);

+

+#ifdef CONFIG_BT_COEXIST

+	// UMB-B cut bug. We need to support the modification.

+	if (IS_81xxC_VENDOR_UMC_B_CUT(pHalData->VersionID) &&

+		pHalData->bt_coexist.BT_Coexist)

+	{

+		tmp1byte |= (BIT5);

+	}

+#endif

+	rtw_write8(Adapter, REG_GPIO_MUXCFG, tmp1byte);

+

+}

+

+//============================================================

+// functions

+//============================================================

+static void Init_ODM_ComInfo_88E(PADAPTER	Adapter)

+{

+	EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+	u8	cut_ver,fab_ver;

+	

+	//

+	// Init Value

+	//

+	_rtw_memset(pDM_Odm,0,sizeof(*pDM_Odm));

+	

+	pDM_Odm->Adapter = Adapter;	

+	

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_PLATFORM,ODM_CE);

+

+	if (Adapter->interface_type == RTW_GSPI)

+		ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_INTERFACE,ODM_ITRF_SDIO);

+	else

+		ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_INTERFACE,Adapter->interface_type);

+	

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_IC_TYPE,ODM_RTL8188E);

+

+	fab_ver = ODM_TSMC;

+	cut_ver = ODM_CUT_A;	

+

+	if(IS_I_CUT(pHalData->VersionID) || IS_J_CUT(pHalData->VersionID) || IS_K_CUT(pHalData->VersionID))

+		cut_ver = ODM_CUT_I;

+

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_FAB_VER,fab_ver);		

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_CUT_VER,cut_ver);

+

+	ODM_CmnInfoInit(pDM_Odm,	ODM_CMNINFO_MP_TEST_CHIP,IS_NORMAL_CHIP(pHalData->VersionID));

+	

+#if 0	

+//#ifdef CONFIG_USB_HCI	

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_BOARD_TYPE,pHalData->BoardType);

+

+	if(pHalData->BoardType == BOARD_USB_High_PA){

+		ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_EXT_LNA,_TRUE);

+		ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_EXT_PA,_TRUE);

+	}

+#endif	

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_PATCH_ID,pEEPROM->CustomerID);

+	//	ODM_CMNINFO_BINHCT_TEST only for MP Team

+	ODM_CmnInfoInit(pDM_Odm,ODM_CMNINFO_BWIFI_TEST,Adapter->registrypriv.wifi_spec);

+		

+	

+	if(pHalData->rf_type == RF_1T1R){

+		ODM_CmnInfoUpdate(pDM_Odm,ODM_CMNINFO_RF_TYPE,ODM_1T1R);		

+	}

+	else if(pHalData->rf_type == RF_2T2R){

+		ODM_CmnInfoUpdate(pDM_Odm,ODM_CMNINFO_RF_TYPE,ODM_2T2R);		

+	}

+	else if(pHalData->rf_type == RF_1T2R){		

+		ODM_CmnInfoUpdate(pDM_Odm,ODM_CMNINFO_RF_TYPE,ODM_1T2R);		

+	}	

+

+ 	ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_RF_ANTENNA_TYPE, pHalData->TRxAntDivType);

+	

+	#ifdef CONFIG_DISABLE_ODM

+	pdmpriv->InitODMFlag = 0;

+	#else

+	pdmpriv->InitODMFlag =	ODM_RF_CALIBRATION		|

+							ODM_RF_TX_PWR_TRACK	//|

+							;	

+	//if(pHalData->AntDivCfg)

+	//	pdmpriv->InitODMFlag |= ODM_BB_ANT_DIV;

+	#endif	

+

+	ODM_CmnInfoUpdate(pDM_Odm,ODM_CMNINFO_ABILITY,pdmpriv->InitODMFlag);

+	

+}

+static void Update_ODM_ComInfo_88E(PADAPTER	Adapter)

+{

+	struct mlme_ext_priv	*pmlmeext = &Adapter->mlmeextpriv;

+	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;

+	struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;	

+	int i;

+

+	pdmpriv->InitODMFlag = 0

+		| ODM_BB_DIG

+		| ODM_BB_RA_MASK

+		| ODM_BB_DYNAMIC_TXPWR

+		| ODM_BB_FA_CNT

+		| ODM_BB_RSSI_MONITOR

+		| ODM_BB_CCK_PD

+		| ODM_BB_PWR_SAVE		

+		| ODM_RF_CALIBRATION

+		| ODM_RF_TX_PWR_TRACK

+#ifdef CONFIG_ODM_ADAPTIVITY

+		| ODM_BB_ADAPTIVITY

+#endif

+		;

+

+	if (!Adapter->registrypriv.qos_opt_enable) {

+		pdmpriv->InitODMFlag |= ODM_MAC_EDCA_TURBO;

+	}

+	

+	if(pHalData->AntDivCfg)

+		pdmpriv->InitODMFlag |= ODM_BB_ANT_DIV;

+

+#if (MP_DRIVER==1)

+	if (Adapter->registrypriv.mp_mode == 1) {

+		pdmpriv->InitODMFlag = 0

+			| ODM_RF_CALIBRATION

+			| ODM_RF_TX_PWR_TRACK

+			;

+	}

+#endif//(MP_DRIVER==1)

+

+#ifdef CONFIG_DISABLE_ODM

+	pdmpriv->InitODMFlag = 0;

+#endif//CONFIG_DISABLE_ODM

+

+	ODM_CmnInfoUpdate(pDM_Odm,ODM_CMNINFO_ABILITY,pdmpriv->InitODMFlag);

+	

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_TX_UNI,&(Adapter->xmitpriv.tx_bytes));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_RX_UNI,&(Adapter->recvpriv.rx_bytes));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_WM_MODE,&(pmlmeext->cur_wireless_mode));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_SEC_CHNL_OFFSET,&(pHalData->nCur40MhzPrimeSC));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_SEC_MODE,&(Adapter->securitypriv.dot11PrivacyAlgrthm));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BW,&(pHalData->CurrentChannelBW ));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_CHNL,&( pHalData->CurrentChannel));	

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_NET_CLOSED,&( Adapter->net_closed));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_MP_MODE,&(Adapter->registrypriv.mp_mode));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_FORCED_IGI_LB,&(pHalData->u1ForcedIgiLb));

+	//================= only for 8192D   =================

+	

+	//pHalData->CurrentBandType92D hook fake band_type for power tracking

+	//ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BAND,&(pDM_Odm->u1Byte_temp));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BAND,&(pHalData->CurrentBandType));

+

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_FORCED_RATE,&(pHalData->ForcedDataRate));

+	

+	/*

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_DMSP_GET_VALUE,&(pDM_Odm->u1Byte_temp));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BUDDY_ADAPTOR,&(pDM_Odm->PADAPTER_temp));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_DMSP_IS_MASTER,&(pDM_Odm->u1Byte_temp));

+	//================= only for 8192D   =================

+	// driver havn't those variable now

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BT_OPERATION,&(pDM_Odm->u1Byte_temp));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_BT_DISABLE_EDCA,&(pDM_Odm->u1Byte_temp));

+	*/

+	

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_SCAN,&(pmlmepriv->bScanInProcess));

+	ODM_CmnInfoHook(pDM_Odm,ODM_CMNINFO_POWER_SAVING,&(pwrctrlpriv->bpower_saving));

+	ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_RF_ANTENNA_TYPE, pHalData->TRxAntDivType);

+

+	for(i=0; i< NUM_STA; i++)

+	{

+		//pDM_Odm->pODM_StaInfo[i] = NULL;

+		ODM_CmnInfoPtrArrayHook(pDM_Odm, ODM_CMNINFO_STA_STATUS,i,NULL);

+	}	

+}

+

+void

+rtl8188e_InitHalDm(

+	IN	PADAPTER	Adapter

+	)

+{

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+	u8	i;

+

+#ifdef CONFIG_USB_HCI

+	dm_InitGPIOSetting(Adapter);

+#endif

+

+	pdmpriv->DM_Type = DM_Type_ByDriver;

+	pdmpriv->DMFlag = DYNAMIC_FUNC_DISABLE;

+	

+	Update_ODM_ComInfo_88E(Adapter);

+	ODM_DMInit(pDM_Odm);

+}

+

+

+VOID

+rtl8188e_HalDmWatchDog(

+	IN	PADAPTER	Adapter

+	)

+{

+	BOOLEAN		bFwCurrentInPSMode = _FALSE;

+	BOOLEAN		bFwPSAwake = _TRUE;

+	u8 hw_init_completed = _FALSE;

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+#ifdef CONFIG_CONCURRENT_MODE

+	PADAPTER pbuddy_adapter = Adapter->pbuddy_adapter;

+#endif //CONFIG_CONCURRENT_MODE

+

+	_func_enter_;

+

+	hw_init_completed = Adapter->hw_init_completed;

+

+	if (hw_init_completed == _FALSE)

+		goto skip_dm;

+

+#ifdef CONFIG_LPS

+	bFwCurrentInPSMode = adapter_to_pwrctl(Adapter)->bFwCurrentInPSMode;

+	rtw_hal_get_hwreg(Adapter, HW_VAR_FWLPS_RF_ON, (u8 *)(&bFwPSAwake));

+#endif

+

+#ifdef CONFIG_P2P_PS

+	// Fw is under p2p powersaving mode, driver should stop dynamic mechanism.

+	// modifed by thomas. 2011.06.11.

+	if(Adapter->wdinfo.p2p_ps_mode)

+		bFwPSAwake = _FALSE;

+#endif //CONFIG_P2P_PS

+

+	if( (hw_init_completed == _TRUE)

+		&& ((!bFwCurrentInPSMode) && bFwPSAwake))

+	{

+		//

+		// Calculate Tx/Rx statistics.

+		//

+		dm_CheckStatistics(Adapter);

+		

+		rtw_hal_check_rxfifo_full(Adapter);

+		//

+		// Dynamically switch RTS/CTS protection.

+		//

+		//dm_CheckProtection(Adapter);

+

+#ifdef CONFIG_PCI_HCI

+		// 20100630 Joseph: Disable Interrupt Migration mechanism temporarily because it degrades Rx throughput.

+		// Tx Migration settings.

+		//dm_InterruptMigration(Adapter);

+

+		//if(Adapter->HalFunc.TxCheckStuckHandler(Adapter))

+		//	PlatformScheduleWorkItem(&(GET_HAL_DATA(Adapter)->HalResetWorkItem));

+#endif

+	

+	}

+

+

+	//ODM

+	if (hw_init_completed == _TRUE)

+	{

+		u8	bLinked=_FALSE;

+		u8	bsta_state=_FALSE;

+		#ifdef CONFIG_DISABLE_ODM

+		pHalData->odmpriv.SupportAbility = 0;

+		#endif

+

+		if(rtw_linked_check(Adapter)){			

+			bLinked = _TRUE;

+			if (check_fwstate(&Adapter->mlmepriv, WIFI_STATION_STATE))

+				bsta_state = _TRUE;

+		}

+		

+#ifdef CONFIG_CONCURRENT_MODE

+		if(pbuddy_adapter && rtw_linked_check(pbuddy_adapter)){

+			bLinked = _TRUE;

+			if(pbuddy_adapter && check_fwstate(&pbuddy_adapter->mlmepriv, WIFI_STATION_STATE))

+				bsta_state = _TRUE;

+		}

+#endif //CONFIG_CONCURRENT_MODE

+

+		ODM_CmnInfoUpdate(&pHalData->odmpriv ,ODM_CMNINFO_LINK, bLinked);

+		ODM_CmnInfoUpdate(&pHalData->odmpriv ,ODM_CMNINFO_STATION_STATE, bsta_state);

+

+

+		ODM_DMWatchdog(&pHalData->odmpriv);

+			

+	}

+

+skip_dm:

+	

+#ifdef CONFIG_SUPPORT_HW_WPS_PBC

+	// Check GPIO to determine current Pbc status.

+	dm_CheckPbcGPIO(Adapter);

+#endif	

+	return;

+}

+

+void rtl8188e_init_dm_priv(IN PADAPTER Adapter)

+{

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T 		podmpriv = &pHalData->odmpriv;

+	_rtw_memset(pdmpriv, 0, sizeof(struct dm_priv));

+	//_rtw_spinlock_init(&(pHalData->odm_stainfo_lock));

+	Init_ODM_ComInfo_88E(Adapter);

+#ifdef CONFIG_SW_ANTENNA_DIVERSITY

+	//_init_timer(&(pdmpriv->SwAntennaSwitchTimer),  Adapter->pnetdev , odm_SW_AntennaSwitchCallback, Adapter);	

+	ODM_InitAllTimers(podmpriv );	

+#endif

+	ODM_InitDebugSetting(podmpriv);	

+}

+

+void rtl8188e_deinit_dm_priv(IN PADAPTER Adapter)

+{

+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T 		podmpriv = &pHalData->odmpriv;

+	//_rtw_spinlock_free(&pHalData->odm_stainfo_lock);

+#ifdef CONFIG_SW_ANTENNA_DIVERSITY

+	//_cancel_timer_ex(&pdmpriv->SwAntennaSwitchTimer);	

+	ODM_CancelAllTimers(podmpriv);	

+#endif

+}

+

+

+#ifdef CONFIG_ANTENNA_DIVERSITY

+// Add new function to reset the state of antenna diversity before link.

+//

+// Compare RSSI for deciding antenna

+void	AntDivCompare8188E(PADAPTER Adapter, WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src)

+{

+	//PADAPTER Adapter = pDM_Odm->Adapter ;

+	

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	if(0 != pHalData->AntDivCfg )

+	{

+		//DBG_8192C("update_network=> orgRSSI(%d)(%d),newRSSI(%d)(%d)\n",dst->Rssi,query_rx_pwr_percentage(dst->Rssi),

+		//	src->Rssi,query_rx_pwr_percentage(src->Rssi));

+		//select optimum_antenna for before linked =>For antenna diversity

+		if(dst->Rssi >=  src->Rssi )//keep org parameter

+		{

+			src->Rssi = dst->Rssi;

+			src->PhyInfo.Optimum_antenna = dst->PhyInfo.Optimum_antenna;						

+		}

+	}

+}

+

+// Add new function to reset the state of antenna diversity before link.

+u8 AntDivBeforeLink8188E(PADAPTER Adapter )

+{

+	

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);	

+	PDM_ODM_T 	pDM_Odm =&pHalData->odmpriv;

+	SWAT_T		*pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;

+	struct mlme_priv	*pmlmepriv = &(Adapter->mlmepriv);

+	

+	// Condition that does not need to use antenna diversity.

+	if(pHalData->AntDivCfg==0)

+	{

+		//DBG_8192C("odm_AntDivBeforeLink8192C(): No AntDiv Mechanism.\n");

+		return _FALSE;

+	}

+

+	if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)	

+	{		

+		return _FALSE;

+	}

+

+

+	if(pDM_SWAT_Table->SWAS_NoLink_State == 0){

+		//switch channel

+		pDM_SWAT_Table->SWAS_NoLink_State = 1;

+		pDM_SWAT_Table->CurAntenna = (pDM_SWAT_Table->CurAntenna==MAIN_ANT)?AUX_ANT:MAIN_ANT;

+

+		//PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, pDM_SWAT_Table->CurAntenna);

+		rtw_antenna_select_cmd(Adapter, pDM_SWAT_Table->CurAntenna, _FALSE);

+		//DBG_8192C("%s change antenna to ANT_( %s ).....\n",__FUNCTION__, (pDM_SWAT_Table->CurAntenna==MAIN_ANT)?"MAIN":"AUX");

+		return _TRUE;

+	}

+	else

+	{

+		pDM_SWAT_Table->SWAS_NoLink_State = 0;

+		return _FALSE;

+	}	

+

+}

+#endif

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_hal_init.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_hal_init.c
new file mode 100644
index 00000000..10dd48ad
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_hal_init.c
@@ -0,0 +1,4140 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _HAL_INIT_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+
+#if defined(CONFIG_IOL)
+static void iol_mode_enable(PADAPTER padapter, u8 enable)
+{
+	u8 reg_0xf0 = 0;
+	
+	if(enable)
+	{
+		//Enable initial offload
+		reg_0xf0 = rtw_read8(padapter, REG_SYS_CFG);
+		//DBG_871X("%s reg_0xf0:0x%02x, write 0x%02x\n", __FUNCTION__, reg_0xf0, reg_0xf0|SW_OFFLOAD_EN);
+		rtw_write8(padapter, REG_SYS_CFG, reg_0xf0|SW_OFFLOAD_EN);
+		
+		if(padapter->bFWReady == _FALSE)
+		{
+			printk("bFWReady == _FALSE call reset 8051...\n");
+			_8051Reset88E(padapter);
+		}		
+			
+	}
+	else
+	{
+		//disable initial offload
+		reg_0xf0 = rtw_read8(padapter, REG_SYS_CFG);
+		//DBG_871X("%s reg_0xf0:0x%02x, write 0x%02x\n", __FUNCTION__, reg_0xf0, reg_0xf0& ~SW_OFFLOAD_EN);
+		rtw_write8(padapter, REG_SYS_CFG, reg_0xf0 & ~SW_OFFLOAD_EN);
+	}
+}
+
+static s32 iol_execute(PADAPTER padapter, u8 control)
+{
+	s32 status = _FAIL;
+	u8 reg_0x88 = 0,reg_1c7=0;
+	u32 start = 0, passing_time = 0;
+	
+	u32 t1,t2;
+	control = control&0x0f;
+	reg_0x88 = rtw_read8(padapter, REG_HMEBOX_E0);
+	//DBG_871X("%s reg_0x88:0x%02x, write 0x%02x\n", __FUNCTION__, reg_0x88, reg_0x88|control);
+	rtw_write8(padapter, REG_HMEBOX_E0,  reg_0x88|control);
+
+	t1 = start = rtw_get_current_time();
+	while(
+		//(reg_1c7 = rtw_read8(padapter, 0x1c7) >1) &&
+		(reg_0x88=rtw_read8(padapter, REG_HMEBOX_E0)) & control
+		&& (passing_time=rtw_get_passing_time_ms(start))<1000
+	) {
+		//DBG_871X("%s polling reg_0x88:0x%02x,reg_0x1c7:0x%02x\n", __FUNCTION__, reg_0x88,rtw_read8(padapter, 0x1c7) );
+		//rtw_udelay_os(100);
+	}
+
+	reg_0x88 = rtw_read8(padapter, REG_HMEBOX_E0);
+	status = (reg_0x88 & control)?_FAIL:_SUCCESS;
+	if(reg_0x88 & control<<4)
+		status = _FAIL;
+	t2= rtw_get_current_time();
+	//printk("==> step iol_execute :  %5u reg-0x1c0= 0x%02x\n",rtw_get_time_interval_ms(t1,t2),rtw_read8(padapter, 0x1c0));
+	//DBG_871X("%s in %u ms, reg_0x88:0x%02x\n", __FUNCTION__, passing_time, reg_0x88);
+	
+	return status;
+}
+
+static s32 iol_InitLLTTable(
+	PADAPTER padapter,
+	u8 txpktbuf_bndy
+	)
+{
+	s32 rst = _SUCCESS; 
+	iol_mode_enable(padapter, 1);
+	//DBG_871X("%s txpktbuf_bndy:%u\n", __FUNCTION__, txpktbuf_bndy);
+	rtw_write8(padapter, REG_TDECTRL+1, txpktbuf_bndy);
+	rst = iol_execute(padapter, CMD_INIT_LLT);
+	iol_mode_enable(padapter, 0);
+	return rst;
+}
+
+static VOID
+efuse_phymap_to_logical(u8 * phymap, u16 _offset, u16 _size_byte, u8  *pbuf)
+{
+	u8	*efuseTbl = NULL;
+	u8	rtemp8;
+	u16	eFuse_Addr = 0;
+	u8	offset, wren;
+	u16	i, j;
+	u16	**eFuseWord = NULL;
+	u16	efuse_utilized = 0;
+	u8	efuse_usage = 0;
+	u8	u1temp = 0;
+
+
+	efuseTbl = (u8*)rtw_zmalloc(EFUSE_MAP_LEN_88E);
+	if(efuseTbl == NULL)
+	{
+		DBG_871X("%s: alloc efuseTbl fail!\n", __FUNCTION__);
+		goto exit;
+	}
+
+	eFuseWord= (u16 **)rtw_malloc2d(EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, 2);
+	if(eFuseWord == NULL)
+	{
+		DBG_871X("%s: alloc eFuseWord fail!\n", __FUNCTION__);
+		goto exit;
+	}
+
+	// 0. Refresh efuse init map as all oxFF.
+	for (i = 0; i < EFUSE_MAX_SECTION_88E; i++)
+		for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)
+			eFuseWord[i][j] = 0xFFFF;
+
+	//
+	// 1. Read the first byte to check if efuse is empty!!!
+	// 
+	//
+	rtemp8 = *(phymap+eFuse_Addr);
+	if(rtemp8 != 0xFF)
+	{
+		efuse_utilized++;
+		//printk("efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, *rtemp8);
+		eFuse_Addr++;
+	}
+	else
+	{
+		DBG_871X("EFUSE is empty efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, rtemp8);
+		goto exit;
+	}
+
+
+	//
+	// 2. Read real efuse content. Filter PG header and every section data.
+	//
+	while((rtemp8 != 0xFF) && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+	{
+		//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("efuse_Addr-%d efuse_data=%x\n", eFuse_Addr-1, *rtemp8));
+	
+		// Check PG header for section num.
+		if((rtemp8 & 0x1F ) == 0x0F)		//extended header
+		{			
+			u1temp =( (rtemp8 & 0xE0) >> 5);
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header u1temp=%x *rtemp&0xE0 0x%x\n", u1temp, *rtemp8 & 0xE0));
+
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header u1temp=%x \n", u1temp));
+
+			rtemp8 = *(phymap+eFuse_Addr);
+
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, *rtemp8));	
+			
+			if((rtemp8 & 0x0F) == 0x0F)
+			{
+				eFuse_Addr++;			
+				rtemp8 = *(phymap+eFuse_Addr);
+				
+				if(rtemp8 != 0xFF && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+				{
+					eFuse_Addr++;				
+				}				
+				continue;
+			}
+			else
+			{
+				offset = ((rtemp8 & 0xF0) >> 1) | u1temp;
+				wren = (rtemp8 & 0x0F);
+				eFuse_Addr++;				
+			}
+		}
+		else
+		{
+			offset = ((rtemp8 >> 4) & 0x0f);
+			wren = (rtemp8 & 0x0f);			
+		}
+		
+		if(offset < EFUSE_MAX_SECTION_88E)
+		{
+			// Get word enable value from PG header
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Offset-%d Worden=%x\n", offset, wren));
+
+			for(i=0; i<EFUSE_MAX_WORD_UNIT; i++)
+			{
+				// Check word enable condition in the section				
+				if(!(wren & 0x01))
+				{
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d \n", eFuse_Addr));
+					rtemp8 = *(phymap+eFuse_Addr);
+					eFuse_Addr++;
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Data=0x%x\n", *rtemp8)); 				
+					efuse_utilized++;
+					eFuseWord[offset][i] = (rtemp8 & 0xff);
+					
+
+					if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN_88E) 
+						break;
+
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d", eFuse_Addr));
+					rtemp8 = *(phymap+eFuse_Addr);
+					eFuse_Addr++;
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Data=0x%x\n", *rtemp8)); 				
+					
+					efuse_utilized++;
+					eFuseWord[offset][i] |= (((u2Byte)rtemp8 << 8) & 0xff00);
+
+					if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN_88E) 
+						break;
+				}
+				
+				wren >>= 1;
+				
+			}
+		}
+
+		// Read next PG header
+		rtemp8 = *(phymap+eFuse_Addr);
+		//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d rtemp 0x%x\n", eFuse_Addr, *rtemp8));
+		
+		if(rtemp8 != 0xFF && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+		{
+			efuse_utilized++;
+			eFuse_Addr++;
+		}
+	}
+
+	//
+	// 3. Collect 16 sections and 4 word unit into Efuse map.
+	//
+	for(i=0; i<EFUSE_MAX_SECTION_88E; i++)
+	{
+		for(j=0; j<EFUSE_MAX_WORD_UNIT; j++)
+		{
+			efuseTbl[(i*8)+(j*2)]=(eFuseWord[i][j] & 0xff);
+			efuseTbl[(i*8)+((j*2)+1)]=((eFuseWord[i][j] >> 8) & 0xff);
+		}
+	}
+
+
+	//
+	// 4. Copy from Efuse map to output pointer memory!!!
+	//
+	for(i=0; i<_size_byte; i++)
+	{		
+		pbuf[i] = efuseTbl[_offset+i];
+	}
+
+	//
+	// 5. Calculate Efuse utilization.
+	//
+	efuse_usage = (u1Byte)((efuse_utilized*100)/EFUSE_REAL_CONTENT_LEN_88E);
+	//Adapter->HalFunc.SetHwRegHandler(Adapter, HW_VAR_EFUSE_BYTES, (u8 *)&efuse_utilized);
+
+exit:
+	if(efuseTbl)
+		rtw_mfree(efuseTbl, EFUSE_MAP_LEN_88E);
+
+	if(eFuseWord)
+		rtw_mfree2d((void *)eFuseWord, EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, sizeof(u16));
+}
+
+void efuse_read_phymap_from_txpktbuf(
+	ADAPTER *adapter,
+	int bcnhead,	//beacon head, where FW store len(2-byte) and efuse physical map.
+	u8 *content,	//buffer to store efuse physical map
+	u16 *size	//for efuse content: the max byte to read. will update to byte read
+	)
+{
+	u16 dbg_addr = 0;
+	u32 start  = 0, passing_time = 0;
+	u8 reg_0x143 = 0;
+	u8 reg_0x106 = 0;
+	u32 lo32 = 0, hi32 = 0;
+	u16 len = 0, count = 0;
+	int i = 0;
+	u16 limit = *size;
+
+	u8 *pos = content;
+	
+	if(bcnhead<0) //if not valid
+		bcnhead = rtw_read8(adapter, REG_TDECTRL+1);
+
+	DBG_871X("%s bcnhead:%d\n", __FUNCTION__, bcnhead);
+
+	//reg_0x106 = rtw_read8(adapter, REG_PKT_BUFF_ACCESS_CTRL);
+	//DBG_871X("%s reg_0x106:0x%02x, write 0x%02x\n", __FUNCTION__, reg_0x106, 0x69);
+	rtw_write8(adapter, REG_PKT_BUFF_ACCESS_CTRL, TXPKT_BUF_SELECT);
+	//DBG_871X("%s reg_0x106:0x%02x\n", __FUNCTION__, rtw_read8(adapter, 0x106));
+
+	dbg_addr = bcnhead*128/8; //8-bytes addressing
+
+	while(1)
+	{
+		//DBG_871X("%s dbg_addr:0x%x\n", __FUNCTION__, dbg_addr+i);
+		rtw_write16(adapter, REG_PKTBUF_DBG_ADDR, dbg_addr+i);
+
+		//DBG_871X("%s write reg_0x143:0x00\n", __FUNCTION__);
+		rtw_write8(adapter, REG_TXPKTBUF_DBG, 0);
+		start = rtw_get_current_time();
+		while(!(reg_0x143=rtw_read8(adapter, REG_TXPKTBUF_DBG))//dbg
+		//while(rtw_read8(adapter, REG_TXPKTBUF_DBG) & BIT0
+			&& (passing_time=rtw_get_passing_time_ms(start))<1000
+		) {
+			DBG_871X("%s polling reg_0x143:0x%02x, reg_0x106:0x%02x\n", __FUNCTION__, reg_0x143, rtw_read8(adapter, 0x106));
+			rtw_usleep_os(100);
+		}
+
+
+		lo32 = rtw_read32(adapter, REG_PKTBUF_DBG_DATA_L);
+		hi32 = rtw_read32(adapter, REG_PKTBUF_DBG_DATA_H);
+
+		#if 0
+		DBG_871X("%s lo32:0x%08x, %02x %02x %02x %02x\n", __FUNCTION__, lo32
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L+1)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L+2)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L+3)
+		);
+		DBG_871X("%s hi32:0x%08x, %02x %02x %02x %02x\n", __FUNCTION__, hi32
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_H)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_H+1)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_H+2)
+			, rtw_read8(adapter, REG_PKTBUF_DBG_DATA_H+3)
+		);
+		#endif
+
+		if(i==0)
+		{
+			#if 1 //for debug
+			u8 lenc[2];
+			u16 lenbak, aaabak;
+			u16 aaa;
+			lenc[0] = rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L);
+			lenc[1] = rtw_read8(adapter, REG_PKTBUF_DBG_DATA_L+1);
+
+			aaabak = le16_to_cpup((u16*)lenc);
+			lenbak = le16_to_cpu(*((u16*)lenc));
+			aaa = le16_to_cpup((u16*)&lo32);
+			#endif
+			len = le16_to_cpu(*((u16*)&lo32));
+
+			limit = (len-2<limit)?len-2:limit;
+
+			DBG_871X("%s len:%u, lenbak:%u, aaa:%u, aaabak:%u\n", __FUNCTION__, len, lenbak, aaa, aaabak);
+
+			_rtw_memcpy(pos, ((u8*)&lo32)+2, (limit>=count+2)?2:limit-count);
+			count+= (limit>=count+2)?2:limit-count;
+			pos=content+count;
+			
+		}
+		else
+		{
+			_rtw_memcpy(pos, ((u8*)&lo32), (limit>=count+4)?4:limit-count);
+			count+=(limit>=count+4)?4:limit-count;
+			pos=content+count;
+			
+
+		}
+
+		if(limit>count && len-2>count) {
+			_rtw_memcpy(pos, (u8*)&hi32, (limit>=count+4)?4:limit-count);
+			count+=(limit>=count+4)?4:limit-count;
+			pos=content+count;
+		}
+
+		if(limit<=count || len-2<=count)
+			break;
+
+		i++;
+	}
+
+	rtw_write8(adapter, REG_PKT_BUFF_ACCESS_CTRL, DISABLE_TRXPKT_BUF_ACCESS);
+	
+	DBG_871X("%s read count:%u\n", __FUNCTION__, count);
+	*size = count;
+
+}
+
+
+static s32 iol_read_efuse(
+	PADAPTER padapter,
+	u8 txpktbuf_bndy,
+	u16 offset,
+	u16 size_byte,
+	u8 *logical_map
+	)
+{
+	s32 status = _FAIL;
+	u8 reg_0x106 = 0;
+	u8 physical_map[512];
+	u16 size = 512;
+	int i;
+
+
+	rtw_write8(padapter, REG_TDECTRL+1, txpktbuf_bndy);
+	_rtw_memset(physical_map, 0xFF, 512);
+	
+	///reg_0x106 = rtw_read8(padapter, REG_PKT_BUFF_ACCESS_CTRL);
+	//DBG_871X("%s reg_0x106:0x%02x, write 0x%02x\n", __FUNCTION__, reg_0x106, 0x69);
+	rtw_write8(padapter, REG_PKT_BUFF_ACCESS_CTRL, TXPKT_BUF_SELECT);
+	//DBG_871X("%s reg_0x106:0x%02x\n", __FUNCTION__, rtw_read8(padapter, 0x106));
+
+	status = iol_execute(padapter, CMD_READ_EFUSE_MAP);
+
+	if(status == _SUCCESS)
+		efuse_read_phymap_from_txpktbuf(padapter, txpktbuf_bndy, physical_map, &size);
+
+	#if 0
+	DBG_871X("%s physical map\n", __FUNCTION__);
+	for(i=0;i<size;i++)
+	{
+		DBG_871X("%02x ", physical_map[i]);
+		if(i%16==15)
+			DBG_871X("\n");
+	}
+	DBG_871X("\n");
+	#endif
+
+	efuse_phymap_to_logical(physical_map, offset, size_byte, logical_map);
+
+	return status;
+}
+
+s32 rtl8188e_iol_efuse_patch(PADAPTER padapter)
+{
+	s32	result = _SUCCESS;
+	printk("==> %s \n",__FUNCTION__);
+	
+	if(rtw_IOL_applied(padapter)){
+		iol_mode_enable(padapter, 1);
+		result = iol_execute(padapter, CMD_READ_EFUSE_MAP);
+		if(result == _SUCCESS)			
+			result = iol_execute(padapter, CMD_EFUSE_PATCH);
+		
+		iol_mode_enable(padapter, 0);
+	}
+	return result;
+}
+
+static s32 iol_ioconfig(
+	PADAPTER padapter,
+	u8 iocfg_bndy
+	)
+{
+	s32 rst = _SUCCESS; 
+	
+	//DBG_871X("%s iocfg_bndy:%u\n", __FUNCTION__, iocfg_bndy);
+	rtw_write8(padapter, REG_TDECTRL+1, iocfg_bndy);
+	rst = iol_execute(padapter, CMD_IOCONFIG);
+	
+	return rst;
+}
+
+int rtl8188e_IOL_exec_cmds_sync(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_wating_ms,u32 bndy_cnt)
+{
+	
+	u32 start_time = rtw_get_current_time();
+	u32 passing_time_ms;
+	u8 polling_ret,i;
+	int ret = _FAIL;
+	u32 t1,t2;
+	
+	//printk("===> %s ,bndy_cnt = %d \n",__FUNCTION__,bndy_cnt);
+	if (rtw_IOL_append_END_cmd(xmit_frame) != _SUCCESS)
+		goto exit;
+#ifdef CONFIG_USB_HCI
+	{
+		struct pkt_attrib	*pattrib = &xmit_frame->attrib;		
+		if(rtw_usb_bulk_size_boundary(adapter,TXDESC_SIZE+pattrib->last_txcmdsz))
+		{
+			if (rtw_IOL_append_END_cmd(xmit_frame) != _SUCCESS)
+				goto exit;
+		}			
+	}
+#endif //CONFIG_USB_HCI
+	
+	//rtw_IOL_cmd_buf_dump(adapter,xmit_frame->attrib.pktlen+TXDESC_OFFSET,xmit_frame->buf_addr);
+	//rtw_hal_mgnt_xmit(adapter, xmit_frame);
+	//rtw_dump_xframe_sync(adapter, xmit_frame);
+	
+	dump_mgntframe_and_wait(adapter, xmit_frame, max_wating_ms);
+	
+	t1=	rtw_get_current_time();
+	iol_mode_enable(adapter, 1);
+	for(i=0;i<bndy_cnt;i++){
+		u8 page_no = 0;
+		page_no = i*2 ;
+		//printk(" i = %d, page_no = %d \n",i,page_no);	
+		if( (ret = iol_ioconfig(adapter, page_no)) != _SUCCESS)
+		{
+			break;
+		}
+	}
+	iol_mode_enable(adapter, 0);
+	t2 = rtw_get_current_time();
+	//printk("==> %s :  %5u\n",__FUNCTION__,rtw_get_time_interval_ms(t1,t2));
+exit:
+	//restore BCN_HEAD
+	rtw_write8(adapter, REG_TDECTRL+1, 0);	
+	return ret;
+}
+
+void rtw_IOL_cmd_tx_pkt_buf_dump(ADAPTER *Adapter,int data_len)
+{
+	u32 fifo_data,reg_140;
+	u32 addr,rstatus,loop=0;
+
+	u16 data_cnts = (data_len/8)+1;				
+	u8 *pbuf =rtw_zvmalloc(data_len+10);
+	printk("###### %s ######\n",__FUNCTION__);
+	
+	rtw_write8(Adapter, REG_PKT_BUFF_ACCESS_CTRL, TXPKT_BUF_SELECT);
+	if(pbuf){
+		for(addr=0;addr< data_cnts;addr++){
+			//printk("==> addr:0x%02x\n",addr);
+			rtw_write32(Adapter,0x140,addr);
+			rtw_usleep_os(2);
+			loop=0;
+			do{
+				rstatus=(reg_140=rtw_read32(Adapter,REG_PKTBUF_DBG_CTRL)&BIT24);	
+				//printk("rstatus = %02x, reg_140:0x%08x\n",rstatus,reg_140);
+				if(rstatus){
+					fifo_data = rtw_read32(Adapter,REG_PKTBUF_DBG_DATA_L);
+					//printk("fifo_data_144:0x%08x\n",fifo_data);					
+					_rtw_memcpy(pbuf+(addr*8),&fifo_data , 4);  
+					
+					fifo_data = rtw_read32(Adapter,REG_PKTBUF_DBG_DATA_H);
+					//printk("fifo_data_148:0x%08x\n",fifo_data);					
+					_rtw_memcpy(pbuf+(addr*8+4), &fifo_data, 4); 
+					
+				}
+				rtw_usleep_os(2);
+			}while( !rstatus && (loop++ <10));
+		}
+		rtw_IOL_cmd_buf_dump(Adapter,data_len,pbuf);
+		rtw_vmfree(pbuf, data_len+10);	
+		
+	}					
+	printk("###### %s ######\n",__FUNCTION__);
+}
+
+#endif /* defined(CONFIG_IOL) */
+
+
+static VOID
+_FWDownloadEnable_8188E(
+	IN	PADAPTER		padapter,
+	IN	BOOLEAN			enable
+	)
+{
+	u8	tmp;
+
+	if(enable)
+	{
+		// MCU firmware download enable.
+		tmp = rtw_read8(padapter, REG_MCUFWDL);
+		rtw_write8(padapter, REG_MCUFWDL, tmp|0x01);
+
+		// 8051 reset
+		tmp = rtw_read8(padapter, REG_MCUFWDL+2);
+		rtw_write8(padapter, REG_MCUFWDL+2, tmp&0xf7);
+	}
+	else
+	{		
+		
+		// MCU firmware download disable.
+		tmp = rtw_read8(padapter, REG_MCUFWDL);
+		rtw_write8(padapter, REG_MCUFWDL, tmp&0xfe);
+
+		// Reserved for fw extension.
+		rtw_write8(padapter, REG_MCUFWDL+1, 0x00);
+	}
+}
+#define MAX_REG_BOLCK_SIZE	196 
+static int
+_BlockWrite(
+	IN		PADAPTER		padapter,
+	IN		PVOID		buffer,
+	IN		u32			buffSize
+	)
+{
+	int ret = _SUCCESS;
+
+	u32			blockSize_p1 = 4;	// (Default) Phase #1 : PCI muse use 4-byte write to download FW
+	u32			blockSize_p2 = 8;	// Phase #2 : Use 8-byte, if Phase#1 use big size to write FW.
+	u32			blockSize_p3 = 1;	// Phase #3 : Use 1-byte, the remnant of FW image.
+	u32			blockCount_p1 = 0, blockCount_p2 = 0, blockCount_p3 = 0;
+	u32			remainSize_p1 = 0, remainSize_p2 = 0;
+	u8			*bufferPtr	= (u8*)buffer;
+	u32			i=0, offset=0;
+#ifdef CONFIG_PCI_HCI
+	u8			remainFW[4] = {0, 0, 0, 0};
+	u8			*p = NULL;
+#endif
+
+#ifdef CONFIG_USB_HCI
+	blockSize_p1 = MAX_REG_BOLCK_SIZE;
+#endif
+
+	//3 Phase #1
+	blockCount_p1 = buffSize / blockSize_p1;
+	remainSize_p1 = buffSize % blockSize_p1;
+
+	if (blockCount_p1) {
+		RT_TRACE(_module_hal_init_c_, _drv_notice_,
+				("_BlockWrite: [P1] buffSize(%d) blockSize_p1(%d) blockCount_p1(%d) remainSize_p1(%d)\n",
+				buffSize, blockSize_p1, blockCount_p1, remainSize_p1));
+	}
+
+	for (i = 0; i < blockCount_p1; i++)
+	{
+#ifdef CONFIG_USB_HCI
+		ret = rtw_writeN(padapter, (FW_8188E_START_ADDRESS + i * blockSize_p1), blockSize_p1, (bufferPtr + i * blockSize_p1));
+#else
+		ret = rtw_write32(padapter, (FW_8188E_START_ADDRESS + i * blockSize_p1), le32_to_cpu(*((u32*)(bufferPtr + i * blockSize_p1))));
+#endif
+
+		if(ret == _FAIL)
+			goto exit;
+	}
+
+#ifdef CONFIG_PCI_HCI
+	p = (u8*)((u32*)(bufferPtr + blockCount_p1 * blockSize_p1));
+	if (remainSize_p1) {
+		switch (remainSize_p1) {
+		case 0:
+			break;
+		case 3:
+			remainFW[2]=*(p+2);
+		case 2: 	
+			remainFW[1]=*(p+1);
+		case 1: 	
+			remainFW[0]=*(p);
+			ret = rtw_write32(padapter, (FW_8188E_START_ADDRESS + blockCount_p1 * blockSize_p1), 
+				 le32_to_cpu(*(u32*)remainFW));	
+		}
+		return ret;
+	}
+#endif
+
+	//3 Phase #2
+	if (remainSize_p1)
+	{
+		offset = blockCount_p1 * blockSize_p1;
+
+		blockCount_p2 = remainSize_p1/blockSize_p2;
+		remainSize_p2 = remainSize_p1%blockSize_p2;
+
+		if (blockCount_p2) {
+				RT_TRACE(_module_hal_init_c_, _drv_notice_,
+						("_BlockWrite: [P2] buffSize_p2(%d) blockSize_p2(%d) blockCount_p2(%d) remainSize_p2(%d)\n",
+						(buffSize-offset), blockSize_p2 ,blockCount_p2, remainSize_p2));
+		}
+
+#ifdef CONFIG_USB_HCI
+		for (i = 0; i < blockCount_p2; i++) {
+			ret = rtw_writeN(padapter, (FW_8188E_START_ADDRESS + offset + i*blockSize_p2), blockSize_p2, (bufferPtr + offset + i*blockSize_p2));
+			
+			if(ret == _FAIL)
+				goto exit;
+		}
+#endif
+	}
+
+	//3 Phase #3
+	if (remainSize_p2)
+	{
+		offset = (blockCount_p1 * blockSize_p1) + (blockCount_p2 * blockSize_p2);
+
+		blockCount_p3 = remainSize_p2 / blockSize_p3;
+
+		RT_TRACE(_module_hal_init_c_, _drv_notice_,
+				("_BlockWrite: [P3] buffSize_p3(%d) blockSize_p3(%d) blockCount_p3(%d)\n",
+				(buffSize-offset), blockSize_p3, blockCount_p3));
+
+		for(i = 0 ; i < blockCount_p3 ; i++){
+			ret =rtw_write8(padapter, (FW_8188E_START_ADDRESS + offset + i), *(bufferPtr + offset + i));
+			
+			if(ret == _FAIL)
+				goto exit;
+		}
+	}
+
+exit:
+	return ret;
+}
+
+static int
+_PageWrite(
+	IN		PADAPTER	padapter,
+	IN		u32			page,
+	IN		PVOID		buffer,
+	IN		u32			size
+	)
+{
+	u8 value8;
+	u8 u8Page = (u8) (page & 0x07) ;
+
+	value8 = (rtw_read8(padapter, REG_MCUFWDL+2) & 0xF8) | u8Page ;
+	rtw_write8(padapter, REG_MCUFWDL+2,value8);
+
+	return _BlockWrite(padapter,buffer,size);
+}
+
+static VOID
+_FillDummy(
+	u8*		pFwBuf,
+	u32*	pFwLen
+	)
+{
+	u32	FwLen = *pFwLen;
+	u8	remain = (u8)(FwLen%4);
+	remain = (remain==0)?0:(4-remain);
+
+	while(remain>0)
+	{
+		pFwBuf[FwLen] = 0;
+		FwLen++;
+		remain--;
+	}
+
+	*pFwLen = FwLen;
+}
+
+static int
+_WriteFW(
+	IN		PADAPTER		padapter,
+	IN		PVOID			buffer,
+	IN		u32			size
+	)
+{
+	// Since we need dynamic decide method of dwonload fw, so we call this function to get chip version.
+	// We can remove _ReadChipVersion from ReadpadapterInfo8192C later.
+	int ret = _SUCCESS;
+	u32 	pageNums,remainSize ;
+	u32 	page, offset;
+	u8		*bufferPtr = (u8*)buffer;
+
+#ifdef CONFIG_PCI_HCI
+	// 20100120 Joseph: Add for 88CE normal chip.
+	// Fill in zero to make firmware image to dword alignment.
+//		_FillDummy(bufferPtr, &size);
+#endif
+
+	pageNums = size / MAX_DLFW_PAGE_SIZE ;
+	//RT_ASSERT((pageNums <= 4), ("Page numbers should not greater then 4 \n"));
+	remainSize = size % MAX_DLFW_PAGE_SIZE;
+
+	for (page = 0; page < pageNums; page++) {
+		offset = page * MAX_DLFW_PAGE_SIZE;
+		ret = _PageWrite(padapter, page, bufferPtr+offset, MAX_DLFW_PAGE_SIZE);
+		
+		if(ret == _FAIL)
+			goto exit;
+	}
+	if (remainSize) {
+		offset = pageNums * MAX_DLFW_PAGE_SIZE;
+		page = pageNums;
+		ret = _PageWrite(padapter, page, bufferPtr+offset, remainSize);
+		
+		if(ret == _FAIL)
+			goto exit;
+
+	}
+	RT_TRACE(_module_hal_init_c_, _drv_info_, ("_WriteFW Done- for Normal chip.\n"));
+
+exit:
+	return ret;
+}
+
+void _MCUIO_Reset88E(PADAPTER padapter,u8 bReset)
+{
+	u8 u1bTmp;
+
+	if(bReset==_TRUE){
+		// Reset MCU IO Wrapper- sugggest by SD1-Gimmy
+		u1bTmp = rtw_read8(padapter, REG_RSV_CTRL+1);
+		rtw_write8(padapter,REG_RSV_CTRL+1, (u1bTmp&(~BIT3)));
+	}else{
+		// Enable MCU IO Wrapper
+		u1bTmp = rtw_read8(padapter, REG_RSV_CTRL+1);
+		rtw_write8(padapter, REG_RSV_CTRL+1, u1bTmp|BIT3);
+	}
+
+}
+
+void _8051Reset88E(PADAPTER padapter)
+{
+	u8 u1bTmp;
+	
+	_MCUIO_Reset88E(padapter,_TRUE);
+	u1bTmp = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
+	rtw_write8(padapter, REG_SYS_FUNC_EN+1, u1bTmp&(~BIT2));
+	_MCUIO_Reset88E(padapter,_FALSE);
+	rtw_write8(padapter, REG_SYS_FUNC_EN+1, u1bTmp|(BIT2));
+	
+	DBG_871X("=====> _8051Reset88E(): 8051 reset success .\n");
+}
+
+extern u8 g_fwdl_chksum_fail;
+static s32 polling_fwdl_chksum(_adapter *adapter, u32 min_cnt, u32 timeout_ms)
+{
+	s32 ret = _FAIL;
+	u32 value32;
+	u32 start = rtw_get_current_time();
+	u32 cnt = 0;
+
+	/* polling CheckSum report */
+	do {
+		cnt++;
+		value32 = rtw_read32(adapter, REG_MCUFWDL);
+		if (value32 & FWDL_ChkSum_rpt || adapter->bSurpriseRemoved || adapter->bDriverStopped)
+			break;
+		rtw_yield_os();
+	} while (rtw_get_passing_time_ms(start) < timeout_ms || cnt < min_cnt);
+
+	if (!(value32 & FWDL_ChkSum_rpt)) {
+		goto exit;
+	}
+
+	if (g_fwdl_chksum_fail) {
+		DBG_871X("%s: fwdl test case: fwdl_chksum_fail\n", __FUNCTION__);
+		g_fwdl_chksum_fail--;
+		goto exit;
+	}
+
+	ret = _SUCCESS;
+
+exit:
+	DBG_871X("%s: Checksum report %s! (%u, %dms), REG_MCUFWDL:0x%08x\n", __FUNCTION__
+	, (ret==_SUCCESS)?"OK":"Fail", cnt, rtw_get_passing_time_ms(start), value32);
+
+	return ret;
+}
+
+extern u8 g_fwdl_wintint_rdy_fail;
+static s32 _FWFreeToGo(_adapter *adapter, u32 min_cnt, u32 timeout_ms)
+{
+	s32 ret = _FAIL;
+	u32	value32;
+	u32 start = rtw_get_current_time();
+	u32 cnt = 0;
+
+	value32 = rtw_read32(adapter, REG_MCUFWDL);
+	value32 |= MCUFWDL_RDY;
+	value32 &= ~WINTINI_RDY;
+	rtw_write32(adapter, REG_MCUFWDL, value32);
+
+	_8051Reset88E(adapter);
+
+	/*  polling for FW ready */
+	do {
+		cnt++;
+		value32 = rtw_read32(adapter, REG_MCUFWDL);
+		if (value32 & WINTINI_RDY || adapter->bSurpriseRemoved || adapter->bDriverStopped)
+			break;
+		rtw_yield_os();
+	} while (rtw_get_passing_time_ms(start) < timeout_ms || cnt < min_cnt);
+
+	if (!(value32 & WINTINI_RDY)) {
+		goto exit;
+	}
+
+	if (g_fwdl_wintint_rdy_fail) {
+		DBG_871X("%s: fwdl test case: wintint_rdy_fail\n", __FUNCTION__);
+		g_fwdl_wintint_rdy_fail--;
+		goto exit;
+	}
+
+	ret = _SUCCESS;
+
+exit:
+	DBG_871X("%s: Polling FW ready %s! (%u, %dms), REG_MCUFWDL:0x%08x\n", __FUNCTION__
+		, (ret==_SUCCESS)?"OK":"Fail", cnt, rtw_get_passing_time_ms(start), value32);
+	return ret;
+}
+
+#define IS_FW_81xxC(padapter)	(((GET_HAL_DATA(padapter))->FirmwareSignature & 0xFFF0) == 0x88C0)
+
+
+#ifdef CONFIG_FILE_FWIMG
+extern char *rtw_fw_file_path;
+extern char *rtw_fw_wow_file_path;
+u8	FwBuffer8188E[FW_8188E_SIZE];
+#endif //CONFIG_FILE_FWIMG
+
+//
+//	Description:
+//		Download 8192C firmware code.
+//
+//
+s32 rtl8188e_FirmwareDownload(PADAPTER padapter, BOOLEAN  bUsedWoWLANFw)
+{
+	s32	rtStatus = _SUCCESS;
+	u8 write_fw = 0;
+	u32 fwdl_start_time;
+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(padapter);	
+
+#ifdef CONFIG_WOWLAN
+	u8			*FwImageWoWLAN;
+	u32			FwImageWoWLANLen;
+#endif
+
+	PRT_FIRMWARE_8188E	pFirmware = NULL;
+	PRT_8188E_FIRMWARE_HDR		pFwHdr = NULL;
+	
+	u8			*pFirmwareBuf;
+	u32			FirmwareLen;
+#ifdef CONFIG_FILE_FWIMG
+	u8 *fwfilepath;
+#endif // CONFIG_FILE_FWIMG
+
+	RT_TRACE(_module_hal_init_c_, _drv_info_, ("+%s\n", __FUNCTION__));
+	pFirmware = (PRT_FIRMWARE_8188E)rtw_zmalloc(sizeof(RT_FIRMWARE_8188E));
+	if(!pFirmware)
+	{
+		rtStatus = _FAIL;
+		goto exit;
+	}
+
+
+//	RT_TRACE(_module_hal_init_c_, _drv_err_, ("rtl8723a_FirmwareDownload: %s\n", pFwImageFileName));
+
+#ifdef CONFIG_FILE_FWIMG
+#ifdef CONFIG_WOWLAN
+		if (bUsedWoWLANFw)
+		{
+			fwfilepath = rtw_fw_wow_file_path;
+		}
+		else
+#endif // CONFIG_WOWLAN
+		{
+			fwfilepath = rtw_fw_file_path;
+		}
+#endif // CONFIG_FILE_FWIMG
+
+#ifdef CONFIG_FILE_FWIMG
+	if(rtw_is_file_readable(fwfilepath) == _TRUE)
+	{
+		DBG_871X("%s accquire FW from file:%s\n", __FUNCTION__, fwfilepath);
+		pFirmware->eFWSource = FW_SOURCE_IMG_FILE;
+	}
+	else
+#endif //CONFIG_FILE_FWIMG
+	{
+		pFirmware->eFWSource = FW_SOURCE_HEADER_FILE;
+	}
+
+	switch(pFirmware->eFWSource)
+	{
+		case FW_SOURCE_IMG_FILE:
+			#ifdef CONFIG_FILE_FWIMG
+			rtStatus = rtw_retrive_from_file(fwfilepath, FwBuffer8188E, FW_8188E_SIZE);
+			pFirmware->ulFwLength = rtStatus>=0?rtStatus:0;
+			pFirmware->szFwBuffer = FwBuffer8188E;
+			#endif //CONFIG_FILE_FWIMG
+			break;
+		case FW_SOURCE_HEADER_FILE:
+#ifdef CONFIG_WOWLAN
+			if(bUsedWoWLANFw) {
+				ODM_ConfigFWWithHeaderFile(&pHalData->odmpriv, CONFIG_FW_WoWLAN, 
+					(u8 *)&(pFirmware->szFwBuffer), &(pFirmware->ulFwLength));
+				DBG_871X("%s fw:%s, size: %d\n",__FUNCTION__, "WoWLAN", pFirmware->ulFwLength);
+			}else
+#endif //CONFIG_WOWLAN
+			{
+				ODM_ConfigFWWithHeaderFile(&pHalData->odmpriv, CONFIG_FW_NIC, 
+					(u8 *)&(pFirmware->szFwBuffer), &(pFirmware->ulFwLength));
+				DBG_871X("%s fw:%s, size: %d\n", __FUNCTION__, "NIC", pFirmware->ulFwLength);
+			}
+			break;
+	}
+
+	if (pFirmware->ulFwLength > FW_8188E_SIZE) {
+		rtStatus = _FAIL;
+		DBG_871X_LEVEL(_drv_emerg_, "Firmware size:%u exceed %u\n", pFirmware->ulFwLength, FW_8188E_SIZE);
+		goto exit;
+	}
+	
+	pFirmwareBuf = pFirmware->szFwBuffer;
+	FirmwareLen = pFirmware->ulFwLength;
+
+	// To Check Fw header. Added by tynli. 2009.12.04.
+	pFwHdr = (PRT_8188E_FIRMWARE_HDR)pFirmwareBuf;
+
+	pHalData->FirmwareVersion =  le16_to_cpu(pFwHdr->Version);
+	pHalData->FirmwareSubVersion = pFwHdr->Subversion;
+	pHalData->FirmwareSignature = le16_to_cpu(pFwHdr->Signature);
+
+	DBG_871X("%s: fw_ver=%x fw_subver=%04x sig=0x%x, Month=%02x, Date=%02x, Hour=%02x, Minute=%02x\n",
+		  __FUNCTION__, pHalData->FirmwareVersion, pHalData->FirmwareSubVersion, pHalData->FirmwareSignature
+		  ,pFwHdr->Month,pFwHdr->Date,pFwHdr->Hour,pFwHdr->Minute);
+		
+	if (IS_FW_HEADER_EXIST_88E(pFwHdr))
+	{
+		// Shift 32 bytes for FW header
+		pFirmwareBuf = pFirmwareBuf + 32;
+		FirmwareLen = FirmwareLen - 32;
+	}
+
+	// Suggested by Filen. If 8051 is running in RAM code, driver should inform Fw to reset by itself,
+	// or it will cause download Fw fail. 2010.02.01. by tynli.
+	if (rtw_read8(padapter, REG_MCUFWDL) & RAM_DL_SEL) //8051 RAM code
+	{
+		rtw_write8(padapter, REG_MCUFWDL, 0x00);
+		_8051Reset88E(padapter);		
+	}
+
+	_FWDownloadEnable_8188E(padapter, _TRUE);
+	fwdl_start_time = rtw_get_current_time();
+	while(!padapter->bDriverStopped && !padapter->bSurpriseRemoved
+			&& (write_fw++ < 3 || rtw_get_passing_time_ms(fwdl_start_time) < 500))
+	{
+		/* reset FWDL chksum */
+		rtw_write8(padapter, REG_MCUFWDL, rtw_read8(padapter, REG_MCUFWDL)|FWDL_ChkSum_rpt);
+		
+		rtStatus = _WriteFW(padapter, pFirmwareBuf, FirmwareLen);
+		if (rtStatus != _SUCCESS)
+			continue;
+
+		rtStatus = polling_fwdl_chksum(padapter, 5, 50);
+		if (rtStatus == _SUCCESS)
+			break;
+	}
+	_FWDownloadEnable_8188E(padapter, _FALSE);
+	if(_SUCCESS != rtStatus)
+		goto fwdl_stat;
+
+	rtStatus = _FWFreeToGo(padapter, 10, 200);
+	if (_SUCCESS != rtStatus)
+		goto fwdl_stat;
+
+fwdl_stat:
+	DBG_871X("FWDL %s. write_fw:%u, %dms\n"
+		, (rtStatus == _SUCCESS)?"success":"fail"
+		, write_fw
+		, rtw_get_passing_time_ms(fwdl_start_time)
+	);
+
+exit:
+	if (pFirmware)
+		rtw_mfree((u8*)pFirmware, sizeof(RT_FIRMWARE_8188E));
+
+	return rtStatus;
+}
+
+void rtl8188e_InitializeFirmwareVars(PADAPTER padapter)
+{
+	PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
+	struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
+
+	// Init Fw LPS related.
+	pwrpriv->bFwCurrentInPSMode = _FALSE;
+
+	//Init H2C cmd.
+	rtw_write8(padapter, REG_HMETFR, 0x0f);
+
+	// Init H2C counter. by tynli. 2009.12.09.
+	pHalData->LastHMEBoxNum = 0;
+}
+
+#ifdef CONFIG_WOWLAN
+//===========================================
+
+//
+// Description: Prepare some information to Fw for WoWLAN.
+//					(1) Download wowlan Fw.
+//					(2) Download RSVD page packets.
+//					(3) Enable AP offload if needed.
+//
+// 2011.04.12 by tynli.
+//
+VOID
+SetFwRelatedForWoWLAN8188ES(
+		IN		PADAPTER			padapter,
+		IN		u8					bHostIsGoingtoSleep
+)
+{
+		int				status=_FAIL;
+		HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+		u8				bRecover = _FALSE;
+	//
+	// 1. Before WoWLAN we need to re-download WoWLAN Fw.
+	//
+	status = rtl8188e_FirmwareDownload(padapter, bHostIsGoingtoSleep);
+	if(status != _SUCCESS) {
+		DBG_871X("ConfigFwRelatedForWoWLAN8188ES(): Re-Download Firmware failed!!\n");
+		return;
+	} else {
+		DBG_871X("ConfigFwRelatedForWoWLAN8188ES(): Re-Download Firmware Success !!\n");
+	}
+	//
+	// 2. Re-Init the variables about Fw related setting.
+	//
+	rtl8188e_InitializeFirmwareVars(padapter);
+}
+#endif //CONFIG_WOWLAN
+
+static void rtl8188e_free_hal_data(PADAPTER padapter)
+{
+_func_enter_;
+
+	if(padapter->HalData)
+	{
+		rtw_vmfree(padapter->HalData, sizeof(HAL_DATA_TYPE));
+		padapter->HalData = NULL;
+	}
+	
+_func_exit_;
+}
+
+//===========================================================
+//				Efuse related code
+//===========================================================
+enum{
+		VOLTAGE_V25						= 0x03,
+		LDOE25_SHIFT						= 28 ,
+	};
+
+static BOOLEAN
+hal_EfusePgPacketWrite2ByteHeader(
+	IN	PADAPTER		pAdapter,
+	IN	u8				efuseType,
+	IN	u16				*pAddr,
+	IN	PPGPKT_STRUCT	pTargetPkt,
+	IN	BOOLEAN			bPseudoTest);
+static BOOLEAN
+hal_EfusePgPacketWrite1ByteHeader(
+	IN	PADAPTER		pAdapter,
+	IN	u8				efuseType,
+	IN	u16				*pAddr,
+	IN	PPGPKT_STRUCT	pTargetPkt,
+	IN	BOOLEAN			bPseudoTest);
+static BOOLEAN
+hal_EfusePgPacketWriteData(
+	IN	PADAPTER		pAdapter,
+	IN	u8				efuseType,
+	IN	u16				*pAddr,
+	IN	PPGPKT_STRUCT	pTargetPkt,
+	IN	BOOLEAN			bPseudoTest);
+
+static VOID
+hal_EfusePowerSwitch_RTL8188E(
+	IN	PADAPTER	pAdapter,
+	IN	u8		bWrite,
+	IN	u8		PwrState)
+{
+	u8	tempval;
+	u16	tmpV16;
+
+	if (PwrState == _TRUE)
+	{
+		rtw_write8(pAdapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_ON);
+
+		// 1.2V Power: From VDDON with Power Cut(0x0000h[15]), defualt valid
+		tmpV16 = rtw_read16(pAdapter,REG_SYS_ISO_CTRL);
+		if( ! (tmpV16 & PWC_EV12V ) ){
+			tmpV16 |= PWC_EV12V ;
+			 rtw_write16(pAdapter,REG_SYS_ISO_CTRL,tmpV16);
+		}
+		// Reset: 0x0000h[28], default valid
+		tmpV16 =  rtw_read16(pAdapter,REG_SYS_FUNC_EN);
+		if( !(tmpV16 & FEN_ELDR) ){
+			tmpV16 |= FEN_ELDR ;
+			rtw_write16(pAdapter,REG_SYS_FUNC_EN,tmpV16);
+		}
+
+		// Clock: Gated(0x0008h[5]) 8M(0x0008h[1]) clock from ANA, default valid
+		tmpV16 = rtw_read16(pAdapter,REG_SYS_CLKR);
+		if( (!(tmpV16 & LOADER_CLK_EN) )  ||(!(tmpV16 & ANA8M) ) ){
+			tmpV16 |= (LOADER_CLK_EN |ANA8M ) ;
+			rtw_write16(pAdapter,REG_SYS_CLKR,tmpV16);
+		}
+
+		if(bWrite == _TRUE)
+		{
+			// Enable LDO 2.5V before read/write action
+			tempval = rtw_read8(pAdapter, EFUSE_TEST+3);
+			tempval &= 0x0F;
+			tempval |= (VOLTAGE_V25 << 4);
+			rtw_write8(pAdapter, EFUSE_TEST+3, (tempval | 0x80));
+		}
+	}
+	else
+	{
+		rtw_write8(pAdapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_OFF);
+
+		if(bWrite == _TRUE){
+			// Disable LDO 2.5V after read/write action
+			tempval = rtw_read8(pAdapter, EFUSE_TEST+3);
+			rtw_write8(pAdapter, EFUSE_TEST+3, (tempval & 0x7F));
+		}
+	}
+}
+
+static VOID
+rtl8188e_EfusePowerSwitch(
+	IN	PADAPTER	pAdapter,
+	IN	u8		bWrite,
+	IN	u8		PwrState)
+{
+	hal_EfusePowerSwitch_RTL8188E(pAdapter, bWrite, PwrState);	
+}
+
+
+
+static bool efuse_read_phymap(
+	PADAPTER	Adapter,
+	u8			*pbuf,	//buffer to store efuse physical map
+	u16			*size	//the max byte to read. will update to byte read
+	)
+{
+	u8 *pos = pbuf;
+	u16 limit = *size;
+	u16 addr = 0;
+	bool reach_end = _FALSE;
+
+	//
+	// Refresh efuse init map as all 0xFF.
+	//
+	_rtw_memset(pbuf, 0xFF, limit);
+		
+	
+	//
+	// Read physical efuse content.
+	//
+	while(addr < limit)
+	{
+		ReadEFuseByte(Adapter, addr, pos, _FALSE);
+		if(*pos != 0xFF)
+		{
+			pos++;
+			addr++;
+		}
+		else
+		{
+			reach_end = _TRUE;
+			break;
+		}
+	}
+
+	*size = addr;
+
+	return reach_end;
+
+}
+
+static VOID
+Hal_EfuseReadEFuse88E(
+	PADAPTER		Adapter,
+	u16			_offset,
+	u16 			_size_byte,
+	u8      		*pbuf,
+	IN	BOOLEAN	bPseudoTest
+	)
+{
+	//u8	efuseTbl[EFUSE_MAP_LEN_88E];
+	u8	*efuseTbl = NULL;
+	u8	rtemp8[1];
+	u16	eFuse_Addr = 0;
+	u8	offset, wren;
+	u16	i, j;
+	//u16	eFuseWord[EFUSE_MAX_SECTION_88E][EFUSE_MAX_WORD_UNIT];
+	u16	**eFuseWord = NULL;
+	u16	efuse_utilized = 0;
+	u8	efuse_usage = 0;
+	u8	u1temp = 0;
+
+	//
+	// Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10.
+	//
+	if((_offset + _size_byte)>EFUSE_MAP_LEN_88E)
+	{// total E-Fuse table is 512bytes
+		DBG_8192C("Hal_EfuseReadEFuse88E(): Invalid offset(%#x) with read bytes(%#x)!!\n",_offset, _size_byte);
+		goto exit;
+	}
+
+	efuseTbl = (u8*)rtw_zmalloc(EFUSE_MAP_LEN_88E);
+	if(efuseTbl == NULL)
+	{
+		DBG_871X("%s: alloc efuseTbl fail!\n", __FUNCTION__);
+		goto exit;
+	}
+
+	eFuseWord= (u16 **)rtw_malloc2d(EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, 2);
+	if(eFuseWord == NULL)
+	{
+		DBG_871X("%s: alloc eFuseWord fail!\n", __FUNCTION__);
+		goto exit;
+	}
+
+	// 0. Refresh efuse init map as all oxFF.
+	for (i = 0; i < EFUSE_MAX_SECTION_88E; i++)
+		for (j = 0; j < EFUSE_MAX_WORD_UNIT; j++)
+			eFuseWord[i][j] = 0xFFFF;
+
+	//
+	// 1. Read the first byte to check if efuse is empty!!!
+	// 
+	//
+	ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest);	
+	if(*rtemp8 != 0xFF)
+	{
+		efuse_utilized++;
+		//DBG_8192C("efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, *rtemp8);
+		eFuse_Addr++;
+	}
+	else
+	{
+		DBG_871X("EFUSE is empty efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, *rtemp8);
+		goto exit;
+	}
+
+
+	//
+	// 2. Read real efuse content. Filter PG header and every section data.
+	//
+	while((*rtemp8 != 0xFF) && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+	{
+		//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("efuse_Addr-%d efuse_data=%x\n", eFuse_Addr-1, *rtemp8));
+	
+		// Check PG header for section num.
+		if((*rtemp8 & 0x1F ) == 0x0F)		//extended header
+		{			
+			u1temp =( (*rtemp8 & 0xE0) >> 5);
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header u1temp=%x *rtemp&0xE0 0x%x\n", u1temp, *rtemp8 & 0xE0));
+
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header u1temp=%x \n", u1temp));
+			
+			ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest);	
+
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("extended header efuse_Addr-%d efuse_data=%x\n", eFuse_Addr, *rtemp8));	
+			
+			if((*rtemp8 & 0x0F) == 0x0F)
+			{
+				eFuse_Addr++;			
+				ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest); 
+				
+				if(*rtemp8 != 0xFF && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+				{
+					eFuse_Addr++;				
+				}				
+				continue;
+			}
+			else
+			{
+				offset = ((*rtemp8 & 0xF0) >> 1) | u1temp;
+				wren = (*rtemp8 & 0x0F);
+				eFuse_Addr++;				
+			}
+		}
+		else
+		{
+			offset = ((*rtemp8 >> 4) & 0x0f);
+			wren = (*rtemp8 & 0x0f);			
+		}
+		
+		if(offset < EFUSE_MAX_SECTION_88E)
+		{
+			// Get word enable value from PG header
+			//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Offset-%d Worden=%x\n", offset, wren));
+
+			for(i=0; i<EFUSE_MAX_WORD_UNIT; i++)
+			{
+				// Check word enable condition in the section				
+				if(!(wren & 0x01))
+				{
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d \n", eFuse_Addr));
+					ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest);	
+					eFuse_Addr++;
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Data=0x%x\n", *rtemp8)); 				
+					efuse_utilized++;
+					eFuseWord[offset][i] = (*rtemp8 & 0xff);
+					
+
+					if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN_88E) 
+						break;
+
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d", eFuse_Addr));
+					ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest);	
+					eFuse_Addr++;
+					//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Data=0x%x\n", *rtemp8)); 				
+					
+					efuse_utilized++;
+					eFuseWord[offset][i] |= (((u2Byte)*rtemp8 << 8) & 0xff00);
+
+					if(eFuse_Addr >= EFUSE_REAL_CONTENT_LEN_88E) 
+						break;
+				}
+				
+				wren >>= 1;
+				
+			}
+		}
+
+		// Read next PG header
+		ReadEFuseByte(Adapter, eFuse_Addr, rtemp8, bPseudoTest);	
+		//RTPRINT(FEEPROM, EFUSE_READ_ALL, ("Addr=%d rtemp 0x%x\n", eFuse_Addr, *rtemp8));
+		
+		if(*rtemp8 != 0xFF && (eFuse_Addr < EFUSE_REAL_CONTENT_LEN_88E))
+		{
+			efuse_utilized++;
+			eFuse_Addr++;
+		}
+	}
+
+	//
+	// 3. Collect 16 sections and 4 word unit into Efuse map.
+	//
+	for(i=0; i<EFUSE_MAX_SECTION_88E; i++)
+	{
+		for(j=0; j<EFUSE_MAX_WORD_UNIT; j++)
+		{
+			efuseTbl[(i*8)+(j*2)]=(eFuseWord[i][j] & 0xff);
+			efuseTbl[(i*8)+((j*2)+1)]=((eFuseWord[i][j] >> 8) & 0xff);
+		}
+	}
+
+
+	//
+	// 4. Copy from Efuse map to output pointer memory!!!
+	//
+	for(i=0; i<_size_byte; i++)
+	{		
+		pbuf[i] = efuseTbl[_offset+i];
+	}
+
+	//
+	// 5. Calculate Efuse utilization.
+	//
+	efuse_usage = (u1Byte)((eFuse_Addr*100)/EFUSE_REAL_CONTENT_LEN_88E);
+	rtw_hal_set_hwreg(Adapter, HW_VAR_EFUSE_BYTES, (u8 *)&eFuse_Addr);
+
+exit:
+	if(efuseTbl)
+		rtw_mfree(efuseTbl, EFUSE_MAP_LEN_88E);
+
+	if(eFuseWord)
+		rtw_mfree2d((void *)eFuseWord, EFUSE_MAX_SECTION_88E, EFUSE_MAX_WORD_UNIT, sizeof(u16));
+}
+
+
+static BOOLEAN
+Hal_EfuseSwitchToBank(
+	IN		PADAPTER	pAdapter,
+	IN		u8			bank,
+	IN		BOOLEAN		bPseudoTest
+	)
+{
+	BOOLEAN		bRet = _FALSE;
+	u32		value32=0;
+
+	//RTPRINT(FEEPROM, EFUSE_PG, ("Efuse switch bank to %d\n", bank));
+	if(bPseudoTest)
+	{
+		fakeEfuseBank = bank;
+		bRet = _TRUE;
+	}
+	else
+	{
+		if(IS_HARDWARE_TYPE_8723A(pAdapter) &&
+			INCLUDE_MULTI_FUNC_BT(pAdapter))
+		{
+			value32 = rtw_read32(pAdapter, EFUSE_TEST);
+			bRet = _TRUE;
+			switch(bank)
+			{
+			case 0:
+				value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
+				break;
+			case 1:
+				value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_0);
+				break;
+			case 2:
+				value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_1);
+				break;
+			case 3:
+				value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_2);
+				break;
+			default:
+				value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
+				bRet = _FALSE;
+				break;
+			}
+			rtw_write32(pAdapter, EFUSE_TEST, value32);
+		}
+		else
+			bRet = _TRUE;
+	}
+	return bRet;
+}
+
+
+
+static VOID
+ReadEFuseByIC(
+	PADAPTER	Adapter,
+	u8		efuseType,
+	u16		 _offset,
+	u16 		_size_byte,
+	u8      	*pbuf,
+	IN BOOLEAN	bPseudoTest
+	)
+{
+#ifdef DBG_IOL_READ_EFUSE_MAP
+	u8 logical_map[512];
+#endif
+
+#ifdef CONFIG_IOL_READ_EFUSE_MAP
+	if(!bPseudoTest )//&& rtw_IOL_applied(Adapter))
+	{
+		int ret = _FAIL;
+		if(rtw_IOL_applied(Adapter))
+		{
+			rtw_hal_power_on(Adapter);
+			
+			iol_mode_enable(Adapter, 1);
+			#ifdef DBG_IOL_READ_EFUSE_MAP
+			iol_read_efuse(Adapter, 0, _offset, _size_byte, logical_map);
+			#else
+			ret = iol_read_efuse(Adapter, 0, _offset, _size_byte, pbuf);
+			#endif
+			iol_mode_enable(Adapter, 0);	
+			
+			if(_SUCCESS == ret) 
+				goto exit;
+		}
+	}
+#endif
+	Hal_EfuseReadEFuse88E(Adapter, _offset, _size_byte, pbuf, bPseudoTest);
+
+exit:
+	
+#ifdef DBG_IOL_READ_EFUSE_MAP
+	if(_rtw_memcmp(logical_map, Adapter->eeprompriv.efuse_eeprom_data, 0x130) == _FALSE)
+	{
+		int i;
+		DBG_871X("%s compare first 0x130 byte fail\n", __FUNCTION__);
+		for(i=0;i<512;i++)
+		{
+			if(i%16==0)
+				DBG_871X("0x%03x: ", i);
+			DBG_871X("%02x ", logical_map[i]);
+			if(i%16==15)
+				DBG_871X("\n");
+		}
+		DBG_871X("\n");
+	}
+#endif
+
+	return;	
+}
+
+static VOID
+ReadEFuse_Pseudo(
+	PADAPTER	Adapter,
+	u8		efuseType,
+	u16		 _offset,
+	u16 		_size_byte,
+	u8      	*pbuf,
+	IN BOOLEAN	bPseudoTest
+	)
+{
+	Hal_EfuseReadEFuse88E(Adapter, _offset, _size_byte, pbuf, bPseudoTest);
+}
+
+static VOID
+rtl8188e_ReadEFuse(
+	PADAPTER	Adapter,
+	u8		efuseType,
+	u16		_offset,
+	u16 		_size_byte,
+	u8      	*pbuf,
+	IN	BOOLEAN	bPseudoTest
+	)
+{
+	if(bPseudoTest)
+	{
+		ReadEFuse_Pseudo(Adapter, efuseType, _offset, _size_byte, pbuf, bPseudoTest);
+	}
+	else
+	{
+		ReadEFuseByIC(Adapter, efuseType, _offset, _size_byte, pbuf, bPseudoTest);
+	}
+}
+
+//Do not support BT
+VOID
+Hal_EFUSEGetEfuseDefinition88E(
+	IN		PADAPTER	pAdapter,
+	IN		u1Byte		efuseType,
+	IN		u1Byte		type,
+	OUT		PVOID		pOut
+	)
+{
+	switch(type)
+	{
+		case TYPE_EFUSE_MAX_SECTION:
+			{
+				u8*	pMax_section;
+				pMax_section = (u8*)pOut;
+				*pMax_section = EFUSE_MAX_SECTION_88E;
+			}
+			break;
+		case TYPE_EFUSE_REAL_CONTENT_LEN:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (u16*)pOut;
+				*pu2Tmp = EFUSE_REAL_CONTENT_LEN_88E;
+			}
+			break;
+		case TYPE_EFUSE_CONTENT_LEN_BANK:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (u16*)pOut;
+				*pu2Tmp = EFUSE_REAL_CONTENT_LEN_88E;
+			}
+			break;
+		case TYPE_AVAILABLE_EFUSE_BYTES_BANK:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (u16*)pOut;
+				*pu2Tmp = (u16)(EFUSE_REAL_CONTENT_LEN_88E-EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		case TYPE_AVAILABLE_EFUSE_BYTES_TOTAL:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (u16*)pOut;
+				*pu2Tmp = (u16)(EFUSE_REAL_CONTENT_LEN_88E-EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		case TYPE_EFUSE_MAP_LEN:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (u16*)pOut;
+				*pu2Tmp = (u16)EFUSE_MAP_LEN_88E;
+			}
+			break;
+		case TYPE_EFUSE_PROTECT_BYTES_BANK:
+			{
+				u8* pu1Tmp;
+				pu1Tmp = (u8*)pOut;
+				*pu1Tmp = (u8)(EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		default:
+			{
+				u8* pu1Tmp;
+				pu1Tmp = (u8*)pOut;
+				*pu1Tmp = 0;
+			}
+			break;
+	}
+}
+VOID
+Hal_EFUSEGetEfuseDefinition_Pseudo88E(
+	IN		PADAPTER	pAdapter,
+	IN		u8			efuseType,
+	IN		u8			type,
+	OUT		PVOID		pOut
+	)
+{
+	switch(type)
+	{
+		case TYPE_EFUSE_MAX_SECTION:
+			{
+				u8*		pMax_section;
+				pMax_section = (pu1Byte)pOut;
+				*pMax_section = EFUSE_MAX_SECTION_88E;
+			}
+			break;
+		case TYPE_EFUSE_REAL_CONTENT_LEN:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (pu2Byte)pOut;
+				*pu2Tmp = EFUSE_REAL_CONTENT_LEN_88E;
+			}
+			break;
+		case TYPE_EFUSE_CONTENT_LEN_BANK:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (pu2Byte)pOut;
+				*pu2Tmp = EFUSE_REAL_CONTENT_LEN_88E;
+			}
+			break;
+		case TYPE_AVAILABLE_EFUSE_BYTES_BANK:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (pu2Byte)pOut;
+				*pu2Tmp = (u2Byte)(EFUSE_REAL_CONTENT_LEN_88E-EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		case TYPE_AVAILABLE_EFUSE_BYTES_TOTAL:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (pu2Byte)pOut;
+				*pu2Tmp = (u2Byte)(EFUSE_REAL_CONTENT_LEN_88E-EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		case TYPE_EFUSE_MAP_LEN:
+			{
+				u16* pu2Tmp;
+				pu2Tmp = (pu2Byte)pOut;
+				*pu2Tmp = (u2Byte)EFUSE_MAP_LEN_88E;
+			}
+			break;
+		case TYPE_EFUSE_PROTECT_BYTES_BANK:
+			{
+				u8* pu1Tmp;
+				pu1Tmp = (u8*)pOut;
+				*pu1Tmp = (u8)(EFUSE_OOB_PROTECT_BYTES_88E);
+			}
+			break;
+		default:
+			{
+				u8* pu1Tmp;
+				pu1Tmp = (u8*)pOut;
+				*pu1Tmp = 0;
+			}
+			break;
+	}
+}
+
+
+static VOID
+rtl8188e_EFUSE_GetEfuseDefinition(
+	IN		PADAPTER	pAdapter,
+	IN		u8		efuseType,
+	IN		u8		type,
+	OUT		void		*pOut,
+	IN		BOOLEAN		bPseudoTest
+	)
+{
+	if(bPseudoTest)
+	{
+		Hal_EFUSEGetEfuseDefinition_Pseudo88E(pAdapter, efuseType, type, pOut);
+	}
+	else
+	{
+		Hal_EFUSEGetEfuseDefinition88E(pAdapter, efuseType, type, pOut);
+	}
+}
+
+static u8
+Hal_EfuseWordEnableDataWrite(	IN	PADAPTER	pAdapter,
+							IN	u16		efuse_addr,
+							IN	u8		word_en,
+							IN	u8		*data,
+							IN	BOOLEAN		bPseudoTest)
+{
+	u16	tmpaddr = 0;
+	u16	start_addr = efuse_addr;
+	u8	badworden = 0x0F;
+	u8	tmpdata[8];
+
+	_rtw_memset((PVOID)tmpdata, 0xff, PGPKT_DATA_SIZE);
+	//RT_TRACE(COMP_EFUSE, DBG_LOUD, ("word_en = %x efuse_addr=%x\n", word_en, efuse_addr));
+
+	if(!(word_en&BIT0))
+	{
+		tmpaddr = start_addr;
+		efuse_OneByteWrite(pAdapter,start_addr++, data[0], bPseudoTest);
+		efuse_OneByteWrite(pAdapter,start_addr++, data[1], bPseudoTest);
+
+		efuse_OneByteRead(pAdapter,tmpaddr, &tmpdata[0], bPseudoTest);
+		efuse_OneByteRead(pAdapter,tmpaddr+1, &tmpdata[1], bPseudoTest);
+		if((data[0]!=tmpdata[0])||(data[1]!=tmpdata[1])){
+			badworden &= (~BIT0);
+		}
+	}
+	if(!(word_en&BIT1))
+	{
+		tmpaddr = start_addr;
+		efuse_OneByteWrite(pAdapter,start_addr++, data[2], bPseudoTest);
+		efuse_OneByteWrite(pAdapter,start_addr++, data[3], bPseudoTest);
+
+		efuse_OneByteRead(pAdapter,tmpaddr    , &tmpdata[2], bPseudoTest);
+		efuse_OneByteRead(pAdapter,tmpaddr+1, &tmpdata[3], bPseudoTest);
+		if((data[2]!=tmpdata[2])||(data[3]!=tmpdata[3])){
+			badworden &=( ~BIT1);
+		}
+	}
+	if(!(word_en&BIT2))
+	{
+		tmpaddr = start_addr;
+		efuse_OneByteWrite(pAdapter,start_addr++, data[4], bPseudoTest);
+		efuse_OneByteWrite(pAdapter,start_addr++, data[5], bPseudoTest);
+
+		efuse_OneByteRead(pAdapter,tmpaddr, &tmpdata[4], bPseudoTest);
+		efuse_OneByteRead(pAdapter,tmpaddr+1, &tmpdata[5], bPseudoTest);
+		if((data[4]!=tmpdata[4])||(data[5]!=tmpdata[5])){
+			badworden &=( ~BIT2);
+		}
+	}
+	if(!(word_en&BIT3))
+	{
+		tmpaddr = start_addr;
+		efuse_OneByteWrite(pAdapter,start_addr++, data[6], bPseudoTest);
+		efuse_OneByteWrite(pAdapter,start_addr++, data[7], bPseudoTest);
+
+		efuse_OneByteRead(pAdapter,tmpaddr, &tmpdata[6], bPseudoTest);
+		efuse_OneByteRead(pAdapter,tmpaddr+1, &tmpdata[7], bPseudoTest);
+		if((data[6]!=tmpdata[6])||(data[7]!=tmpdata[7])){
+			badworden &=( ~BIT3);
+		}
+	}
+	return badworden;
+}
+
+static u8
+Hal_EfuseWordEnableDataWrite_Pseudo(	IN	PADAPTER	pAdapter,
+							IN	u16		efuse_addr,
+							IN	u8		word_en,
+							IN	u8		*data,
+							IN	BOOLEAN		bPseudoTest)
+{
+	u8	ret=0;
+
+	ret = Hal_EfuseWordEnableDataWrite(pAdapter, efuse_addr, word_en, data, bPseudoTest);
+
+	return ret;
+}
+
+static u8
+rtl8188e_Efuse_WordEnableDataWrite(	IN	PADAPTER	pAdapter,
+							IN	u16		efuse_addr,
+							IN	u8		word_en,
+							IN	u8		*data,
+							IN	BOOLEAN		bPseudoTest)
+{
+	u8	ret=0;
+
+	if(bPseudoTest)
+	{
+		ret = Hal_EfuseWordEnableDataWrite_Pseudo(pAdapter, efuse_addr, word_en, data, bPseudoTest);
+	}
+	else
+	{
+		ret = Hal_EfuseWordEnableDataWrite(pAdapter, efuse_addr, word_en, data, bPseudoTest);
+	}
+
+	return ret;
+}
+
+
+static u16
+hal_EfuseGetCurrentSize_8188e(IN	PADAPTER	pAdapter,
+		IN		BOOLEAN			bPseudoTest)
+{
+	int	bContinual = _TRUE;
+
+	u16	efuse_addr = 0;
+	u8	hoffset=0,hworden=0;
+	u8	efuse_data,word_cnts=0;
+
+	if(bPseudoTest)
+	{
+		efuse_addr = (u16)(fakeEfuseUsedBytes);
+	}
+	else
+	{
+		rtw_hal_get_hwreg(pAdapter, HW_VAR_EFUSE_BYTES, (u8 *)&efuse_addr);
+	}
+	//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfuseGetCurrentSize_8723A(), start_efuse_addr = %d\n", efuse_addr));
+
+	while (	bContinual &&
+			efuse_OneByteRead(pAdapter, efuse_addr ,&efuse_data, bPseudoTest) &&
+			AVAILABLE_EFUSE_ADDR(efuse_addr))
+	{
+		if(efuse_data!=0xFF)
+		{
+			if((efuse_data&0x1F) == 0x0F)		//extended header
+			{
+				hoffset = efuse_data;
+				efuse_addr++;
+				efuse_OneByteRead(pAdapter, efuse_addr ,&efuse_data, bPseudoTest);
+				if((efuse_data & 0x0F) == 0x0F)
+				{
+					efuse_addr++;
+					continue;
+				}
+				else
+				{
+					hoffset = ((hoffset & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1);
+					hworden = efuse_data & 0x0F;
+				}
+			}
+			else
+			{
+				hoffset = (efuse_data>>4) & 0x0F;
+				hworden =  efuse_data & 0x0F;
+			}
+			word_cnts = Efuse_CalculateWordCnts(hworden);
+			//read next header
+			efuse_addr = efuse_addr + (word_cnts*2)+1;
+		}
+		else
+		{
+			bContinual = _FALSE ;
+		}
+	}
+
+	if(bPseudoTest)
+	{
+		fakeEfuseUsedBytes = efuse_addr;
+		//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfuseGetCurrentSize_8723A(), return %d\n", fakeEfuseUsedBytes));
+	}
+	else
+	{
+		rtw_hal_set_hwreg(pAdapter, HW_VAR_EFUSE_BYTES, (u8 *)&efuse_addr);
+		//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfuseGetCurrentSize_8723A(), return %d\n", efuse_addr));
+	}
+
+	return efuse_addr;
+}
+
+static u16
+Hal_EfuseGetCurrentSize_Pseudo(IN	PADAPTER	pAdapter,
+		IN		BOOLEAN			bPseudoTest)
+{
+	u16	ret=0;
+
+	ret = hal_EfuseGetCurrentSize_8188e(pAdapter, bPseudoTest);
+
+	return ret;
+}
+
+
+static u16
+rtl8188e_EfuseGetCurrentSize(
+	IN	PADAPTER	pAdapter,
+	IN	u8			efuseType,
+	IN	BOOLEAN		bPseudoTest)
+{
+	u16	ret=0;
+
+	if(bPseudoTest)
+	{
+		ret = Hal_EfuseGetCurrentSize_Pseudo(pAdapter, bPseudoTest);
+	}
+	else
+	{
+		ret = hal_EfuseGetCurrentSize_8188e(pAdapter, bPseudoTest);
+		
+	}
+
+	return ret;
+}
+
+
+static int
+hal_EfusePgPacketRead_8188e(
+	IN	PADAPTER	pAdapter,
+	IN	u8			offset,
+	IN	u8			*data,
+	IN	BOOLEAN		bPseudoTest)
+{
+	u8	ReadState = PG_STATE_HEADER;
+
+	int	bContinual = _TRUE;
+	int	bDataEmpty = _TRUE ;
+
+	u8	efuse_data,word_cnts = 0;
+	u16	efuse_addr = 0;
+	u8	hoffset = 0,hworden = 0;
+	u8	tmpidx = 0;
+	u8	tmpdata[8];
+	u8	max_section = 0;
+	u8	tmp_header = 0;
+
+	EFUSE_GetEfuseDefinition(pAdapter, EFUSE_WIFI, TYPE_EFUSE_MAX_SECTION, (PVOID)&max_section, bPseudoTest);
+
+	if(data==NULL)
+		return _FALSE;
+	if(offset>max_section)
+		return _FALSE;
+
+	_rtw_memset((PVOID)data, 0xff, sizeof(u8)*PGPKT_DATA_SIZE);
+	_rtw_memset((PVOID)tmpdata, 0xff, sizeof(u8)*PGPKT_DATA_SIZE);
+
+
+	//
+	// <Roger_TODO> Efuse has been pre-programmed dummy 5Bytes at the end of Efuse by CP.
+	// Skip dummy parts to prevent unexpected data read from Efuse.
+	// By pass right now. 2009.02.19.
+	//
+	while(bContinual && AVAILABLE_EFUSE_ADDR(efuse_addr) )
+	{
+		//-------  Header Read -------------
+		if(ReadState & PG_STATE_HEADER)
+		{
+			if(efuse_OneByteRead(pAdapter, efuse_addr ,&efuse_data, bPseudoTest)&&(efuse_data!=0xFF))
+			{
+				if(EXT_HEADER(efuse_data))
+				{
+					tmp_header = efuse_data;
+					efuse_addr++;
+					efuse_OneByteRead(pAdapter, efuse_addr ,&efuse_data, bPseudoTest);
+					if(!ALL_WORDS_DISABLED(efuse_data))
+					{
+						hoffset = ((tmp_header & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1);
+						hworden = efuse_data & 0x0F;
+					}
+					else
+					{
+						DBG_8192C("Error, All words disabled\n");
+						efuse_addr++;
+						continue;
+					}
+				}
+				else
+				{
+					hoffset = (efuse_data>>4) & 0x0F;
+					hworden =  efuse_data & 0x0F;
+				}
+				word_cnts = Efuse_CalculateWordCnts(hworden);
+				bDataEmpty = _TRUE ;
+
+				if(hoffset==offset)
+				{
+					for(tmpidx = 0;tmpidx< word_cnts*2 ;tmpidx++)
+					{
+						if(efuse_OneByteRead(pAdapter, efuse_addr+1+tmpidx ,&efuse_data, bPseudoTest) )
+						{
+							tmpdata[tmpidx] = efuse_data;
+							if(efuse_data!=0xff)
+							{
+								bDataEmpty = _FALSE;
+							}
+						}
+					}
+					if(bDataEmpty==_FALSE){
+						ReadState = PG_STATE_DATA;
+					}else{//read next header
+						efuse_addr = efuse_addr + (word_cnts*2)+1;
+						ReadState = PG_STATE_HEADER;
+					}
+				}
+				else{//read next header
+					efuse_addr = efuse_addr + (word_cnts*2)+1;
+					ReadState = PG_STATE_HEADER;
+				}
+
+			}
+			else{
+				bContinual = _FALSE ;
+			}
+		}
+		//-------  Data section Read -------------
+		else if(ReadState & PG_STATE_DATA)
+		{
+			efuse_WordEnableDataRead(hworden,tmpdata,data);
+			efuse_addr = efuse_addr + (word_cnts*2)+1;
+			ReadState = PG_STATE_HEADER;
+		}
+
+	}
+
+	if(	(data[0]==0xff) &&(data[1]==0xff) && (data[2]==0xff)  && (data[3]==0xff) &&
+		(data[4]==0xff) &&(data[5]==0xff) && (data[6]==0xff)  && (data[7]==0xff))
+		return _FALSE;
+	else
+		return _TRUE;
+
+}
+
+static int
+Hal_EfusePgPacketRead(	IN	PADAPTER	pAdapter,
+					IN	u8			offset,
+					IN	u8			*data,
+					IN	BOOLEAN			bPseudoTest)
+{
+	int	ret=0;
+
+	ret = hal_EfusePgPacketRead_8188e(pAdapter, offset, data, bPseudoTest);
+	
+
+	return ret;
+}
+
+static int
+Hal_EfusePgPacketRead_Pseudo(	IN	PADAPTER	pAdapter,
+					IN	u8			offset,
+					IN	u8			*data,
+					IN	BOOLEAN		bPseudoTest)
+{
+	int	ret=0;
+
+	ret = hal_EfusePgPacketRead_8188e(pAdapter, offset, data, bPseudoTest);
+
+	return ret;
+}
+
+static int
+rtl8188e_Efuse_PgPacketRead(	IN	PADAPTER	pAdapter,
+					IN	u8			offset,
+					IN	u8			*data,
+					IN	BOOLEAN		bPseudoTest)
+{
+	int	ret=0;
+
+	if(bPseudoTest)
+	{
+		ret = Hal_EfusePgPacketRead_Pseudo(pAdapter, offset, data, bPseudoTest);
+	}
+	else
+	{
+		ret = Hal_EfusePgPacketRead(pAdapter, offset, data, bPseudoTest);
+	}
+
+	return ret;
+}
+
+static BOOLEAN
+hal_EfuseFixHeaderProcess(
+	IN		PADAPTER			pAdapter,
+	IN		u8					efuseType,
+	IN		PPGPKT_STRUCT		pFixPkt,
+	IN		u16					*pAddr,
+	IN		BOOLEAN				bPseudoTest
+)
+{
+	u8	originaldata[8], badworden=0;
+	u16	efuse_addr=*pAddr;
+	u32	PgWriteSuccess=0;
+
+	_rtw_memset((PVOID)originaldata, 0xff, 8);
+
+	if(Efuse_PgPacketRead(pAdapter, pFixPkt->offset, originaldata, bPseudoTest))
+	{	//check if data exist
+		badworden = Efuse_WordEnableDataWrite(pAdapter, efuse_addr+1, pFixPkt->word_en, originaldata, bPseudoTest);
+
+		if(badworden != 0xf)	// write fail
+		{			
+			PgWriteSuccess = Efuse_PgPacketWrite(pAdapter, pFixPkt->offset, badworden, originaldata, bPseudoTest);
+
+			if(!PgWriteSuccess)
+				return _FALSE;
+			else
+				efuse_addr = Efuse_GetCurrentSize(pAdapter, efuseType, bPseudoTest);
+		}
+		else
+		{
+			efuse_addr = efuse_addr + (pFixPkt->word_cnts*2) +1;
+		}
+	}
+	else
+	{
+		efuse_addr = efuse_addr + (pFixPkt->word_cnts*2) +1;
+	}
+	*pAddr = efuse_addr;
+	return _TRUE;
+}
+
+static BOOLEAN
+hal_EfusePgPacketWrite2ByteHeader(
+	IN			PADAPTER		pAdapter,
+	IN			u8				efuseType,
+	IN			u16				*pAddr,
+	IN			PPGPKT_STRUCT	pTargetPkt,
+	IN			BOOLEAN			bPseudoTest)
+{
+	BOOLEAN		bRet=_FALSE, bContinual=_TRUE;
+	u16	efuse_addr=*pAddr, efuse_max_available_len=0;
+	u8	pg_header=0, tmp_header=0, pg_header_temp=0;
+	u8	repeatcnt=0;
+
+	//RTPRINT(FEEPROM, EFUSE_PG, ("Wirte 2byte header\n"));
+	EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_BANK, (PVOID)&efuse_max_available_len, bPseudoTest);
+
+	while(efuse_addr < efuse_max_available_len)
+	{
+		pg_header = ((pTargetPkt->offset & 0x07) << 5) | 0x0F;
+		//RTPRINT(FEEPROM, EFUSE_PG, ("pg_header = 0x%x\n", pg_header));
+		efuse_OneByteWrite(pAdapter, efuse_addr, pg_header, bPseudoTest);
+		efuse_OneByteRead(pAdapter, efuse_addr, &tmp_header, bPseudoTest);
+
+		while(tmp_header == 0xFF)
+		{
+			if(repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
+			{
+				//RTPRINT(FEEPROM, EFUSE_PG, ("Repeat over limit for pg_header!!\n"));
+				return _FALSE;
+			}
+
+			efuse_OneByteWrite(pAdapter, efuse_addr, pg_header, bPseudoTest);
+			efuse_OneByteRead(pAdapter, efuse_addr, &tmp_header, bPseudoTest);
+		}
+
+		//to write ext_header
+		if(tmp_header == pg_header)
+		{
+			efuse_addr++;
+			pg_header_temp = pg_header;
+			pg_header = ((pTargetPkt->offset & 0x78) << 1) | pTargetPkt->word_en;
+
+			efuse_OneByteWrite(pAdapter, efuse_addr, pg_header, bPseudoTest);
+			efuse_OneByteRead(pAdapter, efuse_addr, &tmp_header, bPseudoTest);
+
+			while(tmp_header == 0xFF)
+			{
+				if(repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
+				{
+					//RTPRINT(FEEPROM, EFUSE_PG, ("Repeat over limit for ext_header!!\n"));
+					return _FALSE;
+				}
+
+				efuse_OneByteWrite(pAdapter, efuse_addr, pg_header, bPseudoTest);
+				efuse_OneByteRead(pAdapter, efuse_addr, &tmp_header, bPseudoTest);
+			}
+
+			if((tmp_header & 0x0F) == 0x0F)	//word_en PG fail
+			{
+				if(repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
+				{
+					//RTPRINT(FEEPROM, EFUSE_PG, ("Repeat over limit for word_en!!\n"));
+					return _FALSE;
+				}
+				else
+				{
+					efuse_addr++;
+					continue;
+				}
+			}
+			else if(pg_header != tmp_header)	//offset PG fail
+			{
+				PGPKT_STRUCT	fixPkt;
+				//RTPRINT(FEEPROM, EFUSE_PG, ("Error condition for offset PG fail, need to cover the existed data\n"));
+				fixPkt.offset = ((pg_header_temp & 0xE0) >> 5) | ((tmp_header & 0xF0) >> 1);
+				fixPkt.word_en = tmp_header & 0x0F;
+				fixPkt.word_cnts = Efuse_CalculateWordCnts(fixPkt.word_en);
+				if(!hal_EfuseFixHeaderProcess(pAdapter, efuseType, &fixPkt, &efuse_addr, bPseudoTest))
+					return _FALSE;
+			}
+			else
+			{
+				bRet = _TRUE;
+				break;
+			}
+		}
+		else if ((tmp_header & 0x1F) == 0x0F)		//wrong extended header
+		{
+			efuse_addr+=2;
+			continue;
+		}
+	}
+
+	*pAddr = efuse_addr;
+	return bRet;
+}
+
+static BOOLEAN
+hal_EfusePgPacketWrite1ByteHeader(
+	IN			PADAPTER		pAdapter,
+	IN			u8				efuseType,
+	IN			u16				*pAddr,
+	IN			PPGPKT_STRUCT	pTargetPkt,
+	IN			BOOLEAN			bPseudoTest)
+{
+	BOOLEAN		bRet=_FALSE;
+	u8	pg_header=0, tmp_header=0;
+	u16	efuse_addr=*pAddr;
+	u8	repeatcnt=0;
+
+	//RTPRINT(FEEPROM, EFUSE_PG, ("Wirte 1byte header\n"));
+	pg_header = ((pTargetPkt->offset << 4) & 0xf0) |pTargetPkt->word_en;
+
+	efuse_OneByteWrite(pAdapter, efuse_addr, pg_header, bPseudoTest);
+	efuse_OneByteRead(pAdapter, efuse_addr, &tmp_header, bPseudoTest);
+
+	while(tmp_header == 0xFF)
+	{
+		if(repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
+		{
+			return _FALSE;
+		}
+		efuse_OneByteWrite(pAdapter,efuse_addr, pg_header, bPseudoTest);
+		efuse_OneByteRead(pAdapter,efuse_addr, &tmp_header, bPseudoTest);
+	}
+
+	if(pg_header == tmp_header)
+	{
+		bRet = _TRUE;
+	}
+	else
+	{
+		PGPKT_STRUCT	fixPkt;
+		//RTPRINT(FEEPROM, EFUSE_PG, ("Error condition for fixed PG packet, need to cover the existed data\n"));
+		fixPkt.offset = (tmp_header>>4) & 0x0F;
+		fixPkt.word_en = tmp_header & 0x0F;
+		fixPkt.word_cnts = Efuse_CalculateWordCnts(fixPkt.word_en);
+		if(!hal_EfuseFixHeaderProcess(pAdapter, efuseType, &fixPkt, &efuse_addr, bPseudoTest))
+			return _FALSE;
+	}
+
+	*pAddr = efuse_addr;
+	return bRet;
+}
+
+static BOOLEAN
+hal_EfusePgPacketWriteData(
+	IN			PADAPTER		pAdapter,
+	IN			u8				efuseType,
+	IN			u16				*pAddr,
+	IN			PPGPKT_STRUCT	pTargetPkt,
+	IN			BOOLEAN			bPseudoTest)
+{
+	BOOLEAN	bRet=_FALSE;
+	u16	efuse_addr=*pAddr;
+	u8	badworden=0;
+	u32	PgWriteSuccess=0;
+
+	badworden = 0x0f;
+	badworden = Efuse_WordEnableDataWrite(pAdapter, efuse_addr+1, pTargetPkt->word_en, pTargetPkt->data, bPseudoTest);
+	if(badworden == 0x0F)
+	{
+		// write ok
+		//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfusePgPacketWriteData ok!!\n"));
+		return _TRUE;
+	}
+	else
+	{
+		//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfusePgPacketWriteData Fail!!\n"));
+		//reorganize other pg packet
+		
+		PgWriteSuccess = Efuse_PgPacketWrite(pAdapter, pTargetPkt->offset, badworden, pTargetPkt->data, bPseudoTest);
+		
+		if(!PgWriteSuccess)
+			return _FALSE;
+		else
+			return _TRUE;
+	}
+
+	return bRet;
+}
+
+static BOOLEAN
+hal_EfusePgPacketWriteHeader(
+	IN			PADAPTER		pAdapter,
+	IN			u8				efuseType,
+	IN			u16				*pAddr,
+	IN			PPGPKT_STRUCT	pTargetPkt,
+	IN			BOOLEAN			bPseudoTest)
+{
+	BOOLEAN		bRet=_FALSE;
+
+	if(pTargetPkt->offset >= EFUSE_MAX_SECTION_BASE)
+	{
+		bRet = hal_EfusePgPacketWrite2ByteHeader(pAdapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
+	}
+	else
+	{
+		bRet = hal_EfusePgPacketWrite1ByteHeader(pAdapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
+	}
+
+	return bRet;
+}
+
+static BOOLEAN
+wordEnMatched(
+	IN	PPGPKT_STRUCT	pTargetPkt,
+	IN	PPGPKT_STRUCT	pCurPkt,
+	IN	u8				*pWden
+)
+{
+	u8	match_word_en = 0x0F;	// default all words are disabled
+	u8	i;
+
+	// check if the same words are enabled both target and current PG packet
+	if( ((pTargetPkt->word_en & BIT0) == 0) &&
+		((pCurPkt->word_en & BIT0) == 0) )
+	{
+		match_word_en &= ~BIT0;				// enable word 0
+	}
+	if( ((pTargetPkt->word_en & BIT1) == 0) &&
+		((pCurPkt->word_en & BIT1) == 0) )
+	{
+		match_word_en &= ~BIT1;				// enable word 1
+	}
+	if( ((pTargetPkt->word_en & BIT2) == 0) &&
+		((pCurPkt->word_en & BIT2) == 0) )
+	{
+		match_word_en &= ~BIT2;				// enable word 2
+	}
+	if( ((pTargetPkt->word_en & BIT3) == 0) &&
+		((pCurPkt->word_en & BIT3) == 0) )
+	{
+		match_word_en &= ~BIT3;				// enable word 3
+	}
+
+	*pWden = match_word_en;
+
+	if(match_word_en != 0xf)
+		return _TRUE;
+	else
+		return _FALSE;
+}
+
+static BOOLEAN
+hal_EfuseCheckIfDatafollowed(
+	IN		PADAPTER		pAdapter,
+	IN		u8				word_cnts,
+	IN		u16				startAddr,
+	IN		BOOLEAN			bPseudoTest
+	)
+{
+	BOOLEAN		bRet=_FALSE;
+	u8	i, efuse_data;
+
+	for(i=0; i<(word_cnts*2) ; i++)
+	{
+		if(efuse_OneByteRead(pAdapter, (startAddr+i) ,&efuse_data, bPseudoTest)&&(efuse_data != 0xFF))
+			bRet = _TRUE;
+	}
+
+	return bRet;
+}
+
+static BOOLEAN
+hal_EfusePartialWriteCheck(
+					IN	PADAPTER		pAdapter,
+					IN	u8				efuseType,
+					IN	u16				*pAddr,
+					IN	PPGPKT_STRUCT	pTargetPkt,
+					IN	BOOLEAN			bPseudoTest
+					)
+{
+	BOOLEAN		bRet=_FALSE;
+	u8	i, efuse_data=0, cur_header=0;
+	u8	new_wden=0, matched_wden=0, badworden=0;
+	u16	startAddr=0, efuse_max_available_len=0, efuse_max=0;
+	PGPKT_STRUCT	curPkt;
+
+	EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_BANK, (PVOID)&efuse_max_available_len, bPseudoTest);
+	EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_EFUSE_REAL_CONTENT_LEN, (PVOID)&efuse_max, bPseudoTest);
+
+	if(efuseType == EFUSE_WIFI)
+	{
+		if(bPseudoTest)
+		{
+			startAddr = (u16)(fakeEfuseUsedBytes%EFUSE_REAL_CONTENT_LEN);
+		}
+		else
+		{
+			rtw_hal_get_hwreg(pAdapter, HW_VAR_EFUSE_BYTES, (u8 *)&startAddr);
+			startAddr%=EFUSE_REAL_CONTENT_LEN;
+		}
+	}
+	else
+	{
+		if(bPseudoTest)
+		{
+			startAddr = (u16)(fakeBTEfuseUsedBytes%EFUSE_REAL_CONTENT_LEN);
+		}
+		else
+		{
+			startAddr = (u16)(BTEfuseUsedBytes%EFUSE_REAL_CONTENT_LEN);
+		}
+	}
+	//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfusePartialWriteCheck(), startAddr=%d\n", startAddr));
+
+	while(1)
+	{
+		if(startAddr >= efuse_max_available_len)
+		{
+			bRet = _FALSE;
+			break;
+		}
+
+		if(efuse_OneByteRead(pAdapter, startAddr, &efuse_data, bPseudoTest) && (efuse_data!=0xFF))
+		{
+			if(EXT_HEADER(efuse_data))
+			{
+				cur_header = efuse_data;
+				startAddr++;
+				efuse_OneByteRead(pAdapter, startAddr, &efuse_data, bPseudoTest);
+				if(ALL_WORDS_DISABLED(efuse_data))
+				{
+					//RTPRINT(FEEPROM, EFUSE_PG, ("Error condition, all words disabled"));
+					bRet = _FALSE;
+					break;
+				}
+				else
+				{
+					curPkt.offset = ((cur_header & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1);
+					curPkt.word_en = efuse_data & 0x0F;
+				}
+			}
+			else
+			{
+				cur_header  =  efuse_data;
+				curPkt.offset = (cur_header>>4) & 0x0F;
+				curPkt.word_en = cur_header & 0x0F;
+			}
+
+			curPkt.word_cnts = Efuse_CalculateWordCnts(curPkt.word_en);
+			// if same header is found but no data followed
+			// write some part of data followed by the header.
+			if( (curPkt.offset == pTargetPkt->offset) &&
+				(!hal_EfuseCheckIfDatafollowed(pAdapter, curPkt.word_cnts, startAddr+1, bPseudoTest)) &&
+				wordEnMatched(pTargetPkt, &curPkt, &matched_wden) )
+			{
+				//RTPRINT(FEEPROM, EFUSE_PG, ("Need to partial write data by the previous wrote header\n"));
+				// Here to write partial data
+				badworden = Efuse_WordEnableDataWrite(pAdapter, startAddr+1, matched_wden, pTargetPkt->data, bPseudoTest);
+				if(badworden != 0x0F)
+				{
+					u32	PgWriteSuccess=0;
+					// if write fail on some words, write these bad words again
+					
+					PgWriteSuccess = Efuse_PgPacketWrite(pAdapter, pTargetPkt->offset, badworden, pTargetPkt->data, bPseudoTest);
+					
+					if(!PgWriteSuccess)
+					{
+						bRet = _FALSE;	// write fail, return
+						break;
+					}
+				}
+				// partial write ok, update the target packet for later use
+				for(i=0; i<4; i++)
+				{
+					if((matched_wden & (0x1<<i)) == 0)	// this word has been written
+					{
+						pTargetPkt->word_en |= (0x1<<i);	// disable the word
+					}
+				}
+				pTargetPkt->word_cnts = Efuse_CalculateWordCnts(pTargetPkt->word_en);
+			}
+			// read from next header
+			startAddr = startAddr + (curPkt.word_cnts*2) +1;
+		}
+		else
+		{
+			// not used header, 0xff
+			*pAddr = startAddr;
+			//RTPRINT(FEEPROM, EFUSE_PG, ("Started from unused header offset=%d\n", startAddr));
+			bRet = _TRUE;
+			break;
+		}
+	}
+	return bRet;
+}
+
+static BOOLEAN
+hal_EfusePgCheckAvailableAddr(
+	IN	PADAPTER	pAdapter,
+	IN	u8			efuseType,
+	IN	BOOLEAN		bPseudoTest
+	)
+{
+	u16	efuse_max_available_len=0;
+
+	//Change to check TYPE_EFUSE_MAP_LEN ,beacuse 8188E raw 256,logic map over 256.
+	EFUSE_GetEfuseDefinition(pAdapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (PVOID)&efuse_max_available_len, _FALSE);
+	
+	//EFUSE_GetEfuseDefinition(pAdapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&efuse_max_available_len, bPseudoTest);
+	//RTPRINT(FEEPROM, EFUSE_PG, ("efuse_max_available_len = %d\n", efuse_max_available_len));
+
+	if(Efuse_GetCurrentSize(pAdapter, efuseType, bPseudoTest) >= efuse_max_available_len)
+	{
+		//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfusePgCheckAvailableAddr error!!\n"));
+		return _FALSE;
+	}
+	return _TRUE;
+}
+
+static VOID
+hal_EfuseConstructPGPkt(
+					IN	u8 				offset,
+					IN	u8				word_en,
+					IN	u8				*pData,
+					IN	PPGPKT_STRUCT	pTargetPkt
+
+)
+{
+	_rtw_memset((PVOID)pTargetPkt->data, 0xFF, sizeof(u8)*8);
+	pTargetPkt->offset = offset;
+	pTargetPkt->word_en= word_en;
+	efuse_WordEnableDataRead(word_en, pData, pTargetPkt->data);
+	pTargetPkt->word_cnts = Efuse_CalculateWordCnts(pTargetPkt->word_en);
+
+	//RTPRINT(FEEPROM, EFUSE_PG, ("hal_EfuseConstructPGPkt(), targetPkt, offset=%d, word_en=0x%x, word_cnts=%d\n", pTargetPkt->offset, pTargetPkt->word_en, pTargetPkt->word_cnts));
+}
+
+static BOOLEAN
+hal_EfusePgPacketWrite_BT(
+					IN	PADAPTER	pAdapter,
+					IN	u8 			offset,
+					IN	u8			word_en,
+					IN	u8			*pData,
+					IN	BOOLEAN		bPseudoTest
+					)
+{
+	PGPKT_STRUCT 	targetPkt;
+	u16	startAddr=0;
+	u8	efuseType=EFUSE_BT;
+
+	if(!hal_EfusePgCheckAvailableAddr(pAdapter, efuseType, bPseudoTest))
+		return _FALSE;
+
+	hal_EfuseConstructPGPkt(offset, word_en, pData, &targetPkt);
+
+	if(!hal_EfusePartialWriteCheck(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	if(!hal_EfusePgPacketWriteHeader(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	if(!hal_EfusePgPacketWriteData(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	return _TRUE;
+}
+
+static BOOLEAN
+hal_EfusePgPacketWrite_8188e(
+					IN	PADAPTER		pAdapter,
+					IN	u8 			offset,
+					IN	u8			word_en,
+					IN	u8			*pData,
+					IN	BOOLEAN		bPseudoTest
+					)
+{
+	PGPKT_STRUCT 	targetPkt;
+	u16			startAddr=0;
+	u8			efuseType=EFUSE_WIFI;
+
+	if(!hal_EfusePgCheckAvailableAddr(pAdapter, efuseType, bPseudoTest))
+		return _FALSE;
+
+	hal_EfuseConstructPGPkt(offset, word_en, pData, &targetPkt);
+
+	if(!hal_EfusePartialWriteCheck(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	if(!hal_EfusePgPacketWriteHeader(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	if(!hal_EfusePgPacketWriteData(pAdapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
+		return _FALSE;
+
+	return _TRUE;
+}
+
+
+static int
+Hal_EfusePgPacketWrite_Pseudo(IN	PADAPTER	pAdapter,
+					IN	u8 			offset,
+					IN	u8			word_en,
+					IN	u8			*data,
+					IN	BOOLEAN		bPseudoTest)
+{
+	int ret;
+
+	ret = hal_EfusePgPacketWrite_8188e(pAdapter, offset, word_en, data, bPseudoTest);
+
+	return ret;
+}
+
+static int
+Hal_EfusePgPacketWrite(IN	PADAPTER	pAdapter,
+					IN	u8 			offset,
+					IN	u8			word_en,
+					IN	u8			*data,
+					IN	BOOLEAN		bPseudoTest)
+{
+	int	ret=0;
+	ret = hal_EfusePgPacketWrite_8188e(pAdapter, offset, word_en, data, bPseudoTest);
+	
+
+	return ret;
+}
+
+static int
+rtl8188e_Efuse_PgPacketWrite(IN	PADAPTER	pAdapter,
+					IN	u8 			offset,
+					IN	u8			word_en,
+					IN	u8			*data,
+					IN	BOOLEAN		bPseudoTest)
+{
+	int	ret;
+
+	if(bPseudoTest)
+	{
+		ret = Hal_EfusePgPacketWrite_Pseudo(pAdapter, offset, word_en, data, bPseudoTest);
+	}
+	else
+	{
+		ret = Hal_EfusePgPacketWrite(pAdapter, offset, word_en, data, bPseudoTest);
+	}
+	return ret;
+}
+
+static HAL_VERSION
+ReadChipVersion8188E(
+	IN	PADAPTER	padapter
+	)
+{
+	u32				value32;
+	HAL_VERSION				ChipVersion;
+	HAL_DATA_TYPE	*pHalData;
+
+
+	pHalData = GET_HAL_DATA(padapter);
+
+	value32 = rtw_read32(padapter, REG_SYS_CFG);
+	ChipVersion.ICType = CHIP_8188E ;
+	ChipVersion.ChipType = ((value32 & RTL_ID) ? TEST_CHIP : NORMAL_CHIP);
+
+	ChipVersion.RFType = RF_TYPE_1T1R;
+	ChipVersion.VendorType = ((value32 & VENDOR_ID) ? CHIP_VENDOR_UMC : CHIP_VENDOR_TSMC);
+	ChipVersion.CUTVersion = (value32 & CHIP_VER_RTL_MASK)>>CHIP_VER_RTL_SHIFT; // IC version (CUT)
+
+	// For regulator mode. by tynli. 2011.01.14
+	pHalData->RegulatorMode = ((value32 & TRP_BT_EN) ? RT_LDO_REGULATOR : RT_SWITCHING_REGULATOR);
+
+	ChipVersion.ROMVer = 0;	// ROM code version.	
+	pHalData->MultiFunc = RT_MULTI_FUNC_NONE;
+	
+
+//#if DBG
+#if 1	
+	dump_chip_info(ChipVersion);
+#endif
+
+	pHalData->VersionID = ChipVersion;
+
+	if (IS_1T2R(ChipVersion)){
+		pHalData->rf_type = RF_1T2R;
+		pHalData->NumTotalRFPath = 2;
+	}
+	else if (IS_2T2R(ChipVersion)){
+		pHalData->rf_type = RF_2T2R;
+		pHalData->NumTotalRFPath = 2;
+	}
+	else{
+		pHalData->rf_type = RF_1T1R;
+		pHalData->NumTotalRFPath = 1;
+	}
+		
+	MSG_8192C("RF_Type is %x!!\n", pHalData->rf_type);
+
+	return ChipVersion;
+}
+
+static void rtl8188e_read_chip_version(PADAPTER padapter)
+{
+	ReadChipVersion8188E(padapter);	
+}
+void rtl8188e_GetHalODMVar(	
+	PADAPTER				Adapter,
+	HAL_ODM_VARIABLE		eVariable,
+	PVOID					pValue1,
+	BOOLEAN					bSet)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	PDM_ODM_T podmpriv = &pHalData->odmpriv;
+	switch(eVariable){
+		case HAL_ODM_STA_INFO:
+			break;
+		default:
+			break;
+	}
+}
+void rtl8188e_SetHalODMVar(
+	PADAPTER				Adapter,
+	HAL_ODM_VARIABLE		eVariable,
+	PVOID					pValue1,
+	BOOLEAN					bSet)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	PDM_ODM_T podmpriv = &pHalData->odmpriv;
+	//_irqL irqL;
+	switch(eVariable){
+		case HAL_ODM_STA_INFO:
+			{	
+				struct sta_info *psta = (struct sta_info *)pValue1;				
+				if(bSet){
+					DBG_8192C("### Set STA_(%d) info\n",psta->mac_id);
+					ODM_CmnInfoPtrArrayHook(podmpriv, ODM_CMNINFO_STA_STATUS,psta->mac_id,psta);
+					#if(RATE_ADAPTIVE_SUPPORT==1)
+					ODM_RAInfo_Init(podmpriv,psta->mac_id);
+					#endif
+				}
+				else{
+					DBG_8192C("### Clean STA_(%d) info\n",psta->mac_id);
+					//_enter_critical_bh(&pHalData->odm_stainfo_lock, &irqL);
+					ODM_CmnInfoPtrArrayHook(podmpriv, ODM_CMNINFO_STA_STATUS,psta->mac_id,NULL);
+					
+					//_exit_critical_bh(&pHalData->odm_stainfo_lock, &irqL);
+			            }
+			}
+			break;
+		case HAL_ODM_P2P_STATE:		
+				ODM_CmnInfoUpdate(podmpriv,ODM_CMNINFO_WIFI_DIRECT,bSet);
+			break;
+		case HAL_ODM_WIFI_DISPLAY_STATE:
+				ODM_CmnInfoUpdate(podmpriv,ODM_CMNINFO_WIFI_DISPLAY,bSet);
+			break;
+		default:
+			break;
+	}
+}	
+
+void rtl8188e_start_thread(_adapter *padapter)
+{
+#ifdef CONFIG_SDIO_HCI
+#ifndef CONFIG_SDIO_TX_TASKLET
+	struct xmit_priv *xmitpriv = &padapter->xmitpriv;
+
+	xmitpriv->SdioXmitThread = kthread_run(rtl8188es_xmit_thread, padapter, "RTWHALXT");
+	if (IS_ERR(xmitpriv->SdioXmitThread))
+	{
+		RT_TRACE(_module_hal_xmit_c_, _drv_err_, ("%s: start rtl8188es_xmit_thread FAIL!!\n", __FUNCTION__));
+	}
+#endif
+#endif
+}
+
+void rtl8188e_stop_thread(_adapter *padapter)
+{
+#ifdef CONFIG_SDIO_HCI
+#ifndef CONFIG_SDIO_TX_TASKLET
+	struct xmit_priv *xmitpriv = &padapter->xmitpriv;
+
+	// stop xmit_buf_thread
+	if (xmitpriv->SdioXmitThread ) {
+		_rtw_up_sema(&xmitpriv->SdioXmitSema);
+		_rtw_down_sema(&xmitpriv->SdioXmitTerminateSema);
+		xmitpriv->SdioXmitThread = 0;
+	}
+#endif
+#endif
+}
+void hal_notch_filter_8188e(_adapter *adapter, bool enable)
+{
+	if (enable) {
+		DBG_871X("Enable notch filter\n");
+		rtw_write8(adapter, rOFDM0_RxDSP+1, rtw_read8(adapter, rOFDM0_RxDSP+1) | BIT1);
+	} else {
+		DBG_871X("Disable notch filter\n");
+		rtw_write8(adapter, rOFDM0_RxDSP+1, rtw_read8(adapter, rOFDM0_RxDSP+1) & ~BIT1);
+	}
+}
+
+void UpdateHalRAMask8188E(PADAPTER padapter, u32 mac_id, u8 rssi_level)
+{
+	u32	mask,rate_bitmap;
+	u8	shortGIrate = _FALSE;
+	struct sta_info	*psta;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	//struct dm_priv	*pdmpriv = &pHalData->dmpriv;
+	struct mlme_ext_priv	*pmlmeext = &padapter->mlmeextpriv;
+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+
+	if (mac_id >= NUM_STA) //CAM_SIZE
+	{
+		return;
+	}
+
+	psta = pmlmeinfo->FW_sta_info[mac_id].psta;
+	if(psta == NULL)
+	{
+		return;
+	}
+
+	shortGIrate = query_ra_short_GI(psta);
+
+	mask = psta->ra_mask;
+
+	rate_bitmap = 0xffffffff;					
+	rate_bitmap = ODM_Get_Rate_Bitmap(&pHalData->odmpriv,mac_id,mask,rssi_level);
+	DBG_871X("%s => mac_id:%d, networkType:0x%02x, mask:0x%08x\n\t ==> rssi_level:%d, rate_bitmap:0x%08x\n",
+			__FUNCTION__,mac_id,psta->wireless_mode,mask,rssi_level,rate_bitmap);
+
+	mask &= rate_bitmap;
+	
+	if(pHalData->fw_ractrl == _TRUE)
+	{
+		u8 arg = 0;
+
+		//arg = (cam_idx-4)&0x1f;//MACID
+		arg = mac_id&0x1f;//MACID
+		
+		arg |= BIT(7);
+		
+		if (shortGIrate==_TRUE)
+			arg |= BIT(5);
+		mask |= ((psta->raid<<28)&0xf0000000);
+		DBG_871X("update raid entry, mask=0x%x, arg=0x%x\n", mask, arg);
+
+#ifdef CONFIG_INTEL_PROXIM
+		if(padapter->proximity.proxim_on ==_TRUE){
+			arg &= ~BIT(6);
+		}
+		else {
+			arg |= BIT(6);
+		}
+#endif //CONFIG_INTEL_PROXIM
+
+		//to do ,for 8188E-SMIC
+		/*
+		*(pu4Byte)&RateMask=EF4Byte((ratr_bitmap&0x0fffffff) | (ratr_index<<28));
+		RateMask[4] = macId | (bShortGI?0x20:0x00) | 0x80;
+		*/	
+		rtl8188e_set_raid_cmd(padapter, mask);	
+		
+	}
+	else
+	{	
+
+#if(RATE_ADAPTIVE_SUPPORT == 1)	
+
+		ODM_RA_UpdateRateInfo_8188E(
+				&(pHalData->odmpriv),
+				mac_id,
+				psta->raid, 
+				mask,
+				shortGIrate
+				);
+
+#endif		
+	}
+}
+
+void rtl8188e_set_hal_ops(struct hal_ops *pHalFunc)
+{
+	pHalFunc->free_hal_data = &rtl8188e_free_hal_data;
+
+	pHalFunc->dm_init = &rtl8188e_init_dm_priv;
+	pHalFunc->dm_deinit = &rtl8188e_deinit_dm_priv;
+
+	pHalFunc->read_chip_version = &rtl8188e_read_chip_version;
+
+	pHalFunc->UpdateRAMaskHandler = &UpdateHalRAMask8188E;
+
+	pHalFunc->set_bwmode_handler = &PHY_SetBWMode8188E;
+	pHalFunc->set_channel_handler = &PHY_SwChnl8188E;
+	pHalFunc->set_chnl_bw_handler = &PHY_SetSwChnlBWMode8188E;
+
+	pHalFunc->set_tx_power_level_handler = &PHY_SetTxPowerLevel8188E;
+	pHalFunc->get_tx_power_level_handler = &PHY_GetTxPowerLevel8188E;
+
+	pHalFunc->hal_dm_watchdog = &rtl8188e_HalDmWatchDog;
+
+	pHalFunc->Add_RateATid = &rtl8188e_Add_RateATid;
+
+	pHalFunc->run_thread= &rtl8188e_start_thread;
+	pHalFunc->cancel_thread= &rtl8188e_stop_thread;
+
+#ifdef CONFIG_ANTENNA_DIVERSITY
+	pHalFunc->AntDivBeforeLinkHandler = &AntDivBeforeLink8188E;
+	pHalFunc->AntDivCompareHandler = &AntDivCompare8188E;
+#endif
+
+	pHalFunc->read_bbreg = &PHY_QueryBBReg8188E;
+	pHalFunc->write_bbreg = &PHY_SetBBReg8188E;
+	pHalFunc->read_rfreg = &PHY_QueryRFReg8188E;
+	pHalFunc->write_rfreg = &PHY_SetRFReg8188E;
+
+
+	// Efuse related function
+	pHalFunc->EfusePowerSwitch = &rtl8188e_EfusePowerSwitch;
+	pHalFunc->ReadEFuse = &rtl8188e_ReadEFuse;
+	pHalFunc->EFUSEGetEfuseDefinition = &rtl8188e_EFUSE_GetEfuseDefinition;
+	pHalFunc->EfuseGetCurrentSize = &rtl8188e_EfuseGetCurrentSize;
+	pHalFunc->Efuse_PgPacketRead = &rtl8188e_Efuse_PgPacketRead;
+	pHalFunc->Efuse_PgPacketWrite = &rtl8188e_Efuse_PgPacketWrite;
+	pHalFunc->Efuse_WordEnableDataWrite = &rtl8188e_Efuse_WordEnableDataWrite;
+
+#ifdef DBG_CONFIG_ERROR_DETECT
+	pHalFunc->sreset_init_value = &sreset_init_value;
+	pHalFunc->sreset_reset_value = &sreset_reset_value;
+	pHalFunc->silentreset = &sreset_reset;
+	pHalFunc->sreset_xmit_status_check = &rtl8188e_sreset_xmit_status_check;
+	pHalFunc->sreset_linked_status_check  = &rtl8188e_sreset_linked_status_check;
+	pHalFunc->sreset_get_wifi_status  = &sreset_get_wifi_status;
+	pHalFunc->sreset_inprogress= &sreset_inprogress;
+#endif //DBG_CONFIG_ERROR_DETECT
+
+	pHalFunc->GetHalODMVarHandler = &rtl8188e_GetHalODMVar;
+	pHalFunc->SetHalODMVarHandler = &rtl8188e_SetHalODMVar;
+
+#ifdef CONFIG_IOL
+	pHalFunc->IOL_exec_cmds_sync = &rtl8188e_IOL_exec_cmds_sync;
+#endif
+
+	pHalFunc->hal_notch_filter = &hal_notch_filter_8188e;
+
+}
+
+u8 GetEEPROMSize8188E(PADAPTER padapter)
+{
+	u8 size = 0;
+	u32	cr;
+
+	cr = rtw_read16(padapter, REG_9346CR);
+	// 6: EEPROM used is 93C46, 4: boot from E-Fuse.
+	size = (cr & BOOT_FROM_EEPROM) ? 6 : 4;
+
+	MSG_8192C("EEPROM type is %s\n", size==4 ? "E-FUSE" : "93C46");
+
+	return size;
+}
+
+#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_PCI_HCI)
+//-------------------------------------------------------------------------
+//
+// LLT R/W/Init function
+//
+//-------------------------------------------------------------------------
+s32 _LLTWrite(PADAPTER padapter, u32 address, u32 data)
+{
+	s32	status = _SUCCESS;
+	s8	count = POLLING_LLT_THRESHOLD;
+	u32	value = _LLT_INIT_ADDR(address) | _LLT_INIT_DATA(data) | _LLT_OP(_LLT_WRITE_ACCESS);
+	
+	rtw_write32(padapter, REG_LLT_INIT, value);
+
+	//polling
+	do {
+		value = rtw_read32(padapter, REG_LLT_INIT);
+		if (_LLT_NO_ACTIVE == _LLT_OP_VALUE(value)) {
+			break;
+		}
+	} while (--count);
+
+	if(count<=0){
+		DBG_871X("Failed to polling write LLT done at address %d!\n", address);
+		status = _FAIL;
+	}
+
+	return status;
+}
+
+u8 _LLTRead(PADAPTER padapter, u32 address)
+{
+	s32	count = 0;
+	u32	value = _LLT_INIT_ADDR(address) | _LLT_OP(_LLT_READ_ACCESS);
+	u16	LLTReg = REG_LLT_INIT;
+
+
+	rtw_write32(padapter, LLTReg, value);
+
+	//polling and get value
+	do {
+		value = rtw_read32(padapter, LLTReg);
+		if (_LLT_NO_ACTIVE == _LLT_OP_VALUE(value)) {
+			return (u8)value;
+		}
+
+		if (count > POLLING_LLT_THRESHOLD) {
+			RT_TRACE(_module_hal_init_c_, _drv_err_, ("Failed to polling read LLT done at address %d!\n", address));
+			break;
+		}
+	} while (count++);
+
+	return 0xFF;
+}
+
+s32 InitLLTTable(PADAPTER padapter, u8 txpktbuf_bndy)
+{
+	s32	status = _FAIL;
+	u32	i;
+	u32	Last_Entry_Of_TxPktBuf = LAST_ENTRY_OF_TX_PKT_BUFFER_8188E;// 176, 22k
+	HAL_DATA_TYPE *pHalData	= GET_HAL_DATA(padapter);
+
+#if defined(CONFIG_IOL_LLT)
+	if(rtw_IOL_applied(padapter))
+	{		
+		status = iol_InitLLTTable(padapter, txpktbuf_bndy);			
+	}
+	else
+#endif
+	{
+		for (i = 0; i < (txpktbuf_bndy - 1); i++) {
+			status = _LLTWrite(padapter, i, i + 1);
+			if (_SUCCESS != status) {
+				return status;
+			}
+		}
+
+		// end of list
+		status = _LLTWrite(padapter, (txpktbuf_bndy - 1), 0xFF);
+		if (_SUCCESS != status) {
+			return status;
+		}
+
+		// Make the other pages as ring buffer
+		// This ring buffer is used as beacon buffer if we config this MAC as two MAC transfer.
+		// Otherwise used as local loopback buffer.
+		for (i = txpktbuf_bndy; i < Last_Entry_Of_TxPktBuf; i++) {
+			status = _LLTWrite(padapter, i, (i + 1));
+			if (_SUCCESS != status) {
+				return status;
+			}
+		}
+
+		// Let last entry point to the start entry of ring buffer
+		status = _LLTWrite(padapter, Last_Entry_Of_TxPktBuf, txpktbuf_bndy);
+		if (_SUCCESS != status) {
+			return status;
+		}
+	}
+
+	return status;
+}
+#endif
+
+
+void
+Hal_InitPGData88E(PADAPTER	padapter)
+{
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+//	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	u32			i;
+	u16			value16;
+
+	if(_FALSE == pEEPROM->bautoload_fail_flag)
+	{ // autoload OK.
+		if (is_boot_from_eeprom(padapter))
+		{
+			// Read all Content from EEPROM or EFUSE.
+			for(i = 0; i < HWSET_MAX_SIZE_88E; i += 2)
+			{
+//				value16 = EF2Byte(ReadEEprom(pAdapter, (u2Byte) (i>>1)));
+//				*((u16*)(&PROMContent[i])) = value16;
+			}
+		}
+		else
+		{
+			// Read EFUSE real map to shadow.
+			EFUSE_ShadowMapUpdate(padapter, EFUSE_WIFI, _FALSE);
+		}
+	}
+	else
+	{//autoload fail
+		RT_TRACE(_module_hci_hal_init_c_, _drv_notice_, ("AutoLoad Fail reported from CR9346!!\n"));
+//		pHalData->AutoloadFailFlag = _TRUE;
+		//update to default value 0xFF
+		if (!is_boot_from_eeprom(padapter))
+			EFUSE_ShadowMapUpdate(padapter, EFUSE_WIFI, _FALSE);
+	}
+}
+
+void
+Hal_EfuseParseIDCode88E(
+	IN	PADAPTER	padapter,
+	IN	u8			*hwinfo
+	)
+{
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+//	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	u16			EEPROMId;
+
+
+	// Checl 0x8129 again for making sure autoload status!!
+	EEPROMId = le16_to_cpu(*((u16*)hwinfo));
+	if (EEPROMId != RTL_EEPROM_ID)
+	{
+		DBG_8192C("EEPROM ID(%#x) is invalid!!\n", EEPROMId);
+		pEEPROM->bautoload_fail_flag = _TRUE;
+	}
+	else
+	{
+		pEEPROM->bautoload_fail_flag = _FALSE;
+	}
+
+	DBG_871X("EEPROM ID=0x%04x\n", EEPROMId);
+}
+
+static void
+Hal_ReadPowerValueFromPROM_8188E(
+	IN	PADAPTER 		padapter,
+	IN	PTxPowerInfo24G	pwrInfo24G,
+	IN	u8*				PROMContent,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	u32 rfPath, eeAddr=EEPROM_TX_PWR_INX_88E, group,TxCount=0;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	
+	_rtw_memset(pwrInfo24G, 0, sizeof(TxPowerInfo24G));
+
+	if(AutoLoadFail)
+	{	
+		for(rfPath = 0 ; rfPath < pHalData->NumTotalRFPath ; rfPath++)
+		{
+			//2.4G default value
+			for(group = 0 ; group < MAX_CHNL_GROUP_24G; group++)
+			{
+				pwrInfo24G->IndexCCK_Base[rfPath][group] =	EEPROM_DEFAULT_24G_INDEX;
+				pwrInfo24G->IndexBW40_Base[rfPath][group] =	EEPROM_DEFAULT_24G_INDEX;
+			}
+			for(TxCount=0;TxCount<MAX_TX_COUNT;TxCount++)
+			{
+				if(TxCount==0)
+				{
+					pwrInfo24G->BW20_Diff[rfPath][0] =	EEPROM_DEFAULT_24G_HT20_DIFF;
+					pwrInfo24G->OFDM_Diff[rfPath][0] =	EEPROM_DEFAULT_24G_OFDM_DIFF;
+				}
+				else
+				{
+					pwrInfo24G->BW20_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;
+					pwrInfo24G->BW40_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;
+					pwrInfo24G->CCK_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;
+					pwrInfo24G->OFDM_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;
+				}
+			}	
+			
+			
+		}
+		
+		//pHalData->bNOPG = TRUE;				
+		return;
+	}	
+
+	for(rfPath = 0 ; rfPath < pHalData->NumTotalRFPath ; rfPath++)
+	{
+		//2.4G default value
+		for(group = 0 ; group < MAX_CHNL_GROUP_24G; group++)
+		{
+			//printk(" IndexCCK_Base rfPath:%d group:%d,eeAddr:0x%02x ",rfPath,group,eeAddr);
+			pwrInfo24G->IndexCCK_Base[rfPath][group] =	PROMContent[eeAddr++];
+			//printk(" IndexCCK_Base:%02x \n",pwrInfo24G->IndexCCK_Base[rfPath][group] );
+			if(pwrInfo24G->IndexCCK_Base[rfPath][group] == 0xFF)
+			{
+				pwrInfo24G->IndexCCK_Base[rfPath][group] = EEPROM_DEFAULT_24G_INDEX;
+//				pHalData->bNOPG = TRUE; 							
+			}
+		}
+		for(group = 0 ; group < MAX_CHNL_GROUP_24G-1; group++)
+		{
+			//printk(" IndexBW40_Base rfPath:%d group:%d,eeAddr:0x%02x ",rfPath,group,eeAddr);
+			pwrInfo24G->IndexBW40_Base[rfPath][group] =	PROMContent[eeAddr++];
+			//printk(" IndexBW40_Base: %02x \n",pwrInfo24G->IndexBW40_Base[rfPath][group]  );
+			if(pwrInfo24G->IndexBW40_Base[rfPath][group] == 0xFF)
+				pwrInfo24G->IndexBW40_Base[rfPath][group] =	EEPROM_DEFAULT_24G_INDEX;
+		}			
+		for(TxCount=0;TxCount<MAX_TX_COUNT_8188E;TxCount++)
+		{
+			if(TxCount==0)
+			{
+				pwrInfo24G->BW40_Diff[rfPath][TxCount] = 0;
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->BW20_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_24G_HT20_DIFF;
+				else
+				{
+					pwrInfo24G->BW20_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0xf0)>>4;				
+				 	if(pwrInfo24G->BW20_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->BW20_Diff[rfPath][TxCount] |= 0xF0;
+				}
+
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->OFDM_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_24G_OFDM_DIFF;				
+				else 
+				{
+					pwrInfo24G->OFDM_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0x0f);					
+					if(pwrInfo24G->OFDM_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->OFDM_Diff[rfPath][TxCount] |= 0xF0;
+				}		
+				pwrInfo24G->CCK_Diff[rfPath][TxCount] = 0;
+				eeAddr++;
+			}
+			else
+			{				
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->BW40_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;								
+				else 
+				{
+					pwrInfo24G->BW40_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0xf0)>>4;				
+					if(pwrInfo24G->BW40_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->BW40_Diff[rfPath][TxCount] |= 0xF0;
+				}
+				
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->BW20_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;				
+				else 
+				{
+					pwrInfo24G->BW20_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0x0f);				
+					if(pwrInfo24G->BW20_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->BW20_Diff[rfPath][TxCount] |= 0xF0;
+				}
+				eeAddr++;
+				
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->OFDM_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;								
+				else 
+				{
+					pwrInfo24G->OFDM_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0xf0)>>4;				
+					if(pwrInfo24G->OFDM_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->OFDM_Diff[rfPath][TxCount] |= 0xF0;
+				}
+			
+				if(PROMContent[eeAddr] == 0xFF)
+					pwrInfo24G->CCK_Diff[rfPath][TxCount] =	EEPROM_DEFAULT_DIFF;												
+				else 
+				{
+					pwrInfo24G->CCK_Diff[rfPath][TxCount] =	(PROMContent[eeAddr]&0x0f);				
+					if(pwrInfo24G->CCK_Diff[rfPath][TxCount] & BIT3)		//4bit sign number to 8 bit sign number
+						pwrInfo24G->CCK_Diff[rfPath][TxCount] |= 0xF0;
+				}
+				eeAddr++;
+			}
+		}
+
+	}
+
+
+}
+
+static u8
+Hal_GetChnlGroup(
+	IN	u8 chnl
+	)
+{
+	u8	group=0;
+
+	if (chnl < 3)			// Cjanel 1-3
+		group = 0;
+	else if (chnl < 9)		// Channel 4-9
+		group = 1;
+	else					// Channel 10-14
+		group = 2;
+
+	return group;
+}
+static u8 
+Hal_GetChnlGroup88E(
+	IN	u8 	chnl,
+	OUT u8*	pGroup
+	)
+{
+	u8 bIn24G=_TRUE;
+
+	if(chnl<=14)
+	{
+		bIn24G=_TRUE;
+
+		if (chnl < 3)			// Chanel 1-2
+			*pGroup = 0;
+		else if (chnl < 6)		// Channel 3-5
+			*pGroup = 1;
+		else	 if(chnl <9)		// Channel 6-8
+			*pGroup = 2;
+		else if(chnl <12)		// Channel 9-11
+			*pGroup = 3;
+		else if(chnl <14)		// Channel 12-13
+			*pGroup = 4;
+		else if(chnl ==14)		// Channel 14
+			*pGroup = 5;	
+		else
+		{
+			//RT_TRACE(COMP_EFUSE,DBG_LOUD,("==>Hal_GetChnlGroup88E in 2.4 G, but Channel %d in Group not found \n",chnl));
+		}
+	}
+	else
+	{
+		bIn24G=_FALSE;
+		
+		if (chnl <=40)	
+			*pGroup = 0;
+		else if (chnl <=48)
+			*pGroup = 1;
+		else	 if(chnl <=56)	
+			*pGroup = 2;
+		else if(chnl <=64)	
+			*pGroup = 3;
+		else if(chnl <=104)
+			*pGroup = 4;
+		else if(chnl <=112)
+			*pGroup = 5;	
+		else if(chnl <=120)
+			*pGroup = 5;	
+		else if(chnl <=128)
+			*pGroup = 6;		
+		else if(chnl <=136)
+			*pGroup = 7;		
+		else if(chnl <=144)
+			*pGroup = 8;		
+		else if(chnl <=153)
+			*pGroup = 9;		
+		else if(chnl <=161)
+			*pGroup = 10;		
+		else if(chnl <=177)
+			*pGroup = 11;	
+		else
+		{
+			//RT_TRACE(COMP_EFUSE,DBG_LOUD,("==>Hal_GetChnlGroup88E in 5G, but Channel %d in Group not found \n",chnl));
+		}
+
+	}
+	//RT_TRACE(COMP_EFUSE,DBG_LOUD,("<==Hal_GetChnlGroup88E,  Channel = %d, bIn24G =%d,\n",chnl,bIn24G));
+	return bIn24G;
+}
+
+void Hal_ReadPowerSavingMode88E(
+	PADAPTER		padapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
+	u8 tmpvalue;
+
+	if(AutoLoadFail){
+		pwrctl->bHWPowerdown = _FALSE;
+		pwrctl->bSupportRemoteWakeup = _FALSE;
+	}
+	else	{		
+
+		//hw power down mode selection , 0:rf-off / 1:power down
+
+		if(padapter->registrypriv.hwpdn_mode==2)
+			pwrctl->bHWPowerdown = (hwinfo[EEPROM_RF_FEATURE_OPTION_88E] & BIT4);
+		else
+			pwrctl->bHWPowerdown = padapter->registrypriv.hwpdn_mode;
+				
+		// decide hw if support remote wakeup function
+		// if hw supported, 8051 (SIE) will generate WeakUP signal( D+/D- toggle) when autoresume
+#ifdef CONFIG_USB_HCI
+		pwrctl->bSupportRemoteWakeup = (hwinfo[EEPROM_USB_OPTIONAL_FUNCTION0] & BIT1)?_TRUE :_FALSE;
+#endif //CONFIG_USB_HCI
+
+		//if(SUPPORT_HW_RADIO_DETECT(Adapter))	
+			//Adapter->registrypriv.usbss_enable = pwrctl->bSupportRemoteWakeup ;
+		
+		DBG_8192C("%s...bHWPwrPindetect(%x)-bHWPowerdown(%x) ,bSupportRemoteWakeup(%x)\n",__FUNCTION__,
+			pwrctl->bHWPwrPindetect, pwrctl->bHWPowerdown, pwrctl->bSupportRemoteWakeup);
+
+		DBG_8192C("### PS params=>  power_mgnt(%x),usbss_enable(%x) ###\n",padapter->registrypriv.power_mgnt,padapter->registrypriv.usbss_enable);
+	
+	}
+
+}
+
+void
+Hal_ReadTxPowerInfo88E(
+	IN	PADAPTER 		padapter,
+	IN	u8*				PROMContent,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{	
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	TxPowerInfo24G		pwrInfo24G;
+	u8			rfPath, ch, group=0, rfPathMax=1;
+	u8			pwr, diff,bIn24G,TxCount;
+
+
+	Hal_ReadPowerValueFromPROM_8188E(padapter, &pwrInfo24G, PROMContent, AutoLoadFail);
+
+	if(!AutoLoadFail)
+		pHalData->bTXPowerDataReadFromEEPORM = TRUE;		
+
+	//for(rfPath = 0 ; rfPath < MAX_RF_PATH ; rfPath++)
+	for(rfPath = 0 ; rfPath < pHalData->NumTotalRFPath ; rfPath++)
+	{
+		for(ch = 0 ; ch < CHANNEL_MAX_NUMBER ; ch++)
+		{
+			bIn24G = Hal_GetChnlGroup88E(ch+1,&group);
+			if(bIn24G)
+			{
+
+				pHalData->Index24G_CCK_Base[rfPath][ch]=pwrInfo24G.IndexCCK_Base[rfPath][group];
+
+				if(ch==(14-1))
+					pHalData->Index24G_BW40_Base[rfPath][ch]=pwrInfo24G.IndexBW40_Base[rfPath][4];
+				else
+					pHalData->Index24G_BW40_Base[rfPath][ch]=pwrInfo24G.IndexBW40_Base[rfPath][group];
+			}
+			
+			if(bIn24G)
+			{
+				DBG_871X("======= Path %d, Channel %d =======\n",rfPath,ch+1 );			
+				DBG_871X("Index24G_CCK_Base[%d][%d] = 0x%x\n",rfPath,ch+1 ,pHalData->Index24G_CCK_Base[rfPath][ch]);
+				DBG_871X("Index24G_BW40_Base[%d][%d] = 0x%x\n",rfPath,ch+1 ,pHalData->Index24G_BW40_Base[rfPath][ch]);			
+			}			
+		}	
+
+		for(TxCount=0;TxCount<MAX_TX_COUNT_8188E;TxCount++)
+		{
+			pHalData->CCK_24G_Diff[rfPath][TxCount]=pwrInfo24G.CCK_Diff[rfPath][TxCount];
+			pHalData->OFDM_24G_Diff[rfPath][TxCount]=pwrInfo24G.OFDM_Diff[rfPath][TxCount];
+			pHalData->BW20_24G_Diff[rfPath][TxCount]=pwrInfo24G.BW20_Diff[rfPath][TxCount];
+			pHalData->BW40_24G_Diff[rfPath][TxCount]=pwrInfo24G.BW40_Diff[rfPath][TxCount];
+#if DBG			
+			DBG_871X("======= TxCount %d =======\n",TxCount );	
+			DBG_871X("CCK_24G_Diff[%d][%d]= %d\n",rfPath,TxCount,pHalData->CCK_24G_Diff[rfPath][TxCount]);
+			DBG_871X("OFDM_24G_Diff[%d][%d]= %d\n",rfPath,TxCount,pHalData->OFDM_24G_Diff[rfPath][TxCount]);
+			DBG_871X("BW20_24G_Diff[%d][%d]= %d\n",rfPath,TxCount,pHalData->BW20_24G_Diff[rfPath][TxCount]);
+			DBG_871X("BW40_24G_Diff[%d][%d]= %d\n",rfPath,TxCount,pHalData->BW40_24G_Diff[rfPath][TxCount]);
+#endif							
+		}
+	}
+
+	
+	// 2010/10/19 MH Add Regulator recognize for EU.
+	if(!AutoLoadFail)
+	{
+		struct registry_priv  *registry_par = &padapter->registrypriv;
+		
+		if(PROMContent[EEPROM_RF_BOARD_OPTION_88E] == 0xFF)
+			pHalData->EEPROMRegulatory = (EEPROM_DEFAULT_BOARD_OPTION&0x7);	//bit0~2
+		else
+			pHalData->EEPROMRegulatory = (PROMContent[EEPROM_RF_BOARD_OPTION_88E]&0x7);	//bit0~2
+		
+	}
+	else
+	{
+		pHalData->EEPROMRegulatory = 0;
+	}
+	DBG_871X("EEPROMRegulatory = 0x%x\n", pHalData->EEPROMRegulatory);
+
+}
+
+
+VOID
+Hal_EfuseParseXtal_8188E(
+	IN	PADAPTER		pAdapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN		AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);
+
+	if(!AutoLoadFail)
+	{
+		pHalData->CrystalCap = hwinfo[EEPROM_XTAL_88E];
+		if(pHalData->CrystalCap == 0xFF)
+			pHalData->CrystalCap = EEPROM_Default_CrystalCap_88E;	
+	}
+	else
+	{
+		pHalData->CrystalCap = EEPROM_Default_CrystalCap_88E;
+	}
+	DBG_871X("CrystalCap: 0x%2x\n", pHalData->CrystalCap);
+}
+
+void
+Hal_EfuseParseBoardType88E(
+	IN	PADAPTER		pAdapter,
+	IN	u8*				hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);
+
+	if (!AutoLoadFail)
+		pHalData->BoardType = ((hwinfo[EEPROM_RF_BOARD_OPTION_88E]&0xE0)>>5);
+	else
+		pHalData->BoardType = 0;
+	DBG_871X("Board Type: 0x%2x\n", pHalData->BoardType);
+}
+
+void
+Hal_EfuseParseEEPROMVer88E(
+	IN	PADAPTER		padapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	if(!AutoLoadFail){		
+		pHalData->EEPROMVersion = hwinfo[EEPROM_VERSION_88E];
+		if(pHalData->EEPROMVersion == 0xFF)
+			pHalData->EEPROMVersion = EEPROM_Default_Version;				
+	}
+	else{
+		pHalData->EEPROMVersion = 1;
+	}
+	RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("Hal_EfuseParseEEPROMVer(), EEVer = %d\n",
+		pHalData->EEPROMVersion));
+}
+
+void
+rtl8188e_EfuseParseChnlPlan(
+	IN	PADAPTER		padapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	padapter->mlmepriv.ChannelPlan = hal_com_config_channel_plan(
+		padapter
+		, hwinfo?hwinfo[EEPROM_ChannelPlan_88E]:0xFF
+		, padapter->registrypriv.channel_plan
+		, RT_CHANNEL_DOMAIN_WORLD_NULL
+		, AutoLoadFail
+	);
+
+	Hal_ChannelPlanToRegulation(padapter, padapter->mlmepriv.ChannelPlan);
+
+	DBG_871X("mlmepriv.ChannelPlan = 0x%02x\n", padapter->mlmepriv.ChannelPlan);
+}
+
+void
+Hal_EfuseParseCustomerID88E(
+	IN	PADAPTER		padapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	if (!AutoLoadFail)
+	{
+		pHalData->EEPROMCustomerID = hwinfo[EEPROM_CustomID_88E];
+		//pHalData->EEPROMSubCustomerID = hwinfo[EEPROM_CustomID_88E];
+	}
+	else
+	{
+		pHalData->EEPROMCustomerID = 0;
+		pHalData->EEPROMSubCustomerID = 0;
+	}
+	DBG_871X("EEPROM Customer ID: 0x%2x\n", pHalData->EEPROMCustomerID);
+	//DBG_871X("EEPROM SubCustomer ID: 0x%02x\n", pHalData->EEPROMSubCustomerID);
+}
+
+
+void
+Hal_ReadAntennaDiversity88E(
+	IN	PADAPTER		pAdapter,
+	IN	u8*				PROMContent,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);
+	struct registry_priv	*registry_par = &pAdapter->registrypriv;	
+
+	if(!AutoLoadFail)
+	{	
+		// Antenna Diversity setting.
+		if(registry_par->antdiv_cfg == 2)// 2:By EFUSE
+		{
+			pHalData->AntDivCfg = (PROMContent[EEPROM_RF_BOARD_OPTION_88E]&0x18)>>3;
+			if(PROMContent[EEPROM_RF_BOARD_OPTION_88E] == 0xFF)			
+				pHalData->AntDivCfg = (EEPROM_DEFAULT_BOARD_OPTION&0x18)>>3;;				
+		}
+		else
+		{
+			pHalData->AntDivCfg = registry_par->antdiv_cfg ;  // 0:OFF , 1:ON, 2:By EFUSE
+		}
+
+		if(registry_par->antdiv_type == 0)// If TRxAntDivType is AUTO in advanced setting, use EFUSE value instead.
+		{
+			pHalData->TRxAntDivType = PROMContent[EEPROM_RF_ANTENNA_OPT_88E];
+			if (pHalData->TRxAntDivType == 0xFF)
+				pHalData->TRxAntDivType = CG_TRX_HW_ANTDIV; // For 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port)
+		}
+		else{
+			pHalData->TRxAntDivType = registry_par->antdiv_type ;
+		}
+			
+		if (pHalData->TRxAntDivType == CG_TRX_HW_ANTDIV || pHalData->TRxAntDivType == CGCS_RX_HW_ANTDIV)
+			pHalData->AntDivCfg = 1; // 0xC1[3] is ignored.
+	}
+	else
+	{
+		pHalData->AntDivCfg = 0;
+	}
+	
+	DBG_871X("EEPROM : AntDivCfg = %x, TRxAntDivType = %x\n",pHalData->AntDivCfg, pHalData->TRxAntDivType);
+
+
+}
+
+void
+Hal_ReadThermalMeter_88E(
+	IN	PADAPTER	Adapter,	
+	IN	u8* 			PROMContent,
+	IN	BOOLEAN 	AutoloadFail
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	u1Byte			tempval;
+
+	//
+	// ThermalMeter from EEPROM
+	//
+	if(!AutoloadFail)	
+		pHalData->EEPROMThermalMeter = PROMContent[EEPROM_THERMAL_METER_88E];
+	else
+		pHalData->EEPROMThermalMeter = EEPROM_Default_ThermalMeter_88E;
+//	pHalData->EEPROMThermalMeter = (tempval&0x1f);	//[4:0]
+
+	if(pHalData->EEPROMThermalMeter == 0xff || AutoloadFail)
+	{
+		pHalData->bAPKThermalMeterIgnore = _TRUE;
+		pHalData->EEPROMThermalMeter = EEPROM_Default_ThermalMeter_88E;		
+	}
+
+	//pHalData->ThermalMeter[0] = pHalData->EEPROMThermalMeter;	
+	DBG_871X("ThermalMeter = 0x%x\n", pHalData->EEPROMThermalMeter);	
+
+}
+
+
+void
+Hal_InitChannelPlan(
+	IN		PADAPTER	padapter
+	)
+{
+#if 0
+	PMGNT_INFO		pMgntInfo = &(padapter->MgntInfo);
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	if((pMgntInfo->RegChannelPlan >= RT_CHANNEL_DOMAIN_MAX) || (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK))
+	{
+		pMgntInfo->ChannelPlan = hal_MapChannelPlan8192C(padapter, (pHalData->EEPROMChannelPlan & (~(EEPROM_CHANNEL_PLAN_BY_HW_MASK))));
+		pMgntInfo->bChnlPlanFromHW = (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK) ? TRUE : FALSE; // User cannot change  channel plan.
+	}
+	else
+	{
+		pMgntInfo->ChannelPlan = (RT_CHANNEL_DOMAIN)pMgntInfo->RegChannelPlan;
+	}
+
+	switch(pMgntInfo->ChannelPlan)
+	{
+		case RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN:
+		{
+			PRT_DOT11D_INFO	pDot11dInfo = GET_DOT11D_INFO(pMgntInfo);
+
+			pDot11dInfo->bEnabled = TRUE;
+		}
+			RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("ReadAdapterInfo8187(): Enable dot11d when RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN!\n"));
+			break;
+
+		default: //for MacOSX compiler warning.
+			break;
+	}
+
+	RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("RegChannelPlan(%d) EEPROMChannelPlan(%d)", pMgntInfo->RegChannelPlan, pHalData->EEPROMChannelPlan));
+	RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("Mgnt ChannelPlan = %d\n" , pMgntInfo->ChannelPlan));
+#endif
+}
+
+BOOLEAN HalDetectPwrDownMode88E(PADAPTER Adapter)
+{
+	u8 tmpvalue = 0;
+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
+	struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);
+
+	EFUSE_ShadowRead(Adapter, 1, EEPROM_RF_FEATURE_OPTION_88E, (u32 *)&tmpvalue);
+
+	// 2010/08/25 MH INF priority > PDN Efuse value.
+	if(tmpvalue & BIT(4) && pwrctrlpriv->reg_pdnmode)
+	{
+		pHalData->pwrdown = _TRUE;
+	}
+	else
+	{
+		pHalData->pwrdown = _FALSE;
+	}
+
+	DBG_8192C("HalDetectPwrDownMode(): PDN=%d\n", pHalData->pwrdown);
+
+	return pHalData->pwrdown;
+}	// HalDetectPwrDownMode
+
+#ifdef CONFIG_WOWLAN
+void Hal_DetectWoWMode(PADAPTER pAdapter)
+{
+	adapter_to_pwrctl(pAdapter)->bSupportRemoteWakeup = _TRUE;
+	DBG_871X("%s\n", __func__);
+}
+#endif
+
+//====================================================================================
+//
+// 20100209 Joseph:
+// This function is used only for 92C to set REG_BCN_CTRL(0x550) register.
+// We just reserve the value of the register in variable pHalData->RegBcnCtrlVal and then operate
+// the value of the register via atomic operation.
+// This prevents from race condition when setting this register.
+// The value of pHalData->RegBcnCtrlVal is initialized in HwConfigureRTL8192CE() function.
+//
+void SetBcnCtrlReg(
+	PADAPTER	padapter,
+	u8		SetBits,
+	u8		ClearBits)
+{
+	PHAL_DATA_TYPE pHalData;
+
+
+	pHalData = GET_HAL_DATA(padapter);
+
+	pHalData->RegBcnCtrlVal |= SetBits;
+	pHalData->RegBcnCtrlVal &= ~ClearBits;
+
+#if 0
+//#ifdef CONFIG_SDIO_HCI
+	if (pHalData->sdio_himr & (SDIO_HIMR_TXBCNOK_MSK | SDIO_HIMR_TXBCNERR_MSK))
+		pHalData->RegBcnCtrlVal |= EN_TXBCN_RPT;
+#endif
+
+	rtw_write8(padapter, REG_BCN_CTRL, (u8)pHalData->RegBcnCtrlVal);
+}
+
+void _InitTransferPageSize(PADAPTER padapter)
+{
+	// Tx page size is always 128.
+
+	u8 value8;
+	value8 = _PSRX(PBP_128) | _PSTX(PBP_128);
+	rtw_write8(padapter, REG_PBP, value8);
+}
+
+void SetHwReg8188E(_adapter *adapter, u8 variable, u8 *val)
+{
+	HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
+
+_func_enter_;
+
+	switch (variable) {
+	case HW_VAR_BASIC_RATE:
+	{
+		struct mlme_ext_info *mlmext_info = &adapter->mlmeextpriv.mlmext_info;
+		u16 input_b = 0, masked = 0, ioted = 0, BrateCfg = 0, RateIndex = 0;
+		u16 rrsr_2g_force_mask = (RRSR_11M|RRSR_5_5M|RRSR_1M);
+		u16 rrsr_2g_allow_mask = (RRSR_24M|RRSR_12M|RRSR_6M|RRSR_11M|RRSR_5_5M|RRSR_2M|RRSR_1M);
+
+		HalSetBrateCfg(adapter, val, &BrateCfg);
+		input_b = BrateCfg;
+
+		/* apply force and allow mask */
+		BrateCfg |= rrsr_2g_force_mask;
+		BrateCfg &= rrsr_2g_allow_mask;
+		masked = BrateCfg;
+
+		/* IOT consideration */
+		if (mlmext_info->assoc_AP_vendor == HT_IOT_PEER_CISCO) {
+			/* if peer is cisco and didn't use ofdm rate, we enable 6M ack */
+			if((BrateCfg & (RRSR_24M|RRSR_12M|RRSR_6M)) == 0)
+				BrateCfg |= RRSR_6M;
+		}
+		ioted = BrateCfg;
+
+		HalData->BasicRateSet = BrateCfg;
+
+		DBG_8192C("HW_VAR_BASIC_RATE: %#x -> %#x -> %#x\n", input_b, masked, ioted);
+
+		// Set RRSR rate table.
+		rtw_write16(adapter, REG_RRSR, BrateCfg);
+		rtw_write8(adapter, REG_RRSR+2, rtw_read8(adapter, REG_RRSR+2)&0xf0);
+
+		// Set RTS initial rate
+		while(BrateCfg > 0x1)
+		{
+			BrateCfg = (BrateCfg>> 1);
+			RateIndex++;
+		}
+		rtw_write8(adapter, REG_INIRTS_RATE_SEL, RateIndex);
+	}
+		break;
+	case HW_VAR_CHECK_TXBUF:
+	{
+		u8 retry_limit;
+		u16 val16;
+		u32 reg_200 = 0, reg_204 = 0;
+		u32 init_reg_200 = 0, init_reg_204 = 0;
+		u32 start = rtw_get_current_time();
+		u32 pass_ms;
+		int i = 0;
+
+		retry_limit = 0x01;
+
+		val16 = retry_limit << RETRY_LIMIT_SHORT_SHIFT | retry_limit << RETRY_LIMIT_LONG_SHIFT;
+		rtw_write16(adapter, REG_RL, val16);
+
+		while (rtw_get_passing_time_ms(start) < 2000
+			&& !adapter->bDriverStopped && !adapter->bSurpriseRemoved
+		) {
+			reg_200 = rtw_read32(adapter, 0x200);
+			reg_204 = rtw_read32(adapter, 0x204);
+
+			if (i == 0) {
+				init_reg_200 = reg_200;
+				init_reg_204 = reg_204;
+			}
+
+			i++;
+			if ((reg_200 & 0x00ffffff) != (reg_204 & 0x00ffffff)) {
+				//DBG_871X("%s: (HW_VAR_CHECK_TXBUF)TXBUF NOT empty - 0x204=0x%x, 0x200=0x%x (%d)\n", __FUNCTION__, reg_204, reg_200, i);
+				rtw_msleep_os(10);
+			} else {
+				break;
+			}
+		}
+
+		pass_ms = rtw_get_passing_time_ms(start);
+
+		if (adapter->bDriverStopped || adapter->bSurpriseRemoved) {
+		} else if (pass_ms >= 2000 || (reg_200 & 0x00ffffff) != (reg_204 & 0x00ffffff)) {
+			DBG_871X_LEVEL(_drv_always_, "%s:(HW_VAR_CHECK_TXBUF)NOT empty(%d) in %d ms\n", __FUNCTION__, i, pass_ms);
+			DBG_871X_LEVEL(_drv_always_, "%s:(HW_VAR_CHECK_TXBUF)0x200=0x%08x, 0x204=0x%08x (0x%08x, 0x%08x)\n",
+				__FUNCTION__, reg_200, reg_204, init_reg_200, init_reg_204);
+			//rtw_warn_on(1);
+		} else {
+			DBG_871X("%s:(HW_VAR_CHECK_TXBUF)TXBUF Empty(%d) in %d ms\n", __FUNCTION__, i, pass_ms);
+		}
+
+		retry_limit = 0x30;
+		val16 = retry_limit << RETRY_LIMIT_SHORT_SHIFT | retry_limit << RETRY_LIMIT_LONG_SHIFT;
+		rtw_write16(adapter, REG_RL, val16);
+	}
+		break;
+	case HW_VAR_RESP_SIFS:
+	{
+		struct mlme_ext_priv	*pmlmeext = &adapter->mlmeextpriv;
+
+		if((pmlmeext->cur_wireless_mode==WIRELESS_11G) ||
+		(pmlmeext->cur_wireless_mode==WIRELESS_11BG))//WIRELESS_MODE_G){
+		{
+			val[0] = 0x0a;
+			val[1] = 0x0a;
+		} else {
+			val[0] = 0x0e;
+			val[1] = 0x0e;
+		}
+
+		// SIFS for OFDM Data ACK
+		rtw_write8(adapter, REG_SIFS_CTX+1, val[0]);
+		// SIFS for OFDM consecutive tx like CTS data!
+		rtw_write8(adapter, REG_SIFS_TRX+1, val[1]);
+
+		rtw_write8(adapter, REG_SPEC_SIFS+1, val[0]);
+		rtw_write8(adapter, REG_MAC_SPEC_SIFS+1, val[0]);
+				
+		//RESP_SIFS for OFDM
+		rtw_write8(adapter, REG_RESP_SIFS_OFDM, val[0]);
+		rtw_write8(adapter, REG_RESP_SIFS_OFDM+1, val[0]);
+	}
+		break;
+
+	case HW_VAR_MACID_SLEEP:
+	{
+		u32 reg_macid_sleep;
+		u8 bit_shift;
+		u8 id = *(u8*)val;
+		u32 val32;
+	
+		if (id < 32){
+			reg_macid_sleep = REG_MACID_PAUSE_0;
+			bit_shift = id;
+		} else if (id < 64) {
+			reg_macid_sleep = REG_MACID_PAUSE_1;
+			bit_shift = id-32;
+		} else {
+			rtw_warn_on(1);
+			break;
+		}
+	
+		val32 = rtw_read32(adapter, reg_macid_sleep);
+		DBG_8192C(FUNC_ADPT_FMT ": [HW_VAR_MACID_SLEEP] macid=%d, org reg_0x%03x=0x%08X\n",
+			FUNC_ADPT_ARG(adapter), id, reg_macid_sleep, val32);
+	
+		if (val32 & BIT(bit_shift))
+			break;
+	
+		val32 |= BIT(bit_shift);
+		rtw_write32(adapter, reg_macid_sleep, val32);
+	}
+		break;
+	
+	case HW_VAR_MACID_WAKEUP:
+	{
+		u32 reg_macid_sleep;
+		u8 bit_shift;
+		u8 id = *(u8*)val;
+		u32 val32;
+	
+		if (id < 32){
+			reg_macid_sleep = REG_MACID_PAUSE_0;
+			bit_shift = id;
+		} else if (id < 64) {
+			reg_macid_sleep = REG_MACID_PAUSE_1;
+			bit_shift = id-32;
+		} else {
+			rtw_warn_on(1);
+			break;
+		}
+	
+		val32 = rtw_read32(adapter, reg_macid_sleep);
+		DBG_8192C(FUNC_ADPT_FMT ": [HW_VAR_MACID_WAKEUP] macid=%d, org reg_0x%03x=0x%08X\n",
+			FUNC_ADPT_ARG(adapter), id, reg_macid_sleep, val32);
+	
+		if (!(val32 & BIT(bit_shift)))
+			break;
+	
+		val32 &= ~BIT(bit_shift);
+		rtw_write32(adapter, reg_macid_sleep, val32);
+	}
+		break;
+
+	default:
+		SetHwReg(adapter, variable, val);
+		break;
+	}
+
+_func_exit_;
+}
+
+struct qinfo_88e {
+	u32 head:8;
+	u32 pkt_num:8;
+	u32 tail:8;
+	u32 ac:2;
+	u32 macid:6;
+};
+
+struct bcn_qinfo_88e {
+	u16 head:8;
+	u16 pkt_num:8;
+};
+
+void dump_qinfo_88e(void *sel, struct qinfo_88e *info, const char *tag)
+{
+	//if (info->pkt_num)
+	DBG_871X_SEL_NL(sel, "%shead:0x%02x, tail:0x%02x, pkt_num:%u, macid:%u, ac:%u\n"
+		, tag ? tag : "", info->head, info->tail, info->pkt_num, info->macid, info->ac
+	);
+}
+
+void dump_bcn_qinfo_88e(void *sel, struct bcn_qinfo_88e *info, const char *tag)
+{
+	//if (info->pkt_num)
+	DBG_871X_SEL_NL(sel, "%shead:0x%02x, pkt_num:%u\n"
+		, tag ? tag : "", info->head, info->pkt_num
+	);
+}
+
+void dump_mac_qinfo_88e(void *sel, _adapter *adapter)
+{
+	u32 q0_info;
+	u32 q1_info;
+	u32 q2_info;
+	u32 q3_info;
+	/*
+	u32 q4_info;
+	u32 q5_info;
+	u32 q6_info;
+	u32 q7_info;
+	*/
+	u32 mg_q_info;
+	u32 hi_q_info;
+	u16 bcn_q_info;
+
+	q0_info = rtw_read32(adapter, REG_Q0_INFO);
+	q1_info = rtw_read32(adapter, REG_Q1_INFO);
+	q2_info = rtw_read32(adapter, REG_Q2_INFO);
+	q3_info = rtw_read32(adapter, REG_Q3_INFO);
+	/*
+	q4_info = rtw_read32(adapter, REG_Q4_INFO);
+	q5_info = rtw_read32(adapter, REG_Q5_INFO);
+	q6_info = rtw_read32(adapter, REG_Q6_INFO);
+	q7_info = rtw_read32(adapter, REG_Q7_INFO);
+	*/
+	mg_q_info = rtw_read32(adapter, REG_MGQ_INFO);
+	hi_q_info = rtw_read32(adapter, REG_HGQ_INFO);
+	bcn_q_info = rtw_read16(adapter, REG_BCNQ_INFO);
+
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q0_info, "Q0 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q1_info, "Q1 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q2_info, "Q2 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q3_info, "Q3 ");
+	/*
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q4_info, "Q4 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q5_info, "Q5 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q6_info, "Q6 ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&q7_info, "Q7 ");
+	*/
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&mg_q_info, "MG ");
+	dump_qinfo_88e(sel, (struct qinfo_88e *)&hi_q_info, "HI ");
+	dump_bcn_qinfo_88e(sel, (struct bcn_qinfo_88e *)&bcn_q_info, "BCN ");
+}
+
+void GetHwReg8188E(_adapter *adapter, u8 variable, u8 *val)
+{
+	HAL_DATA_TYPE *HalData = GET_HAL_DATA(adapter);
+
+_func_enter_;
+
+	switch (variable) {
+	case HW_VAR_SYS_CLKR:
+		*val = rtw_read8(adapter, REG_SYS_CLKR);
+		break;
+	case HW_VAR_DUMP_MAC_QUEUE_INFO:
+		dump_mac_qinfo_88e(val, adapter);
+		break;
+	default:
+		GetHwReg(adapter, variable, val);
+		break;
+	}
+
+_func_exit_;
+}
+
+u8
+GetHalDefVar8188E(
+	IN	PADAPTER				Adapter,
+	IN	HAL_DEF_VARIABLE		eVariable,
+	IN	PVOID					pValue
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);	
+	u8			bResult = _SUCCESS;
+
+	switch(eVariable)
+	{
+		case HAL_DEF_MACID_SLEEP:
+			*(u8*)pValue = _TRUE; // support macid sleep
+			break;
+
+		default:
+			bResult = GetHalDefVar(Adapter, eVariable, pValue);
+			break;
+	}
+
+	return bResult;
+}
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_mp.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_mp.c
new file mode 100644
index 00000000..7e63d5c1
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_mp.c
@@ -0,0 +1,1157 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+#define _RTL8188E_MP_C_

+#ifdef CONFIG_MP_INCLUDED

+

+#include <drv_types.h>

+#include <rtw_mp.h>

+

+#include <rtl8188e_hal.h>

+#include <rtl8188e_dm.h>

+

+

+s32 Hal_SetPowerTracking(PADAPTER padapter, u8 enable)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+

+

+	if (!netif_running(padapter->pnetdev)) {

+		RT_TRACE(_module_mp_, _drv_warning_, ("SetPowerTracking! Fail: interface not opened!\n"));

+		return _FAIL;

+	}

+

+	if (check_fwstate(&padapter->mlmepriv, WIFI_MP_STATE) == _FALSE) {

+		RT_TRACE(_module_mp_, _drv_warning_, ("SetPowerTracking! Fail: not in MP mode!\n"));

+		return _FAIL;

+	}

+

+	if (enable)

+	{

+			pDM_Odm->RFCalibrateInfo.bTXPowerTracking = _TRUE;

+	}

+	else

+		pDM_Odm->RFCalibrateInfo.bTXPowerTrackingInit= _FALSE;

+

+	return _SUCCESS;

+}

+

+void Hal_GetPowerTracking(PADAPTER padapter, u8 *enable)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+

+

+	*enable = pDM_Odm->RFCalibrateInfo.TxPowerTrackControl;

+}

+

+static void Hal_disable_dm(PADAPTER padapter)

+{

+	u8 v8;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+

+

+	//3 1. disable firmware dynamic mechanism

+	// disable Power Training, Rate Adaptive

+	v8 = rtw_read8(padapter, REG_BCN_CTRL);

+	v8 &= ~EN_BCN_FUNCTION;

+	rtw_write8(padapter, REG_BCN_CTRL, v8);

+

+	//3 2. disable driver dynamic mechanism

+	// disable Dynamic Initial Gain

+	// disable High Power

+	// disable Power Tracking

+	Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, _FALSE);

+

+	// enable APK, LCK and IQK but disable power tracking

+	pDM_Odm->RFCalibrateInfo.TxPowerTrackControl = _FALSE;

+	Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, _TRUE);

+}

+

+/*-----------------------------------------------------------------------------

+ * Function:	mpt_SwitchRfSetting

+ *

+ * Overview:	Change RF Setting when we siwthc channel/rate/BW for MP.

+ *

+ * Input:       IN	PADAPTER				pAdapter

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Revised History:

+ * When			Who		Remark

+ * 01/08/2009	MHC		Suggestion from SD3 Willis for 92S series.

+ * 01/09/2009	MHC		Add CCK modification for 40MHZ. Suggestion from SD3.

+ *

+ *---------------------------------------------------------------------------*/

+void Hal_mpt_SwitchRfSetting(PADAPTER pAdapter)

+{	

+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	struct mp_priv	*pmp = &pAdapter->mppriv;

+	u1Byte				ChannelToSw = pmp->channel;

+	ULONG				ulRateIdx = pmp->rateidx;

+	ULONG				ulbandwidth = pmp->bandwidth;

+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(pAdapter);	

+

+	// <20120525, Kordan> Dynamic mechanism for APK, asked by Dennis.

+	if (IS_HARDWARE_TYPE_8188ES(pAdapter) && (1 <= ChannelToSw && ChannelToSw <= 11) &&

+		(ulRateIdx == MPT_RATE_MCS0 || ulRateIdx == MPT_RATE_1M || ulRateIdx == MPT_RATE_6M))

+	{

+		pmp->MptCtx.backup0x52_RF_A = (u1Byte)PHY_QueryRFReg(pAdapter, ODM_RF_PATH_A, RF_0x52, 0x000F0);

+		pmp->MptCtx.backup0x52_RF_B = (u1Byte)PHY_QueryRFReg(pAdapter, ODM_RF_PATH_B, RF_0x52, 0x000F0);

+		PHY_SetRFReg(pAdapter, ODM_RF_PATH_A, RF_0x52, 0x000F0, 0xD);

+		PHY_SetRFReg(pAdapter, ODM_RF_PATH_B, RF_0x52, 0x000F0, 0xD);

+	}

+	else if (IS_HARDWARE_TYPE_8188E(pAdapter))

+	{

+		PHY_SetRFReg(pAdapter, ODM_RF_PATH_A, RF_0x52, 0x000F0, pmp->MptCtx.backup0x52_RF_A);

+		PHY_SetRFReg(pAdapter, ODM_RF_PATH_B, RF_0x52, 0x000F0, pmp->MptCtx.backup0x52_RF_B);

+	}

+

+	return ;

+}

+/*---------------------------hal\rtl8192c\MPT_Phy.c---------------------------*/

+

+/*---------------------------hal\rtl8192c\MPT_HelperFunc.c---------------------------*/

+void Hal_MPT_CCKTxPowerAdjust(PADAPTER Adapter, BOOLEAN bInCH14)

+{

+	u32		TempVal = 0, TempVal2 = 0, TempVal3 = 0;

+	u32		CurrCCKSwingVal = 0, CCKSwingIndex = 12;

+	u8		i;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+

+

+	// get current cck swing value and check 0xa22 & 0xa23 later to match the table.

+	CurrCCKSwingVal = read_bbreg(Adapter, rCCK0_TxFilter1, bMaskHWord);

+

+	if (!bInCH14)

+	{

+		// Readback the current bb cck swing value and compare with the table to

+		// get the current swing index

+		for (i = 0; i < CCK_TABLE_SIZE; i++)

+		{

+			if (((CurrCCKSwingVal&0xff) == (u32)CCKSwingTable_Ch1_Ch13[i][0]) &&

+				(((CurrCCKSwingVal&0xff00)>>8) == (u32)CCKSwingTable_Ch1_Ch13[i][1]))

+			{

+				CCKSwingIndex = i;

+//				RT_TRACE(COMP_INIT, DBG_LOUD,("Ch1~13, Current reg0x%x = 0x%lx, CCKSwingIndex=0x%x\n",

+//					(rCCK0_TxFilter1+2), CurrCCKSwingVal, CCKSwingIndex));

+				break;

+			}

+		}

+

+		//Write 0xa22 0xa23

+		TempVal = CCKSwingTable_Ch1_Ch13[CCKSwingIndex][0] +

+				(CCKSwingTable_Ch1_Ch13[CCKSwingIndex][1]<<8) ;

+

+

+		//Write 0xa24 ~ 0xa27

+		TempVal2 = 0;

+		TempVal2 = CCKSwingTable_Ch1_Ch13[CCKSwingIndex][2] +

+				(CCKSwingTable_Ch1_Ch13[CCKSwingIndex][3]<<8) +

+				(CCKSwingTable_Ch1_Ch13[CCKSwingIndex][4]<<16 )+

+				(CCKSwingTable_Ch1_Ch13[CCKSwingIndex][5]<<24);

+

+		//Write 0xa28  0xa29

+		TempVal3 = 0;

+		TempVal3 = CCKSwingTable_Ch1_Ch13[CCKSwingIndex][6] +

+				(CCKSwingTable_Ch1_Ch13[CCKSwingIndex][7]<<8) ;

+	}

+	else

+	{

+		for (i = 0; i < CCK_TABLE_SIZE; i++)

+		{

+			if (((CurrCCKSwingVal&0xff) == (u32)CCKSwingTable_Ch14[i][0]) &&

+				(((CurrCCKSwingVal&0xff00)>>8) == (u32)CCKSwingTable_Ch14[i][1]))

+			{

+				CCKSwingIndex = i;

+//				RT_TRACE(COMP_INIT, DBG_LOUD,("Ch14, Current reg0x%x = 0x%lx, CCKSwingIndex=0x%x\n",

+//					(rCCK0_TxFilter1+2), CurrCCKSwingVal, CCKSwingIndex));

+				break;

+			}

+		}

+

+		//Write 0xa22 0xa23

+		TempVal = CCKSwingTable_Ch14[CCKSwingIndex][0] +

+				(CCKSwingTable_Ch14[CCKSwingIndex][1]<<8) ;

+

+		//Write 0xa24 ~ 0xa27

+		TempVal2 = 0;

+		TempVal2 = CCKSwingTable_Ch14[CCKSwingIndex][2] +

+				(CCKSwingTable_Ch14[CCKSwingIndex][3]<<8) +

+				(CCKSwingTable_Ch14[CCKSwingIndex][4]<<16 )+

+				(CCKSwingTable_Ch14[CCKSwingIndex][5]<<24);

+

+		//Write 0xa28  0xa29

+		TempVal3 = 0;

+		TempVal3 = CCKSwingTable_Ch14[CCKSwingIndex][6] +

+				(CCKSwingTable_Ch14[CCKSwingIndex][7]<<8) ;

+	}

+

+	write_bbreg(Adapter, rCCK0_TxFilter1, bMaskHWord, TempVal);

+	write_bbreg(Adapter, rCCK0_TxFilter2, bMaskDWord, TempVal2);

+	write_bbreg(Adapter, rCCK0_DebugPort, bMaskLWord, TempVal3);

+}

+

+void Hal_MPT_CCKTxPowerAdjustbyIndex(PADAPTER pAdapter, BOOLEAN beven)

+{

+	s32		TempCCk;

+	u8		CCK_index, CCK_index_old=0;

+	u8		Action = 0;	//0: no action, 1: even->odd, 2:odd->even

+	u8		TimeOut = 100;

+	s32		i = 0;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	PMPT_CONTEXT	pMptCtx = &pAdapter->mppriv.MptCtx;

+

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+

+

+	if (!IS_92C_SERIAL(pHalData->VersionID))

+		return;

+#if 0

+	while(PlatformAtomicExchange(&Adapter->IntrCCKRefCount, TRUE) == TRUE)

+	{

+		PlatformSleepUs(100);

+		TimeOut--;

+		if(TimeOut <= 0)

+		{

+			RTPRINT(FINIT, INIT_TxPower,

+			 ("!!!MPT_CCKTxPowerAdjustbyIndex Wait for check CCK gain index too long!!!\n" ));

+			break;

+		}

+	}

+#endif

+	if (beven && !pMptCtx->bMptIndexEven)	//odd->even

+	{

+		Action = 2;

+		pMptCtx->bMptIndexEven = _TRUE;

+	}

+	else if (!beven && pMptCtx->bMptIndexEven)	//even->odd

+	{

+		Action = 1;

+		pMptCtx->bMptIndexEven = _FALSE;

+	}

+

+	if (Action != 0)

+	{

+		//Query CCK default setting From 0xa24

+		TempCCk = read_bbreg(pAdapter, rCCK0_TxFilter2, bMaskDWord) & bMaskCCK;

+		for (i = 0; i < CCK_TABLE_SIZE; i++)

+		{

+			if (pDM_Odm->RFCalibrateInfo.bCCKinCH14)

+			{

+				if (_rtw_memcmp((void*)&TempCCk, (void*)&CCKSwingTable_Ch14[i][2], 4) == _TRUE)

+				{

+					CCK_index_old = (u8) i;

+//					RTPRINT(FINIT, INIT_TxPower,("MPT_CCKTxPowerAdjustbyIndex: Initial reg0x%x = 0x%lx, CCK_index=0x%x, ch 14 %d\n",

+//						rCCK0_TxFilter2, TempCCk, CCK_index_old, pHalData->bCCKinCH14));

+					break;

+				}

+			}

+			else

+			{

+				if (_rtw_memcmp((void*)&TempCCk, (void*)&CCKSwingTable_Ch1_Ch13[i][2], 4) == _TRUE)

+				{

+					CCK_index_old = (u8) i;

+//					RTPRINT(FINIT, INIT_TxPower,("MPT_CCKTxPowerAdjustbyIndex: Initial reg0x%x = 0x%lx, CCK_index=0x%x, ch14 %d\n",

+//						rCCK0_TxFilter2, TempCCk, CCK_index_old, pHalData->bCCKinCH14));

+					break;

+				}

+			}

+		}

+

+		if (Action == 1) {

+			if (CCK_index_old == 0)

+				CCK_index_old = 1;

+			CCK_index = CCK_index_old - 1;

+		} else {

+			CCK_index = CCK_index_old + 1;

+		}

+

+		if (CCK_index == CCK_TABLE_SIZE) {

+			CCK_index = CCK_TABLE_SIZE -1;

+			RT_TRACE(_module_mp_, _drv_info_, ("CCK_index == CCK_TABLE_SIZE\n"));

+		}

+

+//		RTPRINT(FINIT, INIT_TxPower,("MPT_CCKTxPowerAdjustbyIndex: new CCK_index=0x%x\n",

+//			 CCK_index));

+

+		//Adjust CCK according to gain index

+		if (!pDM_Odm->RFCalibrateInfo.bCCKinCH14) {

+			rtw_write8(pAdapter, 0xa22, CCKSwingTable_Ch1_Ch13[CCK_index][0]);

+			rtw_write8(pAdapter, 0xa23, CCKSwingTable_Ch1_Ch13[CCK_index][1]);

+			rtw_write8(pAdapter, 0xa24, CCKSwingTable_Ch1_Ch13[CCK_index][2]);

+			rtw_write8(pAdapter, 0xa25, CCKSwingTable_Ch1_Ch13[CCK_index][3]);

+			rtw_write8(pAdapter, 0xa26, CCKSwingTable_Ch1_Ch13[CCK_index][4]);

+			rtw_write8(pAdapter, 0xa27, CCKSwingTable_Ch1_Ch13[CCK_index][5]);

+			rtw_write8(pAdapter, 0xa28, CCKSwingTable_Ch1_Ch13[CCK_index][6]);

+			rtw_write8(pAdapter, 0xa29, CCKSwingTable_Ch1_Ch13[CCK_index][7]);

+		} else {

+			rtw_write8(pAdapter, 0xa22, CCKSwingTable_Ch14[CCK_index][0]);

+			rtw_write8(pAdapter, 0xa23, CCKSwingTable_Ch14[CCK_index][1]);

+			rtw_write8(pAdapter, 0xa24, CCKSwingTable_Ch14[CCK_index][2]);

+			rtw_write8(pAdapter, 0xa25, CCKSwingTable_Ch14[CCK_index][3]);

+			rtw_write8(pAdapter, 0xa26, CCKSwingTable_Ch14[CCK_index][4]);

+			rtw_write8(pAdapter, 0xa27, CCKSwingTable_Ch14[CCK_index][5]);

+			rtw_write8(pAdapter, 0xa28, CCKSwingTable_Ch14[CCK_index][6]);

+			rtw_write8(pAdapter, 0xa29, CCKSwingTable_Ch14[CCK_index][7]);

+		}

+	}

+#if 0

+	RTPRINT(FINIT, INIT_TxPower,

+	("MPT_CCKTxPowerAdjustbyIndex 0xa20=%x\n", PlatformEFIORead4Byte(Adapter, 0xa20)));

+

+	PlatformAtomicExchange(&Adapter->IntrCCKRefCount, FALSE);

+#endif

+}

+/*---------------------------hal\rtl8192c\MPT_HelperFunc.c---------------------------*/

+

+/*

+ * SetChannel

+ * Description

+ *	Use H2C command to change channel,

+ *	not only modify rf register, but also other setting need to be done.

+ */

+void Hal_SetChannel(PADAPTER pAdapter)

+{

+#if 0

+	struct mp_priv *pmp = &pAdapter->mppriv;

+

+//	SelectChannel(pAdapter, pmp->channel);

+	set_channel_bwmode(pAdapter, pmp->channel, pmp->channel_offset, pmp->bandwidth);

+#else

+	u8 		eRFPath;

+

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	struct mp_priv	*pmp = &pAdapter->mppriv;

+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;

+	PDM_ODM_T		pDM_Odm = &(pHalData->odmpriv);

+	

+	u8		channel = pmp->channel;

+	u8		bandwidth = pmp->bandwidth;

+	u8		rate = pmp->rateidx;

+

+

+	// set RF channel register

+	for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)

+	{

+      		if(IS_HARDWARE_TYPE_8192D(pAdapter))

+			_write_rfreg(pAdapter, eRFPath, ODM_CHANNEL, 0xFF, channel);

+		else

+			_write_rfreg(pAdapter, eRFPath, ODM_CHANNEL, 0x3FF, channel);

+	}

+	Hal_mpt_SwitchRfSetting(pAdapter);

+

+	SelectChannel(pAdapter, channel);

+

+	if (pHalData->CurrentChannel == 14 && !pDM_Odm->RFCalibrateInfo.bCCKinCH14) {

+		pDM_Odm->RFCalibrateInfo.bCCKinCH14 = _TRUE;

+		Hal_MPT_CCKTxPowerAdjust(pAdapter, pDM_Odm->RFCalibrateInfo.bCCKinCH14);

+	}

+	else if (pHalData->CurrentChannel != 14 && pDM_Odm->RFCalibrateInfo.bCCKinCH14) {

+		pDM_Odm->RFCalibrateInfo.bCCKinCH14 = _FALSE;

+		Hal_MPT_CCKTxPowerAdjust(pAdapter, pDM_Odm->RFCalibrateInfo.bCCKinCH14);

+	}

+

+#endif

+}

+

+/*

+ * Notice

+ *	Switch bandwitdth may change center frequency(channel)

+ */

+void Hal_SetBandwidth(PADAPTER pAdapter)

+{

+	struct mp_priv *pmp = &pAdapter->mppriv;

+

+

+	SetBWMode(pAdapter, pmp->bandwidth, pmp->prime_channel_offset);

+	Hal_mpt_SwitchRfSetting(pAdapter);

+}

+

+void Hal_SetCCKTxPower(PADAPTER pAdapter, u8 *TxPower)

+{

+	u32 tmpval = 0;

+

+

+	// rf-A cck tx power

+	write_bbreg(pAdapter, rTxAGC_A_CCK1_Mcs32, bMaskByte1, TxPower[RF_PATH_A]);

+	tmpval = (TxPower[RF_PATH_A]<<16) | (TxPower[RF_PATH_A]<<8) | TxPower[RF_PATH_A];

+	write_bbreg(pAdapter, rTxAGC_B_CCK11_A_CCK2_11, 0xffffff00, tmpval);

+

+	// rf-B cck tx power

+	write_bbreg(pAdapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte0, TxPower[RF_PATH_B]);

+	tmpval = (TxPower[RF_PATH_B]<<16) | (TxPower[RF_PATH_B]<<8) | TxPower[RF_PATH_B];

+	write_bbreg(pAdapter, rTxAGC_B_CCK1_55_Mcs32, 0xffffff00, tmpval);

+

+	RT_TRACE(_module_mp_, _drv_notice_,

+		 ("-SetCCKTxPower: A[0x%02x] B[0x%02x]\n",

+		  TxPower[RF_PATH_A], TxPower[RF_PATH_B]));

+}

+

+void Hal_SetOFDMTxPower(PADAPTER pAdapter, u8 *TxPower)

+{

+	u32 TxAGC = 0;

+	u8 tmpval = 0;

+	PMPT_CONTEXT	pMptCtx = &pAdapter->mppriv.MptCtx;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+

+

+	// HT Tx-rf(A)

+	tmpval = TxPower[RF_PATH_A];

+	TxAGC = (tmpval<<24) | (tmpval<<16) | (tmpval<<8) | tmpval;

+

+	write_bbreg(pAdapter, rTxAGC_A_Rate18_06, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_A_Rate54_24, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_A_Mcs03_Mcs00, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_A_Mcs07_Mcs04, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_A_Mcs11_Mcs08, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_A_Mcs15_Mcs12, bMaskDWord, TxAGC);

+

+	// HT Tx-rf(B)

+	tmpval = TxPower[RF_PATH_B];

+	TxAGC = (tmpval<<24) | (tmpval<<16) | (tmpval<<8) | tmpval;

+

+	write_bbreg(pAdapter, rTxAGC_B_Rate18_06, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_B_Rate54_24, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_B_Mcs03_Mcs00, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_B_Mcs07_Mcs04, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_B_Mcs11_Mcs08, bMaskDWord, TxAGC);

+	write_bbreg(pAdapter, rTxAGC_B_Mcs15_Mcs12, bMaskDWord, TxAGC);

+

+}

+

+void Hal_SetAntennaPathPower(PADAPTER pAdapter)

+{

+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);

+	u8 TxPowerLevel[MAX_RF_PATH_NUMS];

+	u8 rfPath;

+

+	TxPowerLevel[RF_PATH_A] = pAdapter->mppriv.txpoweridx;

+	TxPowerLevel[RF_PATH_B] = pAdapter->mppriv.txpoweridx_b;

+

+	switch (pAdapter->mppriv.antenna_tx)

+	{

+		case ANTENNA_A:

+		default:

+			rfPath = RF_PATH_A;

+			break;

+		case ANTENNA_B:

+			rfPath = RF_PATH_B;

+			break;

+		case ANTENNA_C:

+			rfPath = RF_PATH_C;

+			break;

+	}

+

+	switch (pHalData->rf_chip)

+	{

+		case RF_8225:

+		case RF_8256:

+		case RF_6052:

+			Hal_SetCCKTxPower(pAdapter, TxPowerLevel);

+			if (pAdapter->mppriv.rateidx < MPT_RATE_6M)	// CCK rate

+				Hal_MPT_CCKTxPowerAdjustbyIndex(pAdapter, TxPowerLevel[rfPath]%2 == 0);

+			Hal_SetOFDMTxPower(pAdapter, TxPowerLevel);

+			break;

+

+		default:

+			break;

+	}

+}

+

+void Hal_SetTxPower(PADAPTER pAdapter)

+{

+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);

+	u8 TxPower = pAdapter->mppriv.txpoweridx;

+	u8 TxPowerLevel[MAX_RF_PATH_NUMS];

+	u8 rf, rfPath;

+

+	for (rf = 0; rf < MAX_RF_PATH_NUMS; rf++) {

+		TxPowerLevel[rf] = TxPower;

+	}

+

+	switch (pAdapter->mppriv.antenna_tx)

+	{

+		case ANTENNA_A:

+		default:

+			rfPath = RF_PATH_A;

+			break;

+		case ANTENNA_B:

+			rfPath = RF_PATH_B;

+			break;

+		case ANTENNA_C:

+			rfPath = RF_PATH_C;

+			break;

+	}

+

+	switch (pHalData->rf_chip)

+	{

+		// 2008/09/12 MH Test only !! We enable the TX power tracking for MP!!!!!

+		// We should call normal driver API later!!

+		case RF_8225:

+		case RF_8256:

+		case RF_6052:

+			Hal_SetCCKTxPower(pAdapter, TxPowerLevel);

+			if (pAdapter->mppriv.rateidx < MPT_RATE_6M)	// CCK rate

+				Hal_MPT_CCKTxPowerAdjustbyIndex(pAdapter, TxPowerLevel[rfPath]%2 == 0);

+			Hal_SetOFDMTxPower(pAdapter, TxPowerLevel);

+			break;

+

+		default:

+			break;

+	}

+

+//	SetCCKTxPower(pAdapter, TxPower);

+//	SetOFDMTxPower(pAdapter, TxPower);

+}

+

+void Hal_SetTxAGCOffset(PADAPTER pAdapter, u32 ulTxAGCOffset)

+{

+	u32 TxAGCOffset_B, TxAGCOffset_C, TxAGCOffset_D,tmpAGC;

+

+	TxAGCOffset_B = (ulTxAGCOffset&0x000000ff);

+	TxAGCOffset_C = ((ulTxAGCOffset&0x0000ff00)>>8);

+	TxAGCOffset_D = ((ulTxAGCOffset&0x00ff0000)>>16);

+

+	tmpAGC = (TxAGCOffset_D<<8 | TxAGCOffset_C<<4 | TxAGCOffset_B);

+	write_bbreg(pAdapter, rFPGA0_TxGainStage,

+			(bXBTxAGC|bXCTxAGC|bXDTxAGC), tmpAGC);

+}

+

+void Hal_SetDataRate(PADAPTER pAdapter)

+{

+	Hal_mpt_SwitchRfSetting(pAdapter);

+}

+

+void Hal_SetAntenna(PADAPTER pAdapter)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+

+	R_ANTENNA_SELECT_OFDM *p_ofdm_tx;	/* OFDM Tx register */

+	R_ANTENNA_SELECT_CCK *p_cck_txrx;

+

+	u8	r_rx_antenna_ofdm = 0, r_ant_select_cck_val = 0;

+	u8	chgTx = 0, chgRx = 0;

+	u32	r_ant_sel_cck_val = 0, r_ant_select_ofdm_val = 0, r_ofdm_tx_en_val = 0;

+

+

+	p_ofdm_tx = (R_ANTENNA_SELECT_OFDM *)&r_ant_select_ofdm_val;

+	p_cck_txrx = (R_ANTENNA_SELECT_CCK *)&r_ant_select_cck_val;

+

+	p_ofdm_tx->r_ant_ht1	= 0x1;

+	p_ofdm_tx->r_ant_ht2	= 0x2;	// Second TX RF path is A

+	p_ofdm_tx->r_ant_non_ht = 0x3;	// 0x1+0x2=0x3

+

+	switch (pAdapter->mppriv.antenna_tx)

+	{

+		case ANTENNA_A:

+			p_ofdm_tx->r_tx_antenna		= 0x1;

+			r_ofdm_tx_en_val		= 0x1;

+			p_ofdm_tx->r_ant_l 		= 0x1;

+			p_ofdm_tx->r_ant_ht_s1 		= 0x1;

+			p_ofdm_tx->r_ant_non_ht_s1 	= 0x1;

+			p_cck_txrx->r_ccktx_enable	= 0x8;

+			chgTx = 1;

+

+			// From SD3 Willis suggestion !!! Set RF A=TX and B as standby

+//			if (IS_HARDWARE_TYPE_8192S(pAdapter))

+			{

+			write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 2);

+			write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 1);

+			r_ofdm_tx_en_val		= 0x3;

+

+			// Power save

+			//cosa r_ant_select_ofdm_val = 0x11111111;

+

+			// We need to close RFB by SW control

+			if (pHalData->rf_type == RF_2T2R)

+			{

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT26, 1);

+				PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT1, 1);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT17, 0);

+			}

+			}

+			break;

+

+		case ANTENNA_B:

+			p_ofdm_tx->r_tx_antenna		= 0x2;

+			r_ofdm_tx_en_val		= 0x2;

+			p_ofdm_tx->r_ant_l 		= 0x2;

+			p_ofdm_tx->r_ant_ht_s1 		= 0x2;

+			p_ofdm_tx->r_ant_non_ht_s1 	= 0x2;

+			p_cck_txrx->r_ccktx_enable	= 0x4;

+			chgTx = 1;

+

+			// From SD3 Willis suggestion !!! Set RF A as standby

+			//if (IS_HARDWARE_TYPE_8192S(pAdapter))

+			{

+			PHY_SetBBReg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 1);

+			PHY_SetBBReg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 2);

+//			r_ofdm_tx_en_val		= 0x3;

+

+			// Power save

+			//cosa r_ant_select_ofdm_val = 0x22222222;

+

+			// 2008/10/31 MH From SD3 Willi's suggestion. We must read RF 1T table.

+			// 2009/01/08 MH From Sd3 Willis. We need to close RFA by SW control

+			if (pHalData->rf_type == RF_2T2R || pHalData->rf_type == RF_1T2R)

+			{

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT10, 1);

+				PHY_SetBBReg(pAdapter, rFPGA0_XA_RFInterfaceOE, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT26, 0);

+//				PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT1, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT17, 1);

+			}

+			}

+		break;

+

+		case ANTENNA_AB:	// For 8192S

+			p_ofdm_tx->r_tx_antenna		= 0x3;

+			r_ofdm_tx_en_val		= 0x3;

+			p_ofdm_tx->r_ant_l 		= 0x3;

+			p_ofdm_tx->r_ant_ht_s1 		= 0x3;

+			p_ofdm_tx->r_ant_non_ht_s1 	= 0x3;

+			p_cck_txrx->r_ccktx_enable	= 0xC;

+			chgTx = 1;

+

+			// From SD3 Willis suggestion !!! Set RF B as standby

+			//if (IS_HARDWARE_TYPE_8192S(pAdapter))

+			{

+			PHY_SetBBReg(pAdapter, rFPGA0_XA_HSSIParameter2, 0xe, 2);

+			PHY_SetBBReg(pAdapter, rFPGA0_XB_HSSIParameter2, 0xe, 2);

+

+			// Disable Power save

+			//cosa r_ant_select_ofdm_val = 0x3321333;

+#if 0

+			// 2008/10/31 MH From SD3 Willi's suggestion. We must read RFA 2T table.

+			if ((pHalData->VersionID == VERSION_8192S_ACUT)) // For RTL8192SU A-Cut only, by Roger, 2008.11.07.

+			{

+				mpt_RFConfigFromPreParaArrary(pAdapter, 1, RF_PATH_A);

+			}

+#endif

+			// 2009/01/08 MH From Sd3 Willis. We need to enable RFA/B by SW control

+			if (pHalData->rf_type == RF_2T2R)

+			{

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFInterfaceSW, BIT26, 0);

+//				PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT10, 0);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT1, 1);

+				PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT17, 1);

+			}

+			}

+			break;

+

+		default:

+			break;

+	}

+

+	//

+	// r_rx_antenna_ofdm, bit0=A, bit1=B, bit2=C, bit3=D

+	// r_cckrx_enable : CCK default, 0=A, 1=B, 2=C, 3=D

+	// r_cckrx_enable_2 : CCK option, 0=A, 1=B, 2=C, 3=D

+	//

+	switch (pAdapter->mppriv.antenna_rx)

+	{

+		case ANTENNA_A:

+			r_rx_antenna_ofdm 		= 0x1;	// A

+			p_cck_txrx->r_cckrx_enable 	= 0x0;	// default: A

+			p_cck_txrx->r_cckrx_enable_2	= 0x0;	// option: A

+			chgRx = 1;

+			break;

+

+		case ANTENNA_B:

+			r_rx_antenna_ofdm 		= 0x2;	// B

+			p_cck_txrx->r_cckrx_enable 	= 0x1;	// default: B

+			p_cck_txrx->r_cckrx_enable_2	= 0x1;	// option: B

+			chgRx = 1;

+			break;

+

+		case ANTENNA_AB:

+			r_rx_antenna_ofdm 		= 0x3;	// AB

+			p_cck_txrx->r_cckrx_enable 	= 0x0;	// default:A

+			p_cck_txrx->r_cckrx_enable_2	= 0x1;	// option:B

+			chgRx = 1;

+			break;

+

+		default:

+			break;

+	}

+

+	if (chgTx && chgRx)

+	{

+		switch(pHalData->rf_chip)

+		{

+			case RF_8225:

+			case RF_8256:

+			case RF_6052:

+				//r_ant_sel_cck_val = r_ant_select_cck_val;

+				PHY_SetBBReg(pAdapter, rFPGA1_TxInfo, 0x7fffffff, r_ant_select_ofdm_val);	//OFDM Tx

+				PHY_SetBBReg(pAdapter, rFPGA0_TxInfo, 0x0000000f, r_ofdm_tx_en_val);		//OFDM Tx

+				PHY_SetBBReg(pAdapter, rOFDM0_TRxPathEnable, 0x0000000f, r_rx_antenna_ofdm);	//OFDM Rx

+				PHY_SetBBReg(pAdapter, rOFDM1_TRxPathEnable, 0x0000000f, r_rx_antenna_ofdm);	//OFDM Rx

+				PHY_SetBBReg(pAdapter, rCCK0_AFESetting, bMaskByte3, r_ant_select_cck_val);//r_ant_sel_cck_val);		//CCK TxRx

+

+				break;

+

+			default:

+				break;

+		}

+	}

+

+	RT_TRACE(_module_mp_, _drv_notice_, ("-SwitchAntenna: finished\n"));

+}

+

+s32 Hal_SetThermalMeter(PADAPTER pAdapter, u8 target_ther)

+{

+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);

+

+

+	if (!netif_running(pAdapter->pnetdev)) {

+		RT_TRACE(_module_mp_, _drv_warning_, ("SetThermalMeter! Fail: interface not opened!\n"));

+		return _FAIL;

+	}

+

+	if (check_fwstate(&pAdapter->mlmepriv, WIFI_MP_STATE) == _FALSE) {

+		RT_TRACE(_module_mp_, _drv_warning_, ("SetThermalMeter: Fail! not in MP mode!\n"));

+		return _FAIL;

+	}

+

+	target_ther &= 0xff;

+	if (target_ther < 0x07)

+		target_ther = 0x07;

+	else if (target_ther > 0x1d)

+		target_ther = 0x1d;

+

+	pHalData->EEPROMThermalMeter = target_ther;

+

+	return _SUCCESS;

+}

+

+void Hal_TriggerRFThermalMeter(PADAPTER pAdapter)

+{

+  

+	_write_rfreg( pAdapter, RF_PATH_A , RF_T_METER_88E , BIT17 |BIT16 , 0x03 );

+

+//	RT_TRACE(_module_mp_,_drv_alert_, ("TriggerRFThermalMeter() finished.\n" ));

+}

+

+u8 Hal_ReadRFThermalMeter(PADAPTER pAdapter)

+{

+	u32 ThermalValue = 0;

+

+	//ThermalValue = _read_rfreg(pAdapter, RF_PATH_A, RF_T_METER, 0x1F);	// 0x24: RF Reg[4:0]

+

+	ThermalValue = _read_rfreg(pAdapter, RF_PATH_A, RF_T_METER_88E, 0xfc00);

+	

+//	RT_TRACE(_module_mp_, _drv_alert_, ("ThermalValue = 0x%x\n", ThermalValue));

+	return (u8)ThermalValue;

+}

+

+void Hal_GetThermalMeter(PADAPTER pAdapter, u8 *value)

+{

+#if 0

+	fw_cmd(pAdapter, IOCMD_GET_THERMAL_METER);

+	rtw_msleep_os(1000);

+	fw_cmd_data(pAdapter, value, 1);

+	*value &= 0xFF;

+#else

+

+	Hal_TriggerRFThermalMeter(pAdapter);

+	rtw_msleep_os(1000);

+	*value = Hal_ReadRFThermalMeter(pAdapter);

+#endif

+}

+

+void Hal_SetSingleCarrierTx(PADAPTER pAdapter, u8 bStart)

+{

+    HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);

+	pAdapter->mppriv.MptCtx.bSingleCarrier = bStart;

+	if (bStart)// Start Single Carrier.

+	{

+		RT_TRACE(_module_mp_,_drv_alert_, ("SetSingleCarrierTx: test start\n"));

+		// 1. if OFDM block on?

+		if(!read_bbreg(pAdapter, rFPGA0_RFMOD, bOFDMEn))

+			write_bbreg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bEnable);//set OFDM block on

+

+		{

+		// 2. set CCK test mode off, set to CCK normal mode

+		write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, bDisable);

+		// 3. turn on scramble setting

+		write_bbreg(pAdapter, rCCK0_System, bCCKScramble, bEnable);

+         }

+		// 4. Turn On Single Carrier Tx and turn off the other test modes.

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bEnable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+#ifdef CONFIG_RTL8192C

+		// 5. Disable TX power saving at STF & LLTF

+		write_bbreg(pAdapter, rOFDM1_LSTF, BIT22, 1);

+#endif

+		//for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000500);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000500);

+		

+	}

+	else// Stop Single Carrier.

+	{

+		RT_TRACE(_module_mp_,_drv_alert_, ("SetSingleCarrierTx: test stop\n"));

+

+		// Turn off all test modes.

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+#ifdef CONFIG_RTL8192C

+		// Cancel disable TX power saving at STF&LLTF

+		write_bbreg(pAdapter, rOFDM1_LSTF, BIT22, 0);

+#endif

+		//Delay 10 ms //delay_ms(10);

+		rtw_msleep_os(10);

+

+		//BB Reset

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x0);

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x1);

+

+		//Stop for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000100);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000100);

+		

+	}

+}

+

+

+void Hal_SetSingleToneTx(PADAPTER pAdapter, u8 bStart)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	BOOLEAN		is92C = IS_92C_SERIAL(pHalData->VersionID);

+

+	u8 rfPath;

+	u32              reg58 = 0x0;

+	switch (pAdapter->mppriv.antenna_tx)

+	{

+		case ANTENNA_A:

+		default:

+			rfPath = RF_PATH_A;

+			break;

+		case ANTENNA_B:

+			rfPath = RF_PATH_B;

+			break;

+		case ANTENNA_C:

+			rfPath = RF_PATH_C;

+			break;

+	}

+

+	pAdapter->mppriv.MptCtx.bSingleTone = bStart;

+	if (bStart)// Start Single Tone.

+	{

+		RT_TRACE(_module_mp_,_drv_alert_, ("SetSingleToneTx: test start\n"));

+		{   // <20120326, Kordan> To amplify the power of tone for Xtal calibration. (asked by Edlu)

+            if (IS_HARDWARE_TYPE_8188E(pAdapter)) 

+            {

+                reg58 = PHY_QueryRFReg(pAdapter, RF_PATH_A, LNA_Low_Gain_3, bRFRegOffsetMask);

+                reg58 &= 0xFFFFFFF0;

+                reg58 += 2;

+                PHY_SetRFReg(pAdapter, RF_PATH_A, LNA_Low_Gain_3, bRFRegOffsetMask, reg58);

+            }

+		PHY_SetBBReg(pAdapter, rFPGA0_RFMOD, bCCKEn, 0x0);

+		PHY_SetBBReg(pAdapter, rFPGA0_RFMOD, bOFDMEn, 0x0);

+        }

+

+		if (is92C)

+       		 {

+			_write_rfreg(pAdapter, RF_PATH_A, 0x21, BIT19, 0x01);

+			rtw_usleep_os(100);

+			if (rfPath == RF_PATH_A)

+				write_rfreg(pAdapter, RF_PATH_B, 0x00, 0x10000); // PAD all on.

+			else if (rfPath == RF_PATH_B)

+				write_rfreg(pAdapter, RF_PATH_A, 0x00, 0x10000); // PAD all on.

+			write_rfreg(pAdapter, rfPath, 0x00, 0x2001f); // PAD all on.

+			rtw_usleep_os(100);

+		} 

+		else

+		{

+			write_rfreg(pAdapter, rfPath, 0x21, 0xd4000);

+			rtw_usleep_os(100);

+			write_rfreg(pAdapter, rfPath, 0x00, 0x2001f); // PAD all on.

+			rtw_usleep_os(100);

+		}

+

+		//for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000500);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000500);

+		

+	}

+	else// Stop Single Tone.

+	{

+			RT_TRACE(_module_mp_,_drv_alert_, ("SetSingleToneTx: test stop\n"));

+			

+	 	{   // <20120326, Kordan> To amplify the power of tone for Xtal calibration. (asked by Edlu)

+            // <20120326, Kordan> Only in single tone mode. (asked by Edlu)

+            if (IS_HARDWARE_TYPE_8188E(pAdapter)) 

+            {

+                reg58 = PHY_QueryRFReg(pAdapter, RF_PATH_A, LNA_Low_Gain_3, bRFRegOffsetMask);

+                reg58 &= 0xFFFFFFF0;

+                PHY_SetRFReg(pAdapter, RF_PATH_A, LNA_Low_Gain_3, bRFRegOffsetMask, reg58);

+            }

+	

+		write_bbreg(pAdapter, rFPGA0_RFMOD, bCCKEn, 0x1);

+		write_bbreg(pAdapter, rFPGA0_RFMOD, bOFDMEn, 0x1);

+		}

+		if (is92C) {

+			_write_rfreg(pAdapter, RF_PATH_A, 0x21, BIT19, 0x00);

+			rtw_usleep_os(100);

+			write_rfreg(pAdapter, RF_PATH_A, 0x00, 0x32d75); // PAD all on.

+			write_rfreg(pAdapter, RF_PATH_B, 0x00, 0x32d75); // PAD all on.

+			rtw_usleep_os(100);

+		} else {

+			write_rfreg(pAdapter, rfPath, 0x21, 0x54000);

+			rtw_usleep_os(100);

+			write_rfreg(pAdapter, rfPath, 0x00, 0x30000); // PAD all on.

+			rtw_usleep_os(100);

+		}

+

+		//Stop for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000100);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000100);

+		

+	}

+	

+}

+

+

+

+void Hal_SetCarrierSuppressionTx(PADAPTER pAdapter, u8 bStart)

+{

+	pAdapter->mppriv.MptCtx.bCarrierSuppression = bStart;

+	if (bStart) // Start Carrier Suppression.

+	{

+		RT_TRACE(_module_mp_,_drv_alert_, ("SetCarrierSuppressionTx: test start\n"));

+		//if(pMgntInfo->dot11CurrentWirelessMode == WIRELESS_MODE_B)

+		if (pAdapter->mppriv.rateidx <= MPT_RATE_11M)

+		  {

+			// 1. if CCK block on?

+			if(!read_bbreg(pAdapter, rFPGA0_RFMOD, bCCKEn))

+				write_bbreg(pAdapter, rFPGA0_RFMOD, bCCKEn, bEnable);//set CCK block on

+

+			//Turn Off All Test Mode

+			write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable);

+			write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable);

+			write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+

+			write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, 0x2);    //transmit mode

+			write_bbreg(pAdapter, rCCK0_System, bCCKScramble, 0x0);  //turn off scramble setting

+

+			//Set CCK Tx Test Rate

+			//PHY_SetBBReg(pAdapter, rCCK0_System, bCCKTxRate, pMgntInfo->ForcedDataRate);

+			write_bbreg(pAdapter, rCCK0_System, bCCKTxRate, 0x0);    //Set FTxRate to 1Mbps

+		}

+

+		//for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000500);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000500);

+		

+	}

+	else// Stop Carrier Suppression.

+	{

+		RT_TRACE(_module_mp_,_drv_alert_, ("SetCarrierSuppressionTx: test stop\n"));

+		//if(pMgntInfo->dot11CurrentWirelessMode == WIRELESS_MODE_B)

+		if (pAdapter->mppriv.rateidx <= MPT_RATE_11M ) {

+			write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, 0x0);    //normal mode

+			write_bbreg(pAdapter, rCCK0_System, bCCKScramble, 0x1);  //turn on scramble setting

+

+			//BB Reset

+			write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x0);

+			write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x1);

+		}

+

+		//Stop for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000100);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000100);

+		

+	}

+	//DbgPrint("\n MPT_ProSetCarrierSupp() is finished. \n");

+}

+

+void Hal_SetCCKContinuousTx(PADAPTER pAdapter, u8 bStart)

+{

+	u32 cckrate;

+

+	if (bStart)

+	{

+		RT_TRACE(_module_mp_, _drv_alert_,

+			 ("SetCCKContinuousTx: test start\n"));

+

+		// 1. if CCK block on?

+		if(!read_bbreg(pAdapter, rFPGA0_RFMOD, bCCKEn))

+			write_bbreg(pAdapter, rFPGA0_RFMOD, bCCKEn, bEnable);//set CCK block on

+

+		//Turn Off All Test Mode

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+		//Set CCK Tx Test Rate

+		#if 0

+		switch(pAdapter->mppriv.rateidx)

+		{

+			case 2:

+				cckrate = 0;

+				break;

+			case 4:

+				cckrate = 1;

+				break;

+			case 11:

+				cckrate = 2;

+				break;

+			case 22:

+				cckrate = 3;

+				break;

+			default:

+				cckrate = 0;

+				break;

+		}

+		#else

+		cckrate  = pAdapter->mppriv.rateidx;

+		#endif

+		write_bbreg(pAdapter, rCCK0_System, bCCKTxRate, cckrate);

+		write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, 0x2);	//transmit mode

+		write_bbreg(pAdapter, rCCK0_System, bCCKScramble, bEnable);	//turn on scramble setting

+

+#ifdef CONFIG_RTL8192C

+		// Patch for CCK 11M waveform

+		if (cckrate == MPT_RATE_1M)

+			write_bbreg(pAdapter, 0xA71, BIT(6), bDisable);

+		else

+			write_bbreg(pAdapter, 0xA71, BIT(6), bEnable);

+#endif

+		//for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000500);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000500);

+

+	}

+	else {

+		RT_TRACE(_module_mp_, _drv_info_,

+			 ("SetCCKContinuousTx: test stop\n"));

+

+		write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, 0x0);	//normal mode

+		write_bbreg(pAdapter, rCCK0_System, bCCKScramble, bEnable);	//turn on scramble setting

+

+		//BB Reset

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x0);

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x1);

+

+		//Stop for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000100);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000100);

+	}

+

+	pAdapter->mppriv.MptCtx.bCckContTx = bStart;

+	pAdapter->mppriv.MptCtx.bOfdmContTx = _FALSE;

+}/* mpt_StartCckContTx */

+

+void Hal_SetOFDMContinuousTx(PADAPTER pAdapter, u8 bStart)

+{

+    HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+

+	if (bStart) {

+		RT_TRACE(_module_mp_, _drv_info_, ("SetOFDMContinuousTx: test start\n"));

+		// 1. if OFDM block on?

+		if(!read_bbreg(pAdapter, rFPGA0_RFMOD, bOFDMEn))

+			write_bbreg(pAdapter, rFPGA0_RFMOD, bOFDMEn, bEnable);//set OFDM block on

+        {

+

+		// 2. set CCK test mode off, set to CCK normal mode

+		write_bbreg(pAdapter, rCCK0_System, bCCKBBMode, bDisable);

+

+		// 3. turn on scramble setting

+		write_bbreg(pAdapter, rCCK0_System, bCCKScramble, bEnable);

+        }

+		// 4. Turn On Continue Tx and turn off the other test modes.

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bEnable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+

+		//for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000500);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000500);

+		

+	} else {

+		RT_TRACE(_module_mp_,_drv_info_, ("SetOFDMContinuousTx: test stop\n"));

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMContinueTx, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleCarrier, bDisable);

+		write_bbreg(pAdapter, rOFDM1_LSTF, bOFDMSingleTone, bDisable);

+		//Delay 10 ms

+		rtw_msleep_os(10);

+		//BB Reset

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x0);

+		write_bbreg(pAdapter, rPMAC_Reset, bBBResetB, 0x1);

+

+		//Stop for dynamic set Power index.

+		write_bbreg(pAdapter, rFPGA0_XA_HSSIParameter1, bMaskDWord, 0x01000100);

+		write_bbreg(pAdapter, rFPGA0_XB_HSSIParameter1, bMaskDWord, 0x01000100);

+	}

+

+	pAdapter->mppriv.MptCtx.bCckContTx = _FALSE;

+	pAdapter->mppriv.MptCtx.bOfdmContTx = bStart;

+}/* mpt_StartOfdmContTx */

+

+void Hal_SetContinuousTx(PADAPTER pAdapter, u8 bStart)

+{

+#if 0

+	// ADC turn off [bit24-21] adc port0 ~ port1

+	if (bStart) {

+		write_bbreg(pAdapter, rRx_Wait_CCCA, read_bbreg(pAdapter, rRx_Wait_CCCA) & 0xFE1FFFFF);

+		rtw_usleep_os(100);

+	}

+#endif

+	RT_TRACE(_module_mp_, _drv_info_,

+		 ("SetContinuousTx: rate:%d\n", pAdapter->mppriv.rateidx));

+

+	pAdapter->mppriv.MptCtx.bStartContTx = bStart;

+	if (pAdapter->mppriv.rateidx <= MPT_RATE_11M)

+	{

+		Hal_SetCCKContinuousTx(pAdapter, bStart);

+	}

+	else if ((pAdapter->mppriv.rateidx >= MPT_RATE_6M) &&

+		 (pAdapter->mppriv.rateidx <= MPT_RATE_MCS15))

+	{

+		Hal_SetOFDMContinuousTx(pAdapter, bStart);

+	}

+#if 0

+	// ADC turn on [bit24-21] adc port0 ~ port1

+	if (!bStart) {

+		write_bbreg(pAdapter, rRx_Wait_CCCA, read_bbreg(pAdapter, rRx_Wait_CCCA) | 0x01E00000);

+	}

+#endif

+}

+

+#endif // CONFIG_MP_INCLUDE

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_phycfg.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_phycfg.c
new file mode 100644
index 00000000..b4445d23
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_phycfg.c
@@ -0,0 +1,2302 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+#define _RTL8188E_PHYCFG_C_

+

+#include <drv_types.h>

+#include <rtl8188e_hal.h>

+

+

+/*---------------------------Define Local Constant---------------------------*/

+/* Channel switch:The size of command tables for switch channel*/

+#define MAX_PRECMD_CNT 16

+#define MAX_RFDEPENDCMD_CNT 16

+#define MAX_POSTCMD_CNT 16

+

+#define MAX_DOZE_WAITING_TIMES_9x 64

+

+/*---------------------------Define Local Constant---------------------------*/

+

+

+/*------------------------Define global variable-----------------------------*/

+

+/*------------------------Define local variable------------------------------*/

+

+

+/*--------------------Define export function prototype-----------------------*/

+// Please refer to header file

+/*--------------------Define export function prototype-----------------------*/

+

+/*----------------------------Function Body----------------------------------*/

+//

+// 1. BB register R/W API

+//

+

+#if(SIC_ENABLE == 1)

+static BOOLEAN

+sic_IsSICReady(

+	IN	PADAPTER	Adapter

+	)

+{

+	BOOLEAN		bRet=_FALSE;

+	u32		retryCnt=0;

+	u8		sic_cmd=0xff;

+

+	while(1)

+	{		

+		if(retryCnt++ >= SIC_MAX_POLL_CNT)

+		{

+			//RTPRINT(FPHY, (PHY_SICR|PHY_SICW), ("[SIC], sic_IsSICReady() return FALSE\n"));

+			return _FALSE;

+		}

+

+		//if(RT_SDIO_CANNOT_IO(Adapter))

+		//	return _FALSE;

+

+		sic_cmd = rtw_read8(Adapter, SIC_CMD_REG);

+		//sic_cmd = PlatformEFIORead1Byte(Adapter, SIC_CMD_REG);

+#if(SIC_HW_SUPPORT == 1)

+		sic_cmd &= 0xf0;	// [7:4]

+#endif

+		//RTPRINT(FPHY, (PHY_SICR|PHY_SICW), ("[SIC], sic_IsSICReady(), readback 0x%x=0x%x\n", SIC_CMD_REG, sic_cmd));

+		if(sic_cmd == SIC_CMD_READY)

+			return _TRUE;

+		else

+		{

+			rtw_msleep_os(1);

+			//delay_ms(1);

+		}

+	}

+

+	return bRet;

+}

+

+/*

+u32

+sic_CalculateBitShift(

+	u32 BitMask

+	)

+{

+	u32 i;

+

+	for(i=0; i<=31; i++)

+	{

+		if ( ((BitMask>>i) &  0x1 ) == 1)

+			break;

+	}

+

+	return (i);

+}

+*/

+

+static u32

+sic_Read4Byte(

+	PVOID		Adapter,

+	u32		offset

+	)

+{

+	u32	u4ret=0xffffffff;

+#if RTL8188E_SUPPORT == 1

+	u8	retry = 0;

+#endif

+

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], sic_Read4Byte(): read offset(%#x)\n", offset));

+	

+	if(sic_IsSICReady(Adapter))

+	{

+#if(SIC_HW_SUPPORT == 1)

+		rtw_write8(Adapter, SIC_CMD_REG, SIC_CMD_PREREAD);

+		//PlatformEFIOWrite1Byte(Adapter, SIC_CMD_REG, SIC_CMD_PREREAD);

+		//RTPRINT(FPHY, PHY_SICR, ("write cmdreg 0x%x = 0x%x\n", SIC_CMD_REG, SIC_CMD_PREREAD));

+#endif

+		rtw_write8(Adapter, SIC_ADDR_REG, (u8)(offset&0xff));

+		//PlatformEFIOWrite1Byte(Adapter, SIC_ADDR_REG, (u1Byte)(offset&0xff));

+		//RTPRINT(FPHY, PHY_SICR, ("write 0x%x = 0x%x\n", SIC_ADDR_REG, (u1Byte)(offset&0xff)));

+		rtw_write8(Adapter, SIC_ADDR_REG+1, (u8)((offset&0xff00)>>8));

+		//PlatformEFIOWrite1Byte(Adapter, SIC_ADDR_REG+1, (u1Byte)((offset&0xff00)>>8));

+		//RTPRINT(FPHY, PHY_SICR, ("write 0x%x = 0x%x\n", SIC_ADDR_REG+1, (u1Byte)((offset&0xff00)>>8)));

+		rtw_write8(Adapter, SIC_CMD_REG, SIC_CMD_READ);

+		//PlatformEFIOWrite1Byte(Adapter, SIC_CMD_REG, SIC_CMD_READ);

+		//RTPRINT(FPHY, PHY_SICR, ("write cmdreg 0x%x = 0x%x\n", SIC_CMD_REG, SIC_CMD_READ));

+

+#if RTL8188E_SUPPORT == 1

+		retry = 4;

+		while(retry--){			

+			rtw_udelay_os(50);

+			//PlatformStallExecution(50);

+		}

+#else

+		rtw_udelay_os(200);

+		//PlatformStallExecution(200);

+#endif

+

+		if(sic_IsSICReady(Adapter))

+		{

+			u4ret = rtw_read32(Adapter, SIC_DATA_REG);

+			//u4ret = PlatformEFIORead4Byte(Adapter, SIC_DATA_REG);

+			//RTPRINT(FPHY, PHY_SICR, ("read 0x%x = 0x%x\n", SIC_DATA_REG, u4ret));

+			//DbgPrint("<===Read 0x%x = 0x%x\n", offset, u4ret);

+		}

+	}

+	

+	return u4ret;

+}

+

+static VOID

+sic_Write4Byte(

+	PVOID		Adapter,

+	u32		offset,

+	u32		data

+	)

+{

+#if RTL8188E_SUPPORT == 1

+	u8	retry = 6;

+#endif

+	//DbgPrint("=>Write 0x%x = 0x%x\n", offset, data);

+	//RTPRINT(FPHY, PHY_SICW, ("[SIC], sic_Write4Byte(): write offset(%#x)=0x%x\n", offset, data));

+	if(sic_IsSICReady(Adapter))

+	{

+#if(SIC_HW_SUPPORT == 1)

+		rtw_write8(Adapter, SIC_CMD_REG, SIC_CMD_PREWRITE);

+		//PlatformEFIOWrite1Byte(Adapter, SIC_CMD_REG, SIC_CMD_PREWRITE);

+		//RTPRINT(FPHY, PHY_SICW, ("write data 0x%x = 0x%x\n", SIC_CMD_REG, SIC_CMD_PREWRITE));

+#endif

+		rtw_write8(Adapter, SIC_ADDR_REG, (u8)(offset&0xff));

+		//PlatformEFIOWrite1Byte(Adapter, SIC_ADDR_REG, (u1Byte)(offset&0xff));

+		//RTPRINT(FPHY, PHY_SICW, ("write 0x%x=0x%x\n", SIC_ADDR_REG, (u1Byte)(offset&0xff)));

+		rtw_write8(Adapter, SIC_ADDR_REG+1, (u8)((offset&0xff00)>>8));

+		//PlatformEFIOWrite1Byte(Adapter, SIC_ADDR_REG+1, (u1Byte)((offset&0xff00)>>8));

+		//RTPRINT(FPHY, PHY_SICW, ("write 0x%x=0x%x\n", (SIC_ADDR_REG+1), (u1Byte)((offset&0xff00)>>8)));

+		rtw_write32(Adapter, SIC_DATA_REG, (u32)data);

+		//PlatformEFIOWrite4Byte(Adapter, SIC_DATA_REG, (u4Byte)data);

+		//RTPRINT(FPHY, PHY_SICW, ("write data 0x%x = 0x%x\n", SIC_DATA_REG, data));

+		rtw_write8(Adapter, SIC_CMD_REG, SIC_CMD_WRITE);

+		//PlatformEFIOWrite1Byte(Adapter, SIC_CMD_REG, SIC_CMD_WRITE);

+		//RTPRINT(FPHY, PHY_SICW, ("write data 0x%x = 0x%x\n", SIC_CMD_REG, SIC_CMD_WRITE));

+#if RTL8188E_SUPPORT == 1

+		while(retry--){

+			rtw_udelay_os(50);

+			//PlatformStallExecution(50);

+		}

+#else

+		rtw_udelay_os(150);

+		//PlatformStallExecution(150);

+#endif

+

+	}

+}

+//============================================================

+// extern function

+//============================================================

+static VOID

+SIC_SetBBReg(

+	IN	PADAPTER	Adapter,

+	IN	u32		RegAddr,

+	IN	u32		BitMask,

+	IN	u32		Data

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u32			OriginalValue, BitShift;

+	u16			BBWaitCounter = 0;

+

+	//RTPRINT(FPHY, PHY_SICW, ("[SIC], SIC_SetBBReg() start\n"));

+/*

+	while(PlatformAtomicExchange(&pHalData->bChangeBBInProgress, _TRUE) == _TRUE)

+	{

+		BBWaitCounter ++;

+		delay_ms(10); // 1 ms

+

+		if((BBWaitCounter > 100) || RT_CANNOT_IO(Adapter))

+		{// Wait too long, return FALSE to avoid to be stuck here.

+			RTPRINT(FPHY, PHY_SICW, ("[SIC], SIC_SetBBReg(), Fail to set BB offset(%#x)!!, WaitCnt(%d)\n", RegAddr, BBWaitCounter));

+			return;

+		}		

+	}

+*/

+	//

+	// Critical section start

+	// 

+	

+	//RTPRINT(FPHY, PHY_SICW, ("[SIC], SIC_SetBBReg(), mask=0x%x, addr[0x%x]=0x%x\n", BitMask, RegAddr, Data));

+

+	if(BitMask!= bMaskDWord){//if not "double word" write

+		OriginalValue = sic_Read4Byte(Adapter, RegAddr);

+		//BitShift = sic_CalculateBitShift(BitMask);

+		BitShift = PHY_CalculateBitShift(BitMask);		

+		Data = (((OriginalValue) & (~BitMask)) | (Data << BitShift));

+	}

+

+	sic_Write4Byte(Adapter, RegAddr, Data);

+

+	//PlatformAtomicExchange(&pHalData->bChangeBBInProgress, _FALSE);

+	//RTPRINT(FPHY, PHY_SICW, ("[SIC], SIC_SetBBReg() end\n"));

+}

+

+static u32

+SIC_QueryBBReg(

+	IN	PADAPTER	Adapter,

+	IN	u32		RegAddr,

+	IN	u32		BitMask

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u32			ReturnValue = 0, OriginalValue, BitShift;

+	u16			BBWaitCounter = 0;

+

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_QueryBBReg() start\n"));

+

+/*

+	while(PlatformAtomicExchange(&pHalData->bChangeBBInProgress, _TRUE) == _TRUE)

+	{

+		BBWaitCounter ++;

+		delay_ms(10); // 10 ms

+

+		if((BBWaitCounter > 100) || RT_CANNOT_IO(Adapter))

+		{// Wait too long, return FALSE to avoid to be stuck here.

+			RTPRINT(FPHY, PHY_SICW, ("[SIC], SIC_QueryBBReg(), Fail to query BB offset(%#x)!!, WaitCnt(%d)\n", RegAddr, BBWaitCounter));

+			return ReturnValue;

+		}		

+	}

+*/

+	OriginalValue = sic_Read4Byte(Adapter, RegAddr);

+	//BitShift = sic_CalculateBitShift(BitMask);

+	BitShift = PHY_CalculateBitShift(BitMask);

+	ReturnValue = (OriginalValue & BitMask) >> BitShift;

+

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_QueryBBReg(), 0x%x=0x%x\n", RegAddr, OriginalValue));

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_QueryBBReg() end\n"));

+

+	//PlatformAtomicExchange(&pHalData->bChangeBBInProgress, _FALSE);	

+	return (ReturnValue);

+}

+

+VOID

+SIC_Init(

+	IN	PADAPTER	Adapter

+	)

+{

+	// Here we need to write 0x1b8~0x1bf = 0 after fw is downloaded

+	// because for 8723E at beginning 0x1b8=0x1e, that will cause

+	// sic always not be ready

+#if(SIC_HW_SUPPORT == 1)

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_Init(), write 0x%x = 0x%x\n", 

+	//	SIC_INIT_REG, SIC_INIT_VAL));

+	rtw_write8(Adapter, SIC_INIT_REG, SIC_INIT_VAL);

+	//PlatformEFIOWrite1Byte(Adapter, SIC_INIT_REG, SIC_INIT_VAL);

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_Init(), write 0x%x = 0x%x\n", 

+	//	SIC_CMD_REG, SIC_CMD_INIT));

+	rtw_write8(Adapter, SIC_CMD_REG, SIC_CMD_INIT);

+	//PlatformEFIOWrite1Byte(Adapter, SIC_CMD_REG, SIC_CMD_INIT);

+#else

+	//RTPRINT(FPHY, PHY_SICR, ("[SIC], SIC_Init(), write 0x1b8~0x1bf = 0x0\n"));

+	rtw_write32(Adapter, SIC_CMD_REG, 0);

+	//PlatformEFIOWrite4Byte(Adapter, SIC_CMD_REG, 0);

+	rtw_write32(Adapter, SIC_CMD_REG+4, 0);

+	//PlatformEFIOWrite4Byte(Adapter, SIC_CMD_REG+4, 0);

+#endif

+}

+

+static BOOLEAN

+SIC_LedOff(

+	IN	PADAPTER	Adapter

+	)

+{

+	// When SIC is enabled, led pin will be used as debug pin,

+	// so don't execute led function when SIC is enabled.

+	return _TRUE;

+}

+#endif

+

+/**

+* Function:	PHY_QueryBBReg

+*

+* OverView:	Read "sepcific bits" from BB register

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u4Byte			RegAddr,		//The target address to be readback

+*			u4Byte			BitMask		//The target bit position in the target address

+*										//to be readback

+* Output:	None

+* Return:		u4Byte			Data			//The readback register value

+* Note:		This function is equal to "GetRegSetting" in PHY programming guide

+*/

+u32

+PHY_QueryBBReg8188E(

+	IN	PADAPTER	Adapter,

+	IN	u32		RegAddr,

+	IN	u32		BitMask

+	)

+{

+  	u32	ReturnValue = 0, OriginalValue, BitShift;

+	u16	BBWaitCounter = 0;

+

+#if (DISABLE_BB_RF == 1)

+	return 0;

+#endif

+

+#if(SIC_ENABLE == 1)

+	return SIC_QueryBBReg(Adapter, RegAddr, BitMask);

+#endif

+

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("--->PHY_QueryBBReg(): RegAddr(%#lx), BitMask(%#lx)\n", RegAddr, BitMask));

+

+	OriginalValue = rtw_read32(Adapter, RegAddr);

+	BitShift = PHY_CalculateBitShift(BitMask);

+	ReturnValue = (OriginalValue & BitMask) >> BitShift;

+

+	//RTPRINT(FPHY, PHY_BBR, ("BBR MASK=0x%lx Addr[0x%lx]=0x%lx\n", BitMask, RegAddr, OriginalValue));

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("<---PHY_QueryBBReg(): RegAddr(%#lx), BitMask(%#lx), OriginalValue(%#lx)\n", RegAddr, BitMask, OriginalValue));

+

+	return (ReturnValue);

+

+}

+

+

+/**

+* Function:	PHY_SetBBReg

+*

+* OverView:	Write "Specific bits" to BB register (page 8~)

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u4Byte			RegAddr,		//The target address to be modified

+*			u4Byte			BitMask		//The target bit position in the target address

+*										//to be modified

+*			u4Byte			Data			//The new register value in the target bit position

+*										//of the target address

+*

+* Output:	None

+* Return:		None

+* Note:		This function is equal to "PutRegSetting" in PHY programming guide

+*/

+

+VOID

+PHY_SetBBReg8188E(

+	IN	PADAPTER	Adapter,

+	IN	u32		RegAddr,

+	IN	u32		BitMask,

+	IN	u32		Data

+	)

+{

+	HAL_DATA_TYPE	*pHalData		= GET_HAL_DATA(Adapter);

+	//u16			BBWaitCounter	= 0;

+	u32			OriginalValue, BitShift;

+

+#if (DISABLE_BB_RF == 1)

+	return;

+#endif

+

+#if(SIC_ENABLE == 1)

+	SIC_SetBBReg(Adapter, RegAddr, BitMask, Data);

+	return; 

+#endif

+

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("--->PHY_SetBBReg(): RegAddr(%#lx), BitMask(%#lx), Data(%#lx)\n", RegAddr, BitMask, Data));

+

+	if(BitMask!= bMaskDWord){//if not "double word" write

+		OriginalValue = rtw_read32(Adapter, RegAddr);

+		BitShift = PHY_CalculateBitShift(BitMask);

+		Data = ((OriginalValue & (~BitMask)) | ((Data << BitShift) & BitMask));

+	}

+

+	rtw_write32(Adapter, RegAddr, Data);

+

+	//RTPRINT(FPHY, PHY_BBW, ("BBW MASK=0x%lx Addr[0x%lx]=0x%lx\n", BitMask, RegAddr, Data));

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("<---PHY_SetBBReg(): RegAddr(%#lx), BitMask(%#lx), Data(%#lx)\n", RegAddr, BitMask, Data));

+

+}

+

+

+//

+// 2. RF register R/W API

+//

+/**

+* Function:	phy_RFSerialRead

+*

+* OverView:	Read regster from RF chips

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u8				eRFPath,	//Radio path of A/B/C/D

+*			u4Byte			Offset,		//The target address to be read

+*

+* Output:	None

+* Return:		u4Byte			reback value

+* Note:		Threre are three types of serial operations:

+*			1. Software serial write

+*			2. Hardware LSSI-Low Speed Serial Interface

+*			3. Hardware HSSI-High speed

+*			serial write. Driver need to implement (1) and (2).

+*			This function is equal to the combination of RF_ReadReg() and  RFLSSIRead()

+*/

+static	u32

+phy_RFSerialRead(

+	IN	PADAPTER		Adapter,

+	IN	u8				eRFPath,

+	IN	u32				Offset

+	)

+{

+	u32						retValue = 0;

+	HAL_DATA_TYPE				*pHalData = GET_HAL_DATA(Adapter);

+	BB_REGISTER_DEFINITION_T	*pPhyReg = &pHalData->PHYRegDef[eRFPath];

+	u32						NewOffset;

+	u32 						tmplong,tmplong2;

+	u8					RfPiEnable=0;

+#if 0

+	if(pHalData->RFChipID == RF_8225 && Offset > 0x24) //36 valid regs

+		return	retValue;

+	if(pHalData->RFChipID == RF_8256 && Offset > 0x2D) //45 valid regs

+		return	retValue;

+#endif

+	//

+	// Make sure RF register offset is correct

+	//

+	Offset &= 0xff;

+

+	//

+	// Switch page for 8256 RF IC

+	//

+	NewOffset = Offset;

+

+	// 2009/06/17 MH We can not execute IO for power save or other accident mode.

+	//if(RT_CANNOT_IO(Adapter))

+	//{

+	//	RTPRINT(FPHY, PHY_RFR, ("phy_RFSerialRead return all one\n"));

+	//	return	0xFFFFFFFF;

+	//}

+

+	// For 92S LSSI Read RFLSSIRead

+	// For RF A/B write 0x824/82c(does not work in the future)

+	// We must use 0x824 for RF A and B to execute read trigger

+	tmplong = PHY_QueryBBReg(Adapter, rFPGA0_XA_HSSIParameter2, bMaskDWord);

+	if(eRFPath == RF_PATH_A)

+		tmplong2 = tmplong;

+	else

+		tmplong2 = PHY_QueryBBReg(Adapter, pPhyReg->rfHSSIPara2, bMaskDWord);

+

+	tmplong2 = (tmplong2 & (~bLSSIReadAddress)) | (NewOffset<<23) | bLSSIReadEdge;	//T65 RF

+

+	PHY_SetBBReg(Adapter, rFPGA0_XA_HSSIParameter2, bMaskDWord, tmplong&(~bLSSIReadEdge));

+	rtw_udelay_os(10);// PlatformStallExecution(10);

+

+	PHY_SetBBReg(Adapter, pPhyReg->rfHSSIPara2, bMaskDWord, tmplong2);

+	rtw_udelay_os(100);//PlatformStallExecution(100);

+

+	//PHY_SetBBReg(Adapter, rFPGA0_XA_HSSIParameter2, bMaskDWord, tmplong|bLSSIReadEdge);

+	rtw_udelay_os(10);//PlatformStallExecution(10);

+

+	if(eRFPath == RF_PATH_A)

+		RfPiEnable = (u8)PHY_QueryBBReg(Adapter, rFPGA0_XA_HSSIParameter1, BIT8);

+	else if(eRFPath == RF_PATH_B)

+		RfPiEnable = (u8)PHY_QueryBBReg(Adapter, rFPGA0_XB_HSSIParameter1, BIT8);

+

+	if(RfPiEnable)

+	{	// Read from BBreg8b8, 12 bits for 8190, 20bits for T65 RF

+		retValue = PHY_QueryBBReg(Adapter, pPhyReg->rfLSSIReadBackPi, bLSSIReadBackData);

+		//DBG_8192C("Readback from RF-PI : 0x%x\n", retValue);

+	}

+	else

+	{	//Read from BBreg8a0, 12 bits for 8190, 20 bits for T65 RF

+		retValue = PHY_QueryBBReg(Adapter, pPhyReg->rfLSSIReadBack, bLSSIReadBackData);

+		//DBG_8192C("Readback from RF-SI : 0x%x\n", retValue);

+	}

+	//DBG_8192C("RFR-%d Addr[0x%x]=0x%x\n", eRFPath, pPhyReg->rfLSSIReadBack, retValue);

+

+	return retValue;

+

+}

+

+

+

+/**

+* Function:	phy_RFSerialWrite

+*

+* OverView:	Write data to RF register (page 8~)

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u8				eRFPath,	//Radio path of A/B/C/D

+*			u4Byte			Offset,		//The target address to be read

+*			u4Byte			Data			//The new register Data in the target bit position

+*										//of the target to be read

+*

+* Output:	None

+* Return:		None

+* Note:		Threre are three types of serial operations:

+*			1. Software serial write

+*			2. Hardware LSSI-Low Speed Serial Interface

+*			3. Hardware HSSI-High speed

+*			serial write. Driver need to implement (1) and (2).

+*			This function is equal to the combination of RF_ReadReg() and  RFLSSIRead()

+ *

+ * Note: 		  For RF8256 only

+ *			 The total count of RTL8256(Zebra4) register is around 36 bit it only employs

+ *			 4-bit RF address. RTL8256 uses "register mode control bit" (Reg00[12], Reg00[10])

+ *			 to access register address bigger than 0xf. See "Appendix-4 in PHY Configuration

+ *			 programming guide" for more details.

+ *			 Thus, we define a sub-finction for RTL8526 register address conversion

+ *		       ===========================================================

+ *			 Register Mode		RegCTL[1]		RegCTL[0]		Note

+ *								(Reg00[12])		(Reg00[10])

+ *		       ===========================================================

+ *			 Reg_Mode0				0				x			Reg 0 ~15(0x0 ~ 0xf)

+ *		       ------------------------------------------------------------------

+ *			 Reg_Mode1				1				0			Reg 16 ~30(0x1 ~ 0xf)

+ *		       ------------------------------------------------------------------

+ *			 Reg_Mode2				1				1			Reg 31 ~ 45(0x1 ~ 0xf)

+ *		       ------------------------------------------------------------------

+ *

+ *	2008/09/02	MH	Add 92S RF definition

+ *

+ *

+ *

+*/

+static	VOID

+phy_RFSerialWrite(

+	IN	PADAPTER		Adapter,

+	IN	u8				eRFPath,

+	IN	u32				Offset,

+	IN	u32				Data

+	)

+{

+	u32						DataAndAddr = 0;

+	HAL_DATA_TYPE				*pHalData = GET_HAL_DATA(Adapter);

+	BB_REGISTER_DEFINITION_T	*pPhyReg = &pHalData->PHYRegDef[eRFPath];

+	u32						NewOffset;

+

+#if 0

+	//<Roger_TODO> We should check valid regs for RF_6052 case.

+	if(pHalData->RFChipID == RF_8225 && Offset > 0x24) //36 valid regs

+		return;

+	if(pHalData->RFChipID == RF_8256 && Offset > 0x2D) //45 valid regs

+		return;

+#endif

+

+	// 2009/06/17 MH We can not execute IO for power save or other accident mode.

+	//if(RT_CANNOT_IO(Adapter))

+	//{

+	//	RTPRINT(FPHY, PHY_RFW, ("phy_RFSerialWrite stop\n"));

+	//	return;

+	//}

+

+	Offset &= 0xff;

+

+	//

+	// Shadow Update

+	//

+	//PHY_RFShadowWrite(Adapter, eRFPath, Offset, Data);

+

+	//

+	// Switch page for 8256 RF IC

+	//

+	NewOffset = Offset;

+

+	//

+	// Put write addr in [5:0]  and write data in [31:16]

+	//

+	//DataAndAddr = (Data<<16) | (NewOffset&0x3f);

+	DataAndAddr = ((NewOffset<<20) | (Data&0x000fffff)) & 0x0fffffff;	// T65 RF

+

+	//

+	// Write Operation

+	//

+	PHY_SetBBReg(Adapter, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr);

+	//RTPRINT(FPHY, PHY_RFW, ("RFW-%d Addr[0x%lx]=0x%lx\n", eRFPath, pPhyReg->rf3wireOffset, DataAndAddr));

+

+}

+

+

+/**

+* Function:	PHY_QueryRFReg

+*

+* OverView:	Query "Specific bits" to RF register (page 8~)

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u8				eRFPath,	//Radio path of A/B/C/D

+*			u4Byte			RegAddr,		//The target address to be read

+*			u4Byte			BitMask		//The target bit position in the target address

+*										//to be read

+*

+* Output:	None

+* Return:		u4Byte			Readback value

+* Note:		This function is equal to "GetRFRegSetting" in PHY programming guide

+*/

+u32

+PHY_QueryRFReg8188E(

+	IN	PADAPTER		Adapter,

+	IN	u8				eRFPath,

+	IN	u32				RegAddr,

+	IN	u32				BitMask

+	)

+{

+	u32 Original_Value, Readback_Value, BitShift;

+	//HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);

+	//u8	RFWaitCounter = 0;

+	//_irqL	irqL;

+

+#if (DISABLE_BB_RF == 1)

+	return 0;

+#endif

+

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("--->PHY_QueryRFReg(): RegAddr(%#lx), eRFPath(%#x), BitMask(%#lx)\n", RegAddr, eRFPath,BitMask));

+

+#ifdef CONFIG_USB_HCI

+	//PlatformAcquireMutex(&pHalData->mxRFOperate);

+#else

+	//_enter_critical(&pHalData->rf_lock, &irqL);

+#endif

+

+

+	Original_Value = phy_RFSerialRead(Adapter, eRFPath, RegAddr);

+

+	BitShift =  PHY_CalculateBitShift(BitMask);

+	Readback_Value = (Original_Value & BitMask) >> BitShift;

+

+#ifdef CONFIG_USB_HCI

+	//PlatformReleaseMutex(&pHalData->mxRFOperate);

+#else

+	//_exit_critical(&pHalData->rf_lock, &irqL);

+#endif

+

+

+	//RTPRINT(FPHY, PHY_RFR, ("RFR-%d MASK=0x%lx Addr[0x%lx]=0x%lx\n", eRFPath, BitMask, RegAddr, Original_Value));//BitMask(%#lx),BitMask,

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("<---PHY_QueryRFReg(): RegAddr(%#lx), eRFPath(%#x),  Original_Value(%#lx)\n",

+	//				RegAddr, eRFPath, Original_Value));

+

+	return (Readback_Value);

+}

+

+/**

+* Function:	PHY_SetRFReg

+*

+* OverView:	Write "Specific bits" to RF register (page 8~)

+*

+* Input:

+*			PADAPTER		Adapter,

+*			u8				eRFPath,	//Radio path of A/B/C/D

+*			u4Byte			RegAddr,		//The target address to be modified

+*			u4Byte			BitMask		//The target bit position in the target address

+*										//to be modified

+*			u4Byte			Data			//The new register Data in the target bit position

+*										//of the target address

+*

+* Output:	None

+* Return:		None

+* Note:		This function is equal to "PutRFRegSetting" in PHY programming guide

+*/

+VOID

+PHY_SetRFReg8188E(

+	IN	PADAPTER		Adapter,

+	IN	u8				eRFPath,

+	IN	u32				RegAddr,

+	IN	u32				BitMask,

+	IN	u32				Data

+	)

+{

+

+	//HAL_DATA_TYPE	*pHalData		= GET_HAL_DATA(Adapter);

+	//u1Byte			RFWaitCounter	= 0;

+	u32		Original_Value, BitShift;

+	//_irqL	irqL;

+

+#if (DISABLE_BB_RF == 1)

+	return;

+#endif

+

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("--->PHY_SetRFReg(): RegAddr(%#lx), BitMask(%#lx), Data(%#lx), eRFPath(%#x)\n",

+	//	RegAddr, BitMask, Data, eRFPath));

+	//RTPRINT(FINIT, INIT_RF, ("PHY_SetRFReg(): RegAddr(%#lx), BitMask(%#lx), Data(%#lx), eRFPath(%#x)\n",

+	//	RegAddr, BitMask, Data, eRFPath));

+

+

+#ifdef CONFIG_USB_HCI

+	//PlatformAcquireMutex(&pHalData->mxRFOperate);

+#else

+	//_enter_critical(&pHalData->rf_lock, &irqL);

+#endif

+

+

+	// RF data is 12 bits only

+	if (BitMask != bRFRegOffsetMask)

+	{

+		Original_Value = phy_RFSerialRead(Adapter, eRFPath, RegAddr);

+		BitShift =  PHY_CalculateBitShift(BitMask);

+		Data = ((Original_Value & (~BitMask)) | (Data<< BitShift));

+	}

+

+	phy_RFSerialWrite(Adapter, eRFPath, RegAddr, Data);

+

+

+#ifdef CONFIG_USB_HCI

+	//PlatformReleaseMutex(&pHalData->mxRFOperate);

+#else

+	//_exit_critical(&pHalData->rf_lock, &irqL);

+#endif

+

+	//PHY_QueryRFReg(Adapter,eRFPath,RegAddr,BitMask);

+	//RT_TRACE(COMP_RF, DBG_TRACE, ("<---PHY_SetRFReg(): RegAddr(%#lx), BitMask(%#lx), Data(%#lx), eRFPath(%#x)\n",

+	//		RegAddr, BitMask, Data, eRFPath));

+

+}

+

+

+//

+// 3. Initial MAC/BB/RF config by reading MAC/BB/RF txt.

+//

+

+/*-----------------------------------------------------------------------------

+ * Function:    PHY_MACConfig8192C

+ *

+ * Overview:	Condig MAC by header file or parameter file.

+ *

+ * Input:       NONE

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Revised History:

+ *  When		Who		Remark

+ *  08/12/2008	MHC		Create Version 0.

+ *

+ *---------------------------------------------------------------------------*/

+s32 PHY_MACConfig8188E(PADAPTER Adapter)

+{

+	int		rtStatus = _SUCCESS;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	s8			*pszMACRegFile;

+	s8			sz8188EMACRegFile[] = RTL8188E_PHY_MACREG;

+

+	pszMACRegFile = sz8188EMACRegFile;

+

+	//

+	// Config MAC

+	//

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+	rtStatus = phy_ConfigMACWithParaFile(Adapter, pszMACRegFile);

+	if (rtStatus == _FAIL)

+#endif

+	{

+#ifdef CONFIG_EMBEDDED_FWIMG

+		if(HAL_STATUS_FAILURE == ODM_ConfigMACWithHeaderFile(&pHalData->odmpriv))

+			rtStatus = _FAIL;

+		else

+			rtStatus = _SUCCESS;

+#endif//CONFIG_EMBEDDED_FWIMG

+	}

+

+	// 2010.07.13 AMPDU aggregation number B

+	rtw_write8(Adapter, REG_MAX_AGGR_NUM, MAX_AGGR_NUM);

+	//rtw_write8(Adapter, REG_MAX_AGGR_NUM, 0x0B); 

+

+	return rtStatus;

+

+}

+

+/*-----------------------------------------------------------------------------

+* Function:	phy_InitBBRFRegisterDefinition

+*

+* OverView:	Initialize Register definition offset for Radio Path A/B/C/D

+*

+* Input:

+*			PADAPTER		Adapter,

+*

+* Output:	None

+* Return:		None

+* Note:		The initialization value is constant and it should never be changes

+-----------------------------------------------------------------------------*/

+static	VOID

+phy_InitBBRFRegisterDefinition(

+	IN	PADAPTER		Adapter

+)

+{

+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);

+

+	// RF Interface Sowrtware Control

+	pHalData->PHYRegDef[RF_PATH_A].rfintfs = rFPGA0_XAB_RFInterfaceSW; // 16 LSBs if read 32-bit from 0x870

+	pHalData->PHYRegDef[RF_PATH_B].rfintfs = rFPGA0_XAB_RFInterfaceSW; // 16 MSBs if read 32-bit from 0x870 (16-bit for 0x872)

+	pHalData->PHYRegDef[RF_PATH_C].rfintfs = rFPGA0_XCD_RFInterfaceSW;// 16 LSBs if read 32-bit from 0x874

+	pHalData->PHYRegDef[RF_PATH_D].rfintfs = rFPGA0_XCD_RFInterfaceSW;// 16 MSBs if read 32-bit from 0x874 (16-bit for 0x876)

+

+	// RF Interface Output (and Enable)

+	pHalData->PHYRegDef[RF_PATH_A].rfintfo = rFPGA0_XA_RFInterfaceOE; // 16 LSBs if read 32-bit from 0x860

+	pHalData->PHYRegDef[RF_PATH_B].rfintfo = rFPGA0_XB_RFInterfaceOE; // 16 LSBs if read 32-bit from 0x864

+

+	// RF Interface (Output and)  Enable

+	pHalData->PHYRegDef[RF_PATH_A].rfintfe = rFPGA0_XA_RFInterfaceOE; // 16 MSBs if read 32-bit from 0x860 (16-bit for 0x862)

+	pHalData->PHYRegDef[RF_PATH_B].rfintfe = rFPGA0_XB_RFInterfaceOE; // 16 MSBs if read 32-bit from 0x864 (16-bit for 0x866)

+

+	//Addr of LSSI. Wirte RF register by driver

+	pHalData->PHYRegDef[RF_PATH_A].rf3wireOffset = rFPGA0_XA_LSSIParameter; //LSSI Parameter

+	pHalData->PHYRegDef[RF_PATH_B].rf3wireOffset = rFPGA0_XB_LSSIParameter;

+

+	// Tranceiver A~D HSSI Parameter-2

+	pHalData->PHYRegDef[RF_PATH_A].rfHSSIPara2 = rFPGA0_XA_HSSIParameter2;  //wire control parameter2

+	pHalData->PHYRegDef[RF_PATH_B].rfHSSIPara2 = rFPGA0_XB_HSSIParameter2;  //wire control parameter2

+

+	// Tranceiver LSSI Readback SI mode

+	pHalData->PHYRegDef[RF_PATH_A].rfLSSIReadBack = rFPGA0_XA_LSSIReadBack;

+	pHalData->PHYRegDef[RF_PATH_B].rfLSSIReadBack = rFPGA0_XB_LSSIReadBack;

+	pHalData->PHYRegDef[RF_PATH_C].rfLSSIReadBack = rFPGA0_XC_LSSIReadBack;

+	pHalData->PHYRegDef[RF_PATH_D].rfLSSIReadBack = rFPGA0_XD_LSSIReadBack;	

+

+	// Tranceiver LSSI Readback PI mode

+	pHalData->PHYRegDef[RF_PATH_A].rfLSSIReadBackPi = TransceiverA_HSPI_Readback;

+	pHalData->PHYRegDef[RF_PATH_B].rfLSSIReadBackPi = TransceiverB_HSPI_Readback;

+	//pHalData->PHYRegDef[RF_PATH_C].rfLSSIReadBackPi = rFPGA0_XC_LSSIReadBack;

+	//pHalData->PHYRegDef[RF_PATH_D].rfLSSIReadBackPi = rFPGA0_XD_LSSIReadBack;	

+

+}

+

+//****************************************

+// The following is for High Power PA

+//****************************************

+VOID

+phy_ConfigBBExternalPA(

+	IN	PADAPTER			Adapter

+)

+{

+#ifdef CONFIG_USB_HCI

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u16 i=0;

+	u32 temp=0;

+

+	if(!pHalData->ExternalPA)

+	{

+		return;

+	}

+

+	// 2010/10/19 MH According to Jenyu/EEChou 's opinion, we need not to execute the

+	// same code as SU. It is already updated in PHY_REG_1T_HP.txt.

+#if 0

+	PHY_SetBBReg(Adapter, 0xee8, BIT28, 1);

+	temp = PHY_QueryBBReg(Adapter, 0x860, bMaskDWord);

+	temp |= (BIT26|BIT21|BIT10|BIT5);

+	PHY_SetBBReg(Adapter, 0x860, bMaskDWord, temp);

+	PHY_SetBBReg(Adapter, 0x870, BIT10, 0);

+	PHY_SetBBReg(Adapter, 0xc80, bMaskDWord, 0x20000080);

+	PHY_SetBBReg(Adapter, 0xc88, bMaskDWord, 0x40000100);

+#endif

+

+#endif

+}

+

+

+VOID

+storePwrIndexDiffRateOffset(

+	IN	PADAPTER	Adapter,

+	IN	u32		RegAddr,

+	IN	u32		BitMask,

+	IN	u32		Data

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	

+	if(RegAddr == rTxAGC_A_Rate18_06)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][0] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][0]-TxAGC_A_Rate18_06 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][0]);

+	}

+	if(RegAddr == rTxAGC_A_Rate54_24)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][1] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][1]-TxAGC_A_Rate54_24 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][1]);

+	}

+	if(RegAddr == rTxAGC_A_CCK1_Mcs32)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][6] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][6]-TxAGC_A_CCK1_Mcs32 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][6]);

+	}

+	if(RegAddr == rTxAGC_B_CCK11_A_CCK2_11 && BitMask == 0xffffff00)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][7] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][7]-TxAGC_B_CCK11_A_CCK2_11 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][7]);

+	}

+	if(RegAddr == rTxAGC_A_Mcs03_Mcs00)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][2] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][2]-TxAGC_A_Mcs03_Mcs00 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][2]);

+	}

+	if(RegAddr == rTxAGC_A_Mcs07_Mcs04)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][3] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][3]-TxAGC_A_Mcs07_Mcs04 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][3]);

+	}

+	if(RegAddr == rTxAGC_A_Mcs11_Mcs08)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][4] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][4]-TxAGC_A_Mcs11_Mcs08 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][4]);

+	}

+	if(RegAddr == rTxAGC_A_Mcs15_Mcs12)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][5] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][5]-TxAGC_A_Mcs15_Mcs12 = 0x%x\n", pHalData->pwrGroupCnt,pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][5]);

+		if(pHalData->rf_type== RF_1T1R)

+		{

+			//printk("pwrGroupCnt = %d\n", pHalData->pwrGroupCnt);

+			pHalData->pwrGroupCnt++;			

+		}

+	}

+	if(RegAddr == rTxAGC_B_Rate18_06)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][8] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][8]-TxAGC_B_Rate18_06 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][8]);

+	}

+	if(RegAddr == rTxAGC_B_Rate54_24)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][9] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][9]-TxAGC_B_Rate54_24 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][9]);

+	}

+	if(RegAddr == rTxAGC_B_CCK1_55_Mcs32)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][14] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][14]-TxAGC_B_CCK1_55_Mcs32 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][14]);

+	}

+	if(RegAddr == rTxAGC_B_CCK11_A_CCK2_11 && BitMask == 0x000000ff)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][15] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][15]-TxAGC_B_CCK11_A_CCK2_11 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][15]);

+	}

+	if(RegAddr == rTxAGC_B_Mcs03_Mcs00)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][10] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][10]-TxAGC_B_Mcs03_Mcs00 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][10]);

+	}

+	if(RegAddr == rTxAGC_B_Mcs07_Mcs04)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][11] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][11]-TxAGC_B_Mcs07_Mcs04 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][11]);

+	}

+	if(RegAddr == rTxAGC_B_Mcs11_Mcs08)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][12] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][12]-TxAGC_B_Mcs11_Mcs08 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][12]);

+	}

+	if(RegAddr == rTxAGC_B_Mcs15_Mcs12)

+	{

+		pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][13] = Data;

+		//printk("MCSTxPowerLevelOriginalOffset[%d][13]-TxAGC_B_Mcs15_Mcs12 = 0x%x\n", pHalData->pwrGroupCnt,

+		//	pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][13]);

+		

+		if(pHalData->rf_type != RF_1T1R)

+		{

+			//printk("pwrGroupCnt = %d\n", pHalData->pwrGroupCnt);	

+			pHalData->pwrGroupCnt++;

+		}

+	}

+}

+

+

+static VOID

+phy_BB8192C_Config_1T(

+	IN PADAPTER Adapter

+	)

+{

+#if 0

+	//for path - A

+	PHY_SetBBReg(Adapter, rFPGA0_TxInfo, 0x3, 0x1);

+	PHY_SetBBReg(Adapter, rFPGA1_TxInfo, 0x0303, 0x0101);

+	PHY_SetBBReg(Adapter, 0xe74, 0x0c000000, 0x1);

+	PHY_SetBBReg(Adapter, 0xe78, 0x0c000000, 0x1);

+	PHY_SetBBReg(Adapter, 0xe7c, 0x0c000000, 0x1);

+	PHY_SetBBReg(Adapter, 0xe80, 0x0c000000, 0x1);

+	PHY_SetBBReg(Adapter, 0xe88, 0x0c000000, 0x1);

+#endif

+	//for path - B

+	PHY_SetBBReg(Adapter, rFPGA0_TxInfo, 0x3, 0x2);

+	PHY_SetBBReg(Adapter, rFPGA1_TxInfo, 0x300033, 0x200022);

+

+	// 20100519 Joseph: Add for 1T2R config. Suggested by Kevin, Jenyu and Yunan.

+	PHY_SetBBReg(Adapter, rCCK0_AFESetting, bMaskByte3, 0x45);

+	PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, bMaskByte0, 0x23);

+	PHY_SetBBReg(Adapter, rOFDM0_AGCParameter1, 0x30, 0x1);	// B path first AGC

+

+	PHY_SetBBReg(Adapter, 0xe74, 0x0c000000, 0x2);

+	PHY_SetBBReg(Adapter, 0xe78, 0x0c000000, 0x2);

+	PHY_SetBBReg(Adapter, 0xe7c, 0x0c000000, 0x2);

+	PHY_SetBBReg(Adapter, 0xe80, 0x0c000000, 0x2);

+	PHY_SetBBReg(Adapter, 0xe88, 0x0c000000, 0x2);

+

+

+}

+

+// Joseph test: new initialize order!!

+// Test only!! This part need to be re-organized.

+// Now it is just for 8256.

+static	int

+phy_BB8190_Config_HardCode(

+	IN	PADAPTER	Adapter

+	)

+{

+	//RT_ASSERT(FALSE, ("This function is not implement yet!! \n"));

+	return _SUCCESS;

+}

+

+static	int

+phy_BB8188E_Config_ParaFile(

+	IN	PADAPTER	Adapter

+	)

+{

+	EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);

+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);

+	int			rtStatus = _SUCCESS;

+

+	u8	sz8188EBBRegFile[] = RTL8188E_PHY_REG;

+	u8	sz8188EAGCTableFile[] = RTL8188E_AGC_TAB;

+	u8	sz8188EBBRegPgFile[] = RTL8188E_PHY_REG_PG;

+	u8	sz8188EBBRegMpFile[] = RTL8188E_PHY_REG_MP;

+	u8	sz8188EBBRegLimitFile[] = RTL8188E_TXPWR_LMT;

+

+	u8	*pszBBRegFile = NULL, *pszAGCTableFile = NULL, *pszBBRegPgFile = NULL, *pszBBRegMpFile=NULL,

+		*pszRFTxPwrLmtFile = NULL;

+

+

+	//RT_TRACE(COMP_INIT, DBG_TRACE, ("==>phy_BB8192S_Config_ParaFile\n"));

+

+	pszBBRegFile = sz8188EBBRegFile ;

+	pszAGCTableFile = sz8188EAGCTableFile;

+	pszBBRegPgFile = sz8188EBBRegPgFile;

+	pszBBRegMpFile = sz8188EBBRegMpFile;

+	pszRFTxPwrLmtFile = sz8188EBBRegLimitFile;

+

+	PHY_InitTxPowerLimit( Adapter );

+

+ 	if ( Adapter->registrypriv.RegEnableTxPowerLimit == 1 || 

+	     ( Adapter->registrypriv.RegEnableTxPowerLimit == 2 && pHalData->EEPROMRegulatory == 1 ) )

+ 	{

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+		if (PHY_ConfigRFWithPowerLimitTableParaFile( Adapter, pszRFTxPwrLmtFile )== _FAIL)

+#endif

+		{

+#ifdef CONFIG_EMBEDDED_FWIMG

+			if (HAL_STATUS_SUCCESS != ODM_ConfigRFWithHeaderFile(&pHalData->odmpriv, CONFIG_RF_TXPWR_LMT, (ODM_RF_RADIO_PATH_E)0))

+				rtStatus = _FAIL;

+#endif

+		}

+

+		if(rtStatus != _SUCCESS){

+			DBG_871X("phy_BB8188E_Config_ParaFile():Read Tx power limit fail!!\n");

+			goto phy_BB8190_Config_ParaFile_Fail;

+		}

+ 	}

+

+	//

+	// 1. Read PHY_REG.TXT BB INIT!!

+	//

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+	if (phy_ConfigBBWithParaFile(Adapter, pszBBRegFile, CONFIG_BB_PHY_REG) == _FAIL)

+#endif

+	{

+#ifdef CONFIG_EMBEDDED_FWIMG		

+		if(HAL_STATUS_FAILURE ==ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv, CONFIG_BB_PHY_REG))

+			rtStatus = _FAIL;

+#endif

+	}

+

+	if(rtStatus != _SUCCESS){

+		//RT_TRACE(COMP_INIT, DBG_SERIOUS, ("phy_BB8192S_Config_ParaFile():Write BB Reg Fail!!"));

+		goto phy_BB8190_Config_ParaFile_Fail;

+	}

+

+#if (MP_DRIVER == 1)

+	//

+	// 1.1 Read PHY_REG_MP.TXT BB INIT!!

+	//

+	if (Adapter->registrypriv.mp_mode == 1) {

+		//3 Read PHY_REG.TXT BB INIT!!

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+		if (phy_ConfigBBWithMpParaFile(Adapter, pszBBRegMpFile) == _FAIL)

+#endif

+		{

+#ifdef CONFIG_EMBEDDED_FWIMG

+			if (HAL_STATUS_SUCCESS != ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv, CONFIG_BB_PHY_REG_MP))

+				rtStatus = _FAIL;

+#endif

+		}

+

+		if(rtStatus != _SUCCESS){

+			DBG_871X("phy_BB8188E_Config_ParaFile():Write BB Reg MP Fail!!");

+			goto phy_BB8190_Config_ParaFile_Fail;

+		}

+	}

+#endif	// #if (MP_DRIVER == 1)

+

+	//

+	// 2. If EEPROM or EFUSE autoload OK, We must config by PHY_REG_PG.txt

+	//

+	PHY_InitTxPowerByRate( Adapter );

+	if ( ( Adapter->registrypriv.RegEnableTxPowerByRate == 1 || 

+	     ( Adapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory != 2 )  ) )

+	{

+		pHalData->pwrGroupCnt = 0;

+

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+		if (phy_ConfigBBWithPgParaFile(Adapter, pszBBRegPgFile) == _FAIL)

+#endif

+		{

+#ifdef CONFIG_EMBEDDED_FWIMG			

+			if(HAL_STATUS_FAILURE ==ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv, CONFIG_BB_PHY_REG_PG))

+				rtStatus = _FAIL;			

+#endif

+		}

+

+		if ( pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE )

+			PHY_TxPowerByRateConfiguration(Adapter);

+

+		if ( Adapter->registrypriv.RegEnableTxPowerLimit == 1 || 

+	         ( Adapter->registrypriv.RegEnableTxPowerLimit == 2 && pHalData->EEPROMRegulatory == 1 ) )

+			PHY_ConvertTxPowerLimitToPowerIndex( Adapter );

+

+		if(rtStatus != _SUCCESS){

+			DBG_871X("%s(): CONFIG_BB_PHY_REG_PG Fail!!\n",__FUNCTION__	);

+			goto phy_BB8190_Config_ParaFile_Fail;

+		}

+	}

+

+	//

+	// 3. BB AGC table Initialization

+	//

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+	if (phy_ConfigBBWithParaFile(Adapter, pszAGCTableFile, CONFIG_BB_AGC_TAB) == _FAIL)

+#endif

+	{

+#ifdef CONFIG_EMBEDDED_FWIMG

+		if(HAL_STATUS_FAILURE ==ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv,  CONFIG_BB_AGC_TAB))

+			rtStatus = _FAIL;		

+#endif

+	}

+

+	if(rtStatus != _SUCCESS){

+		//RT_TRACE(COMP_FPGA, DBG_SERIOUS, ("phy_BB8192S_Config_ParaFile():AGC Table Fail\n"));

+		goto phy_BB8190_Config_ParaFile_Fail;

+	}

+

+

+phy_BB8190_Config_ParaFile_Fail:

+

+	return rtStatus;

+}

+

+

+int

+PHY_BBConfig8188E(

+	IN	PADAPTER	Adapter

+	)

+{

+	int	rtStatus = _SUCCESS;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u32	RegVal;

+	u8	TmpU1B=0;

+	u8	value8,CrystalCap;

+

+	phy_InitBBRFRegisterDefinition(Adapter);

+

+

+	// Enable BB and RF

+	RegVal = rtw_read16(Adapter, REG_SYS_FUNC_EN);

+	rtw_write16(Adapter, REG_SYS_FUNC_EN, (u16)(RegVal|BIT13|BIT0|BIT1));

+

+	// 20090923 Joseph: Advised by Steven and Jenyu. Power sequence before init RF.

+	//rtw_write8(Adapter, REG_AFE_PLL_CTRL, 0x83);

+	//rtw_write8(Adapter, REG_AFE_PLL_CTRL+1, 0xdb);

+

+	rtw_write8(Adapter, REG_RF_CTRL, RF_EN|RF_RSTB|RF_SDMRSTB);

+

+#ifdef CONFIG_USB_HCI

+	rtw_write8(Adapter, REG_SYS_FUNC_EN, FEN_USBA | FEN_USBD | FEN_BB_GLB_RSTn | FEN_BBRSTB);

+#else

+	rtw_write8(Adapter, REG_SYS_FUNC_EN, FEN_PPLL|FEN_PCIEA|FEN_DIO_PCIE|FEN_BB_GLB_RSTn|FEN_BBRSTB);

+#endif

+

+#if 0

+#ifdef CONFIG_USB_HCI

+	//To Fix MAC loopback mode fail. Suggested by SD4 Johnny. 2010.03.23.

+	rtw_write8(Adapter, REG_LDOHCI12_CTRL, 0x0f);

+	rtw_write8(Adapter, 0x15, 0xe9);

+#endif

+

+	rtw_write8(Adapter, REG_AFE_XTAL_CTRL+1, 0x80);

+#endif

+

+#ifdef CONFIG_USB_HCI

+		//rtw_write8(Adapter, 0x15, 0xe9);

+#endif

+

+

+#ifdef CONFIG_PCI_HCI

+	// Force use left antenna by default for 88C.

+	//	if(!IS_92C_SERIAL(pHalData->VersionID) || IS_92C_1T2R(pHalData->VersionID))

+	if(Adapter->ledpriv.LedStrategy != SW_LED_MODE10)

+	{

+		RegVal = rtw_read32(Adapter, REG_LEDCFG0);

+		rtw_write32(Adapter, REG_LEDCFG0, RegVal|BIT23);

+	}

+#endif

+

+	//

+	// Config BB and AGC

+	//

+	rtStatus = phy_BB8188E_Config_ParaFile(Adapter);

+

+	// write 0x24[16:11] = 0x24[22:17] = CrystalCap

+	CrystalCap = pHalData->CrystalCap & 0x3F;

+	PHY_SetBBReg(Adapter, REG_AFE_XTAL_CTRL, 0x7ff800, (CrystalCap | (CrystalCap << 6)));

+	

+	return rtStatus;

+	

+}

+

+

+int

+PHY_RFConfig8188E(

+	IN	PADAPTER	Adapter

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	int		rtStatus = _SUCCESS;

+

+	//

+	// RF config

+	//

+	rtStatus = PHY_RF6052_Config8188E(Adapter);

+#if 0

+	switch(pHalData->rf_chip)

+	{

+		case RF_6052:

+			rtStatus = PHY_RF6052_Config(Adapter);

+			break;

+		case RF_8225:

+			rtStatus = PHY_RF8225_Config(Adapter);

+			break;

+		case RF_8256:

+			rtStatus = PHY_RF8256_Config(Adapter);

+			break;

+		case RF_8258:

+			break;

+		case RF_PSEUDO_11N:

+			rtStatus = PHY_RF8225_Config(Adapter);

+			break;

+		default: //for MacOs Warning: "RF_TYPE_MIN" not handled in switch

+			break;

+	}

+#endif

+	return rtStatus;

+}

+

+

+/*-----------------------------------------------------------------------------

+ * Function:    PHY_ConfigRFWithParaFile()

+ *

+ * Overview:    This function read RF parameters from general file format, and do RF 3-wire

+ *

+ * Input:      	PADAPTER			Adapter

+ *			ps1Byte 				pFileName

+ *			u8					eRFPath

+ *

+ * Output:      NONE

+ *

+ * Return:      RT_STATUS_SUCCESS: configuration file exist

+ *

+ * Note:		Delay may be required for RF configuration

+ *---------------------------------------------------------------------------*/

+int

+rtl8188e_PHY_ConfigRFWithParaFile(

+	IN	PADAPTER		Adapter,

+	IN	u8* 				pFileName,

+	IN	u8				eRFPath

+)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+

+	int	rtStatus = _SUCCESS;

+

+

+	return rtStatus;

+

+}

+

+//****************************************

+// The following is for High Power PA

+//****************************************

+#define HighPowerRadioAArrayLen 22

+//This is for High power PA

+u32 Rtl8192S_HighPower_RadioA_Array[HighPowerRadioAArrayLen] = {

+0x013,0x00029ea4,

+0x013,0x00025e74,

+0x013,0x00020ea4,

+0x013,0x0001ced0,

+0x013,0x00019f40,

+0x013,0x00014e70,

+0x013,0x000106a0,

+0x013,0x0000c670,

+0x013,0x000082a0,

+0x013,0x00004270,

+0x013,0x00000240,

+};

+

+int

+PHY_ConfigRFExternalPA(

+	IN	PADAPTER		Adapter,

+	IN	u8				eRFPath

+)

+{

+	int	rtStatus = _SUCCESS;

+#ifdef CONFIG_USB_HCI

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u16 i=0;

+

+	if(!pHalData->ExternalPA)

+	{

+		return rtStatus;

+	}

+

+	// 2010/10/19 MH According to Jenyu/EEChou 's opinion, we need not to execute the

+	// same code as SU. It is already updated in radio_a_1T_HP.txt.

+#if 0

+	//add for SU High Power PA

+	for(i = 0;i<HighPowerRadioAArrayLen; i=i+2)

+	{

+		RT_TRACE(COMP_INIT, DBG_LOUD, ("External PA, write RF 0x%lx=0x%lx\n", Rtl8192S_HighPower_RadioA_Array[i], Rtl8192S_HighPower_RadioA_Array[i+1]));

+		PHY_SetRFReg(Adapter, eRFPath, Rtl8192S_HighPower_RadioA_Array[i], bRFRegOffsetMask, Rtl8192S_HighPower_RadioA_Array[i+1]);

+	}

+#endif

+

+#endif

+	return rtStatus;

+}

+//****************************************

+/*-----------------------------------------------------------------------------

+ * Function:    GetTxPowerLevel8190()

+ *

+ * Overview:    This function is export to "common" moudule

+ *

+ * Input:       PADAPTER		Adapter

+ *			psByte			Power Level

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ *---------------------------------------------------------------------------*/

+VOID

+PHY_GetTxPowerLevel8188E(

+	IN	PADAPTER	Adapter,

+	OUT s32*		  	powerlevel

+	)

+{

+#if 0

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	PMGNT_INFO		pMgntInfo = &(Adapter->MgntInfo);

+	s4Byte			TxPwrDbm = 13;

+	RT_TRACE(COMP_TXAGC, DBG_LOUD, ("PHY_GetTxPowerLevel8188E(): TxPowerLevel: %#x\n", TxPwrDbm));

+

+	if ( pMgntInfo->ClientConfigPwrInDbm != UNSPECIFIED_PWR_DBM )

+		*powerlevel = pMgntInfo->ClientConfigPwrInDbm;

+	else

+		*powerlevel = TxPwrDbm;

+#endif

+}

+

+/*-----------------------------------------------------------------------------

+ * Function:    SetTxPowerLevel8190()

+ *

+ * Overview:    This function is export to "HalCommon" moudule

+ *			We must consider RF path later!!!!!!!

+ *

+ * Input:       PADAPTER		Adapter

+ *			u1Byte		channel

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *	2008/11/04	MHC		We remove EEPROM_93C56.

+ *						We need to move CCX relative code to independet file.

+ *	2009/01/21	MHC		Support new EEPROM format from SD3 requirement.

+ *

+ *---------------------------------------------------------------------------*/

+VOID

+PHY_SetTxPowerLevel8188E(

+	IN	PADAPTER	Adapter,

+	IN	u8			Channel

+	)

+{		

+	//DBG_871X("==>PHY_SetTxPowerLevel8188E()\n");

+

+	PHY_SetTxPowerLevelByPath(Adapter, Channel, ODM_RF_PATH_A);

+	

+	//DBG_871X("<==PHY_SetTxPowerLevel8188E()\n");

+}

+

+VOID

+PHY_SetTxPowerIndex_8188E(

+	IN	PADAPTER			Adapter,

+	IN	u32					PowerIndex,

+	IN	u8					RFPath,	

+	IN	u8					Rate

+	)

+{

+	if (RFPath == ODM_RF_PATH_A)

+	{

+		switch (Rate)

+		{

+			case MGN_1M:    PHY_SetBBReg(Adapter, rTxAGC_A_CCK1_Mcs32,      bMaskByte1, PowerIndex); break;

+			case MGN_2M:    PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte1, PowerIndex); break;

+			case MGN_5_5M:  PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte2, PowerIndex); break;

+			case MGN_11M:   PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte3, PowerIndex); break;

+

+			case MGN_6M:    PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte0, PowerIndex); break;

+			case MGN_9M:    PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte1, PowerIndex); break;

+			case MGN_12M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte2, PowerIndex); break;

+			case MGN_18M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte3, PowerIndex); break;

+

+			case MGN_24M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte0, PowerIndex); break;

+			case MGN_36M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte1, PowerIndex); break;

+			case MGN_48M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte2, PowerIndex); break;

+			case MGN_54M:   PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte3, PowerIndex); break;

+

+			case MGN_MCS0:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte0, PowerIndex); break;

+			case MGN_MCS1:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte1, PowerIndex); break;

+			case MGN_MCS2:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte2, PowerIndex); break;

+			case MGN_MCS3:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte3, PowerIndex); break;

+

+			case MGN_MCS4:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte0, PowerIndex); break;

+			case MGN_MCS5:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte1, PowerIndex); break;

+			case MGN_MCS6:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte2, PowerIndex); break;

+			case MGN_MCS7:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte3, PowerIndex); break;

+

+			case MGN_MCS8:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs11_Mcs08, bMaskByte0, PowerIndex); break;

+			case MGN_MCS9:  PHY_SetBBReg(Adapter, rTxAGC_A_Mcs11_Mcs08, bMaskByte1, PowerIndex); break;

+			case MGN_MCS10: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs11_Mcs08, bMaskByte2, PowerIndex); break;

+			case MGN_MCS11: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs11_Mcs08, bMaskByte3, PowerIndex); break;

+

+			case MGN_MCS12: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs15_Mcs12, bMaskByte0, PowerIndex); break;

+			case MGN_MCS13: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs15_Mcs12, bMaskByte1, PowerIndex); break;

+			case MGN_MCS14: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs15_Mcs12, bMaskByte2, PowerIndex); break;

+			case MGN_MCS15: PHY_SetBBReg(Adapter, rTxAGC_A_Mcs15_Mcs12, bMaskByte3, PowerIndex); break;

+

+			default:

+			 DBG_871X("Invalid Rate!!\n");

+			 break;				

+		}

+	}

+	else if (RFPath == ODM_RF_PATH_B)

+	{

+		switch (Rate)

+		{

+			case MGN_1M:    PHY_SetBBReg(Adapter, rTxAGC_B_CCK1_55_Mcs32, bMaskByte1, PowerIndex); break;

+			case MGN_2M:    PHY_SetBBReg(Adapter, rTxAGC_B_CCK1_55_Mcs32, bMaskByte2, PowerIndex); break;

+			case MGN_5_5M:  PHY_SetBBReg(Adapter, rTxAGC_B_CCK1_55_Mcs32, bMaskByte3, PowerIndex); break;

+			case MGN_11M:   PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte0, PowerIndex); break;

+			                                             

+			case MGN_6M:    PHY_SetBBReg(Adapter, rTxAGC_B_Rate18_06, bMaskByte0, PowerIndex); break;

+			case MGN_9M:    PHY_SetBBReg(Adapter, rTxAGC_B_Rate18_06, bMaskByte1, PowerIndex); break;

+			case MGN_12M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate18_06, bMaskByte2, PowerIndex); break;

+			case MGN_18M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate18_06, bMaskByte3, PowerIndex); break;

+			                                             

+			case MGN_24M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate54_24, bMaskByte0, PowerIndex); break;

+			case MGN_36M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate54_24, bMaskByte1, PowerIndex); break;

+			case MGN_48M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate54_24, bMaskByte2, PowerIndex); break;

+			case MGN_54M:   PHY_SetBBReg(Adapter, rTxAGC_B_Rate54_24, bMaskByte3, PowerIndex); break;

+			                                             

+			case MGN_MCS0:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs03_Mcs00, bMaskByte0, PowerIndex); break;

+			case MGN_MCS1:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs03_Mcs00, bMaskByte1, PowerIndex); break;

+			case MGN_MCS2:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs03_Mcs00, bMaskByte2, PowerIndex); break;

+			case MGN_MCS3:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs03_Mcs00, bMaskByte3, PowerIndex); break;

+			                                             

+			case MGN_MCS4:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs07_Mcs04, bMaskByte0, PowerIndex); break;

+			case MGN_MCS5:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs07_Mcs04, bMaskByte1, PowerIndex); break;

+			case MGN_MCS6:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs07_Mcs04, bMaskByte2, PowerIndex); break;

+			case MGN_MCS7:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs07_Mcs04, bMaskByte3, PowerIndex); break;

+			                                             

+			case MGN_MCS8:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs11_Mcs08, bMaskByte0, PowerIndex); break;

+			case MGN_MCS9:  PHY_SetBBReg(Adapter, rTxAGC_B_Mcs11_Mcs08, bMaskByte1, PowerIndex); break;

+			case MGN_MCS10: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs11_Mcs08, bMaskByte2, PowerIndex); break;

+			case MGN_MCS11: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs11_Mcs08, bMaskByte3, PowerIndex); break;

+			                                             

+			case MGN_MCS12: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs15_Mcs12, bMaskByte0, PowerIndex); break;

+			case MGN_MCS13: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs15_Mcs12, bMaskByte1, PowerIndex); break;

+			case MGN_MCS14: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs15_Mcs12, bMaskByte2, PowerIndex); break;

+			case MGN_MCS15: PHY_SetBBReg(Adapter, rTxAGC_B_Mcs15_Mcs12, bMaskByte3, PowerIndex); break;

+

+			default:

+			     DBG_871X("Invalid Rate!!\n");

+			     break;			

+		}

+	}

+	else

+	{

+		DBG_871X("Invalid RFPath!!\n");

+	}

+}

+

+u8

+phy_GetCurrentTxNum_8188E(

+	IN	PADAPTER	pAdapter,

+	IN	u8			Rate

+	)

+{

+	u8	tmpByte = 0;

+	u32	tmpDWord = 0;

+	u8	TxNum = RF_TX_NUM_NONIMPLEMENT;

+

+	if ( ( Rate >= MGN_MCS8 && Rate <= MGN_MCS15 ) )

+		TxNum = RF_2TX;

+	else

+		TxNum = RF_1TX;

+

+	return TxNum;

+}

+

+s8 tx_power_extra_bias(

+	IN	u8				RFPath,

+	IN	u8				Rate,	

+	IN	CHANNEL_WIDTH	BandWidth,	

+	IN	u8				Channel

+	)

+{

+	s8 bias = 0;

+

+	if (Rate == MGN_2M)

+		bias = -9;

+

+	return bias;

+}

+

+u8

+PHY_GetTxPowerIndex_8188E(

+	IN	PADAPTER		pAdapter,

+	IN	u8				RFPath,

+	IN	u8				Rate,	

+	IN	CHANNEL_WIDTH	BandWidth,	

+	IN	u8				Channel

+	)

+{

+	PHAL_DATA_TYPE pHalData = GET_HAL_DATA(pAdapter);

+	u8 base_index = 0;

+	s8 by_rate_diff = 0, txPower = 0, limit = 0, track_diff = 0, extra_bias = 0;

+	u8 txNum = phy_GetCurrentTxNum_8188E(pAdapter, Rate);

+	BOOLEAN bIn24G = _FALSE;

+

+	base_index = PHY_GetTxPowerIndexBase(pAdapter,RFPath, Rate, BandWidth, Channel, &bIn24G);

+

+	by_rate_diff = PHY_GetTxPowerByRate(pAdapter, BAND_ON_2_4G, RFPath, txNum, Rate);

+	limit = PHY_GetTxPowerLimit(pAdapter, pAdapter->registrypriv.RegPwrTblSel, (u8)(!bIn24G), pHalData->CurrentChannelBW, RFPath, Rate, pHalData->CurrentChannel);

+	by_rate_diff = by_rate_diff > limit ? limit : by_rate_diff;

+

+	track_diff = PHY_GetTxPowerTrackingOffset(pAdapter, RFPath, Rate);

+

+	extra_bias = tx_power_extra_bias(RFPath, Rate, BandWidth, Channel);

+

+	txPower = base_index + by_rate_diff + track_diff + extra_bias;

+

+	if(txPower > MAX_POWER_INDEX)

+		txPower = MAX_POWER_INDEX;

+

+	if (0)

+	DBG_871X("RF-%c ch%d TxPwrIdx = %d(0x%X) [%2u %2d %2d %2d]\n"

+		, ((RFPath==0)?'A':'B'), Channel, txPower, txPower, base_index, by_rate_diff, track_diff, extra_bias);

+

+	return (u8)txPower;	

+}

+

+//

+//	Description:

+//		Update transmit power level of all channel supported.

+//

+//	TODO:

+//		A mode.

+//	By Bruce, 2008-02-04.

+//

+BOOLEAN

+PHY_UpdateTxPowerDbm8188E(

+	IN	PADAPTER	Adapter,

+	IN	int		powerInDbm

+	)

+{

+	return _TRUE;

+}

+

+VOID

+PHY_ScanOperationBackup8188E(

+	IN	PADAPTER	Adapter,

+	IN	u8		Operation

+	)

+{

+#if 0

+	IO_TYPE	IoType;

+

+	if(!Adapter->bDriverStopped)

+	{

+		switch(Operation)

+		{

+			case SCAN_OPT_BACKUP:

+				IoType = IO_CMD_PAUSE_DM_BY_SCAN;

+				rtw_hal_set_hwreg(Adapter,HW_VAR_IO_CMD,  (pu1Byte)&IoType);

+

+				break;

+

+			case SCAN_OPT_RESTORE:

+				IoType = IO_CMD_RESUME_DM_BY_SCAN;

+				rtw_hal_set_hwreg(Adapter,HW_VAR_IO_CMD,  (pu1Byte)&IoType);

+				break;

+

+			default:

+				RT_TRACE(COMP_SCAN, DBG_LOUD, ("Unknown Scan Backup Operation. \n"));

+				break;

+		}

+	}

+#endif

+}

+void 

+phy_SpurCalibration_8188E(

+	IN	PADAPTER			Adapter

+	)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	

+	if(pHalData->CurrentChannelBW == CHANNEL_WIDTH_20 && pHalData->CurrentChannel == 13){

+		PHY_SetBBReg(Adapter, rOFDM1_CFOTracking, BIT(28), 0x1); //enable CSI Mask

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask1, BIT(26)|BIT(25), 0x3); //Fix CSI Mask Tone

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask2, BIT(26)|BIT(25), 0x0); 

+	}

+	else if(pHalData->CurrentChannelBW == CHANNEL_WIDTH_40 && pHalData->CurrentChannel == 11){

+		PHY_SetBBReg(Adapter, rOFDM1_CFOTracking, BIT(28), 0x1); //enable CSI Mask

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask1, BIT(26)|BIT(25), 0x0); 

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask2, BIT(26)|BIT(25), 0x3); //Fix CSI Mask Tone

+	}

+	else{

+		PHY_SetBBReg(Adapter, rOFDM1_CFOTracking, BIT(28), 0x0); //disable CSI Mask

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask1, BIT(26)|BIT(25), 0x0); 

+		PHY_SetBBReg(Adapter, rOFDM1_csi_fix_mask2, BIT(26)|BIT(25), 0x0); 

+	}

+

+}

+

+/*-----------------------------------------------------------------------------

+ * Function:    PHY_SetBWModeCallback8192C()

+ *

+ * Overview:    Timer callback function for SetSetBWMode

+ *

+ * Input:       	PRT_TIMER		pTimer

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Note:		(1) We do not take j mode into consideration now

+ *			(2) Will two workitem of "switch channel" and "switch channel bandwidth" run

+ *			     concurrently?

+ *---------------------------------------------------------------------------*/

+static VOID

+_PHY_SetBWMode88E(

+	IN	PADAPTER	Adapter

+)

+{

+//	PADAPTER			Adapter = (PADAPTER)pTimer->Adapter;

+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);

+	u8				regBwOpMode;

+	u8				regRRSR_RSC;

+

+	//return;

+

+	// Added it for 20/40 mhz switch time evaluation by guangan 070531

+	//u4Byte				NowL, NowH;

+	//u8Byte				BeginTime, EndTime;

+

+	/*RT_TRACE(COMP_SCAN, DBG_LOUD, ("==>PHY_SetBWModeCallback8192C()  Switch to %s bandwidth\n", \

+					pHalData->CurrentChannelBW == CHANNEL_WIDTH_20?"20MHz":"40MHz"))*/

+

+	if(pHalData->rf_chip == RF_PSEUDO_11N)

+	{

+		//pHalData->SetBWModeInProgress= _FALSE;

+		return;

+	}

+

+	// There is no 40MHz mode in RF_8225.

+	if(pHalData->rf_chip==RF_8225)

+		return;

+

+	if(Adapter->bDriverStopped)

+		return;

+

+	// Added it for 20/40 mhz switch time evaluation by guangan 070531

+	//NowL = PlatformEFIORead4Byte(Adapter, TSFR);

+	//NowH = PlatformEFIORead4Byte(Adapter, TSFR+4);

+	//BeginTime = ((u8Byte)NowH << 32) + NowL;

+

+	//3//

+	//3//<1>Set MAC register

+	//3//

+	//Adapter->HalFunc.SetBWModeHandler();

+

+	regBwOpMode = rtw_read8(Adapter, REG_BWOPMODE);

+	regRRSR_RSC = rtw_read8(Adapter, REG_RRSR+2);

+	//regBwOpMode = rtw_hal_get_hwreg(Adapter,HW_VAR_BWMODE,(pu1Byte)&regBwOpMode);

+

+	switch(pHalData->CurrentChannelBW)

+	{

+		case CHANNEL_WIDTH_20:

+			regBwOpMode |= BW_OPMODE_20MHZ;

+			   // 2007/02/07 Mark by Emily becasue we have not verify whether this register works

+			rtw_write8(Adapter, REG_BWOPMODE, regBwOpMode);

+			break;

+

+		case CHANNEL_WIDTH_40:

+			regBwOpMode &= ~BW_OPMODE_20MHZ;

+				// 2007/02/07 Mark by Emily becasue we have not verify whether this register works

+			rtw_write8(Adapter, REG_BWOPMODE, regBwOpMode);

+

+			regRRSR_RSC = (regRRSR_RSC&0x90) |(pHalData->nCur40MhzPrimeSC<<5);

+			rtw_write8(Adapter, REG_RRSR+2, regRRSR_RSC);

+			break;

+

+		default:

+			/*RT_TRACE(COMP_DBG, DBG_LOUD, ("PHY_SetBWModeCallback8192C():

+						unknown Bandwidth: %#X\n",pHalData->CurrentChannelBW));*/

+			break;

+	}

+

+	//3//

+	//3//<2>Set PHY related register

+	//3//

+	switch(pHalData->CurrentChannelBW)

+	{

+		/* 20 MHz channel*/

+		case CHANNEL_WIDTH_20:

+			PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bRFMOD, 0x0);

+			PHY_SetBBReg(Adapter, rFPGA1_RFMOD, bRFMOD, 0x0);

+			//PHY_SetBBReg(Adapter, rFPGA0_AnalogParameter2, BIT10, 1);

+

+			break;

+

+

+		/* 40 MHz channel*/

+		case CHANNEL_WIDTH_40:

+			PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bRFMOD, 0x1);

+			PHY_SetBBReg(Adapter, rFPGA1_RFMOD, bRFMOD, 0x1);

+

+			// Set Control channel to upper or lower. These settings are required only for 40MHz

+			PHY_SetBBReg(Adapter, rCCK0_System, bCCKSideBand, (pHalData->nCur40MhzPrimeSC>>1));

+			PHY_SetBBReg(Adapter, rOFDM1_LSTF, 0xC00, pHalData->nCur40MhzPrimeSC);

+			//PHY_SetBBReg(Adapter, rFPGA0_AnalogParameter2, BIT10, 0);

+

+			PHY_SetBBReg(Adapter, 0x818, (BIT26|BIT27), (pHalData->nCur40MhzPrimeSC==HAL_PRIME_CHNL_OFFSET_LOWER)?2:1);

+

+			break;

+

+

+

+		default:

+			/*RT_TRACE(COMP_DBG, DBG_LOUD, ("PHY_SetBWModeCallback8192C(): unknown Bandwidth: %#X\n"\

+						,pHalData->CurrentChannelBW));*/

+			break;

+

+	}

+	//Skip over setting of J-mode in BB register here. Default value is "None J mode". Emily 20070315

+

+	// Added it for 20/40 mhz switch time evaluation by guangan 070531

+	//NowL = PlatformEFIORead4Byte(Adapter, TSFR);

+	//NowH = PlatformEFIORead4Byte(Adapter, TSFR+4);

+	//EndTime = ((u8Byte)NowH << 32) + NowL;

+	//RT_TRACE(COMP_SCAN, DBG_LOUD, ("SetBWModeCallback8190Pci: time of SetBWMode = %I64d us!\n", (EndTime - BeginTime)));

+

+	//3<3>Set RF related register

+	switch(pHalData->rf_chip)

+	{

+		case RF_8225:

+			//PHY_SetRF8225Bandwidth(Adapter, pHalData->CurrentChannelBW);

+			break;

+

+		case RF_8256:

+			// Please implement this function in Hal8190PciPhy8256.c

+			//PHY_SetRF8256Bandwidth(Adapter, pHalData->CurrentChannelBW);

+			break;

+

+		case RF_8258:

+			// Please implement this function in Hal8190PciPhy8258.c

+			// PHY_SetRF8258Bandwidth();

+			break;

+

+		case RF_PSEUDO_11N:

+			// Do Nothing

+			break;

+

+		case RF_6052:

+			rtl8188e_PHY_RF6052SetBandwidth(Adapter, pHalData->CurrentChannelBW);

+			break;

+

+		default:

+			//RT_ASSERT(FALSE, ("Unknown RFChipID: %d\n", pHalData->RFChipID));

+			break;

+	}

+

+	//pHalData->SetBWModeInProgress= FALSE;

+

+	//RT_TRACE(COMP_SCAN, DBG_LOUD, ("<==PHY_SetBWModeCallback8192C() \n" ));

+}

+

+

+ /*-----------------------------------------------------------------------------

+ * Function:   SetBWMode8190Pci()

+ *

+ * Overview:  This function is export to "HalCommon" moudule

+ *

+ * Input:       	PADAPTER			Adapter

+ *			CHANNEL_WIDTH	Bandwidth	//20M or 40M

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Note:		We do not take j mode into consideration now

+ *---------------------------------------------------------------------------*/

+VOID

+PHY_SetBWMode8188E(

+	IN	PADAPTER					Adapter,

+	IN	CHANNEL_WIDTH	Bandwidth,	// 20M or 40M

+	IN	unsigned char	Offset		// Upper, Lower, or Don't care

+)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	CHANNEL_WIDTH 	tmpBW= pHalData->CurrentChannelBW;

+	// Modified it for 20/40 mhz switch by guangan 070531

+	//PMGNT_INFO	pMgntInfo=&Adapter->MgntInfo;

+

+	//return;

+

+	//if(pHalData->SwChnlInProgress)

+//	if(pMgntInfo->bScanInProgress)

+//	{

+//		RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SetBWMode8192C() %s Exit because bScanInProgress!\n",

+//					Bandwidth == CHANNEL_WIDTH_20?"20MHz":"40MHz"));

+//		return;

+//	}

+

+//	if(pHalData->SetBWModeInProgress)

+//	{

+//		// Modified it for 20/40 mhz switch by guangan 070531

+//		RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SetBWMode8192C() %s cancel last timer because SetBWModeInProgress!\n",

+//					Bandwidth == CHANNEL_WIDTH_20?"20MHz":"40MHz"));

+//		PlatformCancelTimer(Adapter, &pHalData->SetBWModeTimer);

+//		//return;

+//	}

+

+	//if(pHalData->SetBWModeInProgress)

+	//	return;

+

+	//pHalData->SetBWModeInProgress= TRUE;

+

+	pHalData->CurrentChannelBW = Bandwidth;

+

+#if 0

+	if(Offset==EXTCHNL_OFFSET_LOWER)

+		pHalData->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_UPPER;

+	else if(Offset==EXTCHNL_OFFSET_UPPER)

+		pHalData->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_LOWER;

+	else

+		pHalData->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_DONT_CARE;

+#else

+	pHalData->nCur40MhzPrimeSC = Offset;

+#endif

+

+	if((!Adapter->bDriverStopped) && (!Adapter->bSurpriseRemoved))

+	{

+	#if 0

+		//PlatformSetTimer(Adapter, &(pHalData->SetBWModeTimer), 0);

+	#else

+		_PHY_SetBWMode88E(Adapter);

+	#endif

+		if (IS_VENDOR_8188E_I_CUT_SERIES(Adapter)&& IS_HARDWARE_TYPE_8188ES(Adapter))

+			phy_SpurCalibration_8188E( Adapter);

+	}

+	else

+	{

+		//RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SetBWMode8192C() SetBWModeInProgress FALSE driver sleep or unload\n"));

+		//pHalData->SetBWModeInProgress= FALSE;

+		pHalData->CurrentChannelBW = tmpBW;

+	}

+	

+}

+

+

+static void _PHY_SwChnl8188E(PADAPTER Adapter, u8 channel)

+{

+	u8 eRFPath;

+	u32 param1, param2;

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+

+	if ( Adapter->bNotifyChannelChange )

+	{

+		DBG_871X( "[%s] ch = %d\n", __FUNCTION__, channel );

+	}

+

+	//s1. pre common command - CmdID_SetTxPowerLevel

+	PHY_SetTxPowerLevel8188E(Adapter, channel);

+

+	//s2. RF dependent command - CmdID_RF_WriteReg, param1=RF_CHNLBW, param2=channel

+	param1 = RF_CHNLBW;

+	param2 = channel;

+	for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)

+	{

+		pHalData->RfRegChnlVal[eRFPath] = ((pHalData->RfRegChnlVal[eRFPath] & 0xfffffc00) | param2);

+		PHY_SetRFReg(Adapter, eRFPath, param1, bRFRegOffsetMask, pHalData->RfRegChnlVal[eRFPath]);

+	}

+

+

+	//s3. post common command - CmdID_End, None

+

+}

+VOID

+PHY_SwChnl8188E(	// Call after initialization

+	IN	PADAPTER	Adapter,

+	IN	u8		channel

+	)

+{

+	//PADAPTER Adapter =  ADJUST_TO_ADAPTIVE_ADAPTER(pAdapter, _TRUE);

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+	u8	tmpchannel = pHalData->CurrentChannel;

+	BOOLEAN  bResult = _TRUE;

+

+	if(pHalData->rf_chip == RF_PSEUDO_11N)

+	{

+		//pHalData->SwChnlInProgress=FALSE;

+		return; 								//return immediately if it is peudo-phy

+	}

+

+	//if(pHalData->SwChnlInProgress)

+	//	return;

+

+	//if(pHalData->SetBWModeInProgress)

+	//	return;

+

+	//--------------------------------------------

+	switch(pHalData->CurrentWirelessMode)

+	{

+		case WIRELESS_MODE_A:

+		case WIRELESS_MODE_N_5G:

+			//RT_ASSERT((channel>14), ("WIRELESS_MODE_A but channel<=14"));

+			break;

+

+		case WIRELESS_MODE_B:

+			//RT_ASSERT((channel<=14), ("WIRELESS_MODE_B but channel>14"));

+			break;

+

+		case WIRELESS_MODE_G:

+		case WIRELESS_MODE_N_24G:

+			//RT_ASSERT((channel<=14), ("WIRELESS_MODE_G but channel>14"));

+			break;

+

+		default:

+			//RT_ASSERT(FALSE, ("Invalid WirelessMode(%#x)!!\n", pHalData->CurrentWirelessMode));

+			break;

+	}

+	//--------------------------------------------

+

+	//pHalData->SwChnlInProgress = TRUE;

+	if(channel == 0)

+		channel = 1;

+

+	pHalData->CurrentChannel=channel;

+

+	//pHalData->SwChnlStage=0;

+	//pHalData->SwChnlStep=0;

+

+	if((!Adapter->bDriverStopped) && (!Adapter->bSurpriseRemoved))

+	{

+		#if 0

+		//PlatformSetTimer(Adapter, &(pHalData->SwChnlTimer), 0);

+		#else

+		_PHY_SwChnl8188E(Adapter, channel);

+		#endif

+

+		if (IS_VENDOR_8188E_I_CUT_SERIES(Adapter)&& IS_HARDWARE_TYPE_8188ES(Adapter))

+			phy_SpurCalibration_8188E( Adapter);

+		

+

+		if(bResult)

+		{

+			//RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SwChnl8192C SwChnlInProgress TRUE schdule workitem done\n"));

+		}

+		else

+		{

+			//RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SwChnl8192C SwChnlInProgress FALSE schdule workitem error\n"));

+			//if(IS_HARDWARE_TYPE_8192SU(Adapter))

+			//{

+			//	pHalData->SwChnlInProgress = FALSE;

+				pHalData->CurrentChannel = tmpchannel;

+			//}

+		}

+

+	}

+	else

+	{

+		//RT_TRACE(COMP_SCAN, DBG_LOUD, ("PHY_SwChnl8192C SwChnlInProgress FALSE driver sleep or unload\n"));

+		//if(IS_HARDWARE_TYPE_8192SU(Adapter))

+		//{

+		//	pHalData->SwChnlInProgress = FALSE;

+			pHalData->CurrentChannel = tmpchannel;

+		//}

+	}

+}

+

+VOID

+PHY_SetSwChnlBWMode8188E(

+	IN	PADAPTER			Adapter,

+	IN	u8					channel,

+	IN	CHANNEL_WIDTH	Bandwidth,

+	IN	u8					Offset40,

+	IN	u8					Offset80

+)

+{

+	//DBG_871X("%s()===>\n",__FUNCTION__);

+

+	PHY_SwChnl8188E(Adapter, channel);

+	PHY_SetBWMode8188E(Adapter, Bandwidth, Offset40);

+

+	//DBG_871X("<==%s()\n",__FUNCTION__);

+}

+

+

+//

+//	Description:

+//		Configure H/W functionality to enable/disable Monitor mode.

+//		Note, because we possibly need to configure BB and RF in this function,

+//		so caller should in PASSIVE_LEVEL. 080118, by rcnjko.

+//

+VOID

+PHY_SetMonitorMode8192C(

+	IN	PADAPTER			pAdapter,

+	IN	BOOLEAN				bEnableMonitorMode

+	)

+{

+#if 0

+	HAL_DATA_TYPE		*pHalData	= GET_HAL_DATA(pAdapter);

+	BOOLEAN				bFilterOutNonAssociatedBSSID = FALSE;

+

+	//2 Note: we may need to stop antenna diversity.

+	if(bEnableMonitorMode)

+	{

+		bFilterOutNonAssociatedBSSID = FALSE;

+		RT_TRACE(COMP_RM, DBG_LOUD, ("PHY_SetMonitorMode8192S(): enable monitor mode\n"));

+

+		pHalData->bInMonitorMode = TRUE;

+		pAdapter->HalFunc.AllowAllDestAddrHandler(pAdapter, TRUE, TRUE);

+		rtw_hal_set_hwreg(pAdapter, HW_VAR_CHECK_BSSID, (pu1Byte)&bFilterOutNonAssociatedBSSID);

+	}

+	else

+	{

+		bFilterOutNonAssociatedBSSID = TRUE;

+		RT_TRACE(COMP_RM, DBG_LOUD, ("PHY_SetMonitorMode8192S(): disable monitor mode\n"));

+

+		pAdapter->HalFunc.AllowAllDestAddrHandler(pAdapter, FALSE, TRUE);

+		pHalData->bInMonitorMode = FALSE;

+		rtw_hal_set_hwreg(pAdapter, HW_VAR_CHECK_BSSID, (pu1Byte)&bFilterOutNonAssociatedBSSID);

+	}

+#endif

+}

+

+

+/*-----------------------------------------------------------------------------

+ * Function:	PHYCheckIsLegalRfPath8190Pci()

+ *

+ * Overview:	Check different RF type to execute legal judgement. If RF Path is illegal

+ *			We will return false.

+ *

+ * Input:		NONE

+ *

+ * Output:		NONE

+ *

+ * Return:		NONE

+ *

+ * Revised History:

+ *	When		Who		Remark

+ *	11/15/2007	MHC		Create Version 0.

+ *

+ *---------------------------------------------------------------------------*/

+BOOLEAN

+PHY_CheckIsLegalRfPath8192C(

+	IN	PADAPTER	pAdapter,

+	IN	u32	eRFPath)

+{

+//	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);

+	BOOLEAN				rtValue = _TRUE;

+

+	// NOt check RF Path now.!

+#if 0

+	if (pHalData->RF_Type == RF_1T2R && eRFPath != RF_PATH_A)

+	{

+		rtValue = FALSE;

+	}

+	if (pHalData->RF_Type == RF_1T2R && eRFPath != RF_PATH_A)

+	{

+

+	}

+#endif

+	return	rtValue;

+

+}	/* PHY_CheckIsLegalRfPath8192C */

+

+static VOID _PHY_SetRFPathSwitch(

+	IN	PADAPTER	pAdapter,

+	IN	BOOLEAN		bMain,

+	IN	BOOLEAN		is2T

+	)

+{

+	u8	u1bTmp;

+

+	if(!pAdapter->hw_init_completed)

+	{

+		u1bTmp = rtw_read8(pAdapter, REG_LEDCFG2) | BIT7;

+		rtw_write8(pAdapter, REG_LEDCFG2, u1bTmp);

+		//PHY_SetBBReg(pAdapter, REG_LEDCFG0, BIT23, 0x01);

+		PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT13, 0x01);

+	}

+

+	if(is2T)

+	{

+		if(bMain)

+			PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT5|BIT6, 0x1);	//92C_Path_A

+		else

+			PHY_SetBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT5|BIT6, 0x2);	//BT

+	}

+	else

+	{

+

+		if(bMain)

+			PHY_SetBBReg(pAdapter, rFPGA0_XA_RFInterfaceOE, 0x300, 0x2);	//Main

+		else

+			PHY_SetBBReg(pAdapter, rFPGA0_XA_RFInterfaceOE, 0x300, 0x1);	//Aux

+	}

+

+}

+

+//return value TRUE => Main; FALSE => Aux

+

+static BOOLEAN _PHY_QueryRFPathSwitch(

+	IN	PADAPTER	pAdapter,

+	IN	BOOLEAN		is2T

+	)

+{

+//	if(is2T)

+//		return _TRUE;

+

+	if(!pAdapter->hw_init_completed)

+	{

+		PHY_SetBBReg(pAdapter, REG_LEDCFG0, BIT23, 0x01);

+		PHY_SetBBReg(pAdapter, rFPGA0_XAB_RFParameter, BIT13, 0x01);

+	}

+

+	if(is2T)

+	{

+		if(PHY_QueryBBReg(pAdapter, rFPGA0_XB_RFInterfaceOE, BIT5|BIT6) == 0x01)

+			return _TRUE;

+		else

+			return _FALSE;

+	}

+	else

+	{

+		if(PHY_QueryBBReg(pAdapter, rFPGA0_XA_RFInterfaceOE, 0x300) == 0x02)

+			return _TRUE;

+		else

+			return _FALSE;

+	}

+}

+

+

+static VOID

+_PHY_DumpRFReg(IN	PADAPTER	pAdapter)

+{

+	u32 rfRegValue,rfRegOffset;

+

+	//RTPRINT(FINIT, INIT_RF, ("PHY_DumpRFReg()====>\n"));

+

+	for(rfRegOffset = 0x00;rfRegOffset<=0x30;rfRegOffset++){

+		rfRegValue = PHY_QueryRFReg(pAdapter,RF_PATH_A, rfRegOffset, bMaskDWord);

+		//RTPRINT(FINIT, INIT_RF, (" 0x%02x = 0x%08x\n",rfRegOffset,rfRegValue));

+	}

+	//RTPRINT(FINIT, INIT_RF, ("<===== PHY_DumpRFReg()\n"));

+}

+

+

+//

+// Move from phycfg.c to gen.c to be code independent later

+//

+//-------------------------Move to other DIR later----------------------------*/

+#ifdef CONFIG_USB_HCI

+

+//

+//	Description:

+// 		To dump all Tx FIFO LLT related link-list table.

+//		Added by Roger, 2009.03.10.

+//

+VOID

+DumpBBDbgPort_92CU(

+	IN	PADAPTER			Adapter

+	)

+{

+

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"));

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("BaseBand Debug Ports:\n"));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0000);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0803);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0a06);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0007);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0100);

+	PHY_SetBBReg(Adapter, 0x0a28, 0x00ff0000, 0x000f0000);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	PHY_SetBBReg(Adapter, 0x0908, 0xffff, 0x0100);

+	PHY_SetBBReg(Adapter, 0x0a28, 0x00ff0000, 0x00150000);

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xdf4, PHY_QueryBBReg(Adapter, 0x0df4, bMaskDWord)));

+

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0x800, PHY_QueryBBReg(Adapter, 0x0800, bMaskDWord)));

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0x900, PHY_QueryBBReg(Adapter, 0x0900, bMaskDWord)));

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xa00, PHY_QueryBBReg(Adapter, 0x0a00, bMaskDWord)));

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xa54, PHY_QueryBBReg(Adapter, 0x0a54, bMaskDWord)));

+	//RT_TRACE(COMP_SEND, DBG_WARNING, ("Offset[%x]: %x\n", 0xa58, PHY_QueryBBReg(Adapter, 0x0a58, bMaskDWord)));

+

+}

+#endif

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rf6052.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rf6052.c
new file mode 100644
index 00000000..21897f53
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rf6052.c
@@ -0,0 +1,348 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+/******************************************************************************

+ *

+ *

+ * Module:	rtl8192c_rf6052.c	( Source C File)

+ *

+ * Note:	Provide RF 6052 series relative API.

+ *

+ * Function:

+ *

+ * Export:

+ *

+ * Abbrev:

+ *

+ * History:

+ * Data			Who		Remark

+ *

+ * 09/25/2008	MHC		Create initial version.

+ * 11/05/2008 	MHC		Add API for tw power setting.

+ *

+ *

+******************************************************************************/

+

+#define _RTL8188E_RF6052_C_

+

+#include <drv_types.h>

+#include <rtl8188e_hal.h>

+

+/*---------------------------Define Local Constant---------------------------*/

+

+/*---------------------------Define Local Constant---------------------------*/

+

+

+/*------------------------Define global variable-----------------------------*/

+/*------------------------Define global variable-----------------------------*/

+

+

+/*------------------------Define local variable------------------------------*/

+

+/*------------------------Define local variable------------------------------*/

+

+

+/*-----------------------------------------------------------------------------

+ * Function:	RF_ChangeTxPath

+ *

+ * Overview:	For RL6052, we must change some RF settign for 1T or 2T.

+ *

+ * Input:		u2Byte DataRate		// 0x80-8f, 0x90-9f

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Revised History:

+ * When			Who		Remark

+ * 09/25/2008 	MHC		Create Version 0.

+ *						Firmwaer support the utility later.

+ *

+ *---------------------------------------------------------------------------*/

+void rtl8188e_RF_ChangeTxPath(	IN	PADAPTER	Adapter,

+										IN	u16		DataRate)

+{

+// We do not support gain table change inACUT now !!!! Delete later !!!

+#if 0//(RTL92SE_FPGA_VERIFY == 0)

+	static	u1Byte	RF_Path_Type = 2;	// 1 = 1T 2= 2T

+	static	u4Byte	tx_gain_tbl1[6]

+			= {0x17f50, 0x11f40, 0x0cf30, 0x08720, 0x04310, 0x00100};

+	static	u4Byte	tx_gain_tbl2[6]

+			= {0x15ea0, 0x10e90, 0x0c680, 0x08250, 0x04040, 0x00030};

+	u1Byte	i;

+

+	if (RF_Path_Type == 2 && (DataRate&0xF) <= 0x7)

+	{

+		// Set TX SYNC power G2G3 loop filter

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G2, bRFRegOffsetMask, 0x0f000);

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G3, bRFRegOffsetMask, 0xeacf1);

+

+		// Change TX AGC gain table

+		for (i = 0; i < 6; i++)

+			PHY_SetRFReg(Adapter, RF_PATH_A,

+						RF_TX_AGC, bRFRegOffsetMask, tx_gain_tbl1[i]);

+

+		// Set PA to high value

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G2, bRFRegOffsetMask, 0x01e39);

+	}

+	else if (RF_Path_Type == 1 && (DataRate&0xF) >= 0x8)

+	{

+		// Set TX SYNC power G2G3 loop filter

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G2, bRFRegOffsetMask, 0x04440);

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G3, bRFRegOffsetMask, 0xea4f1);

+

+		// Change TX AGC gain table

+		for (i = 0; i < 6; i++)

+			PHY_SetRFReg(Adapter, RF_PATH_A,

+						RF_TX_AGC, bRFRegOffsetMask, tx_gain_tbl2[i]);

+

+		// Set PA low gain

+		PHY_SetRFReg(Adapter, RF_PATH_A,

+					RF_TXPA_G2, bRFRegOffsetMask, 0x01e19);

+	}

+#endif

+

+}	/* RF_ChangeTxPath */

+

+

+/*-----------------------------------------------------------------------------

+ * Function:    PHY_RF6052SetBandwidth()

+ *

+ * Overview:    This function is called by SetBWModeCallback8190Pci() only

+ *

+ * Input:       PADAPTER				Adapter

+ *			WIRELESS_BANDWIDTH_E	Bandwidth	//20M or 40M

+ *

+ * Output:      NONE

+ *

+ * Return:      NONE

+ *

+ * Note:		For RF type 0222D

+ *---------------------------------------------------------------------------*/

+VOID

+rtl8188e_PHY_RF6052SetBandwidth(

+	IN	PADAPTER				Adapter,

+	IN	CHANNEL_WIDTH		Bandwidth)	//20M or 40M

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);

+

+	switch(Bandwidth)

+	{

+		case CHANNEL_WIDTH_20:

+			pHalData->RfRegChnlVal[0] = ((pHalData->RfRegChnlVal[0] & 0xfffff3ff) | BIT(10) | BIT(11));

+			PHY_SetRFReg(Adapter, RF_PATH_A, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);

+			break;

+

+		case CHANNEL_WIDTH_40:

+			pHalData->RfRegChnlVal[0] = ((pHalData->RfRegChnlVal[0] & 0xfffff3ff)| BIT(10));

+			PHY_SetRFReg(Adapter, RF_PATH_A, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);

+			break;

+

+		default:

+			//RT_TRACE(COMP_DBG, DBG_LOUD, ("PHY_SetRF8225Bandwidth(): unknown Bandwidth: %#X\n",Bandwidth ));

+			break;

+	}

+

+}

+

+static int

+phy_RF6052_Config_ParaFile(

+	IN	PADAPTER		Adapter

+	)

+{

+	u32					u4RegValue=0;

+	u8					eRFPath;

+	BB_REGISTER_DEFINITION_T	*pPhyReg;

+

+	int					rtStatus = _SUCCESS;

+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);

+

+	static char			sz88eRadioAFile[] = RTL8188E_PHY_RADIO_A;

+	static char			sz88eRadioBFile[] = RTL8188E_PHY_RADIO_B;

+	static char 			sz8188ETxPwrTrack[] = RTL8188E_TXPWR_TRACK;

+	char					*pszRadioAFile, *pszRadioBFile, *pszTxPwrTrack;

+

+

+	pszRadioAFile = sz88eRadioAFile;

+	pszRadioBFile = sz88eRadioBFile;

+	pszTxPwrTrack = sz8188ETxPwrTrack;

+

+	//3//-----------------------------------------------------------------

+	//3// <2> Initialize RF

+	//3//-----------------------------------------------------------------

+	//for(eRFPath = RF_PATH_A; eRFPath <pHalData->NumTotalRFPath; eRFPath++)

+	for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)

+	{

+

+		pPhyReg = &pHalData->PHYRegDef[eRFPath];

+

+		/*----Store original RFENV control type----*/

+		switch(eRFPath)

+		{

+		case RF_PATH_A:

+		case RF_PATH_C:

+			u4RegValue = PHY_QueryBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV);

+			break;

+		case RF_PATH_B :

+		case RF_PATH_D:

+			u4RegValue = PHY_QueryBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV<<16);

+			break;

+		}

+

+		/*----Set RF_ENV enable----*/

+		PHY_SetBBReg(Adapter, pPhyReg->rfintfe, bRFSI_RFENV<<16, 0x1);

+		rtw_udelay_os(1);//PlatformStallExecution(1);

+

+		/*----Set RF_ENV output high----*/

+		PHY_SetBBReg(Adapter, pPhyReg->rfintfo, bRFSI_RFENV, 0x1);

+		rtw_udelay_os(1);//PlatformStallExecution(1);

+

+		/* Set bit number of Address and Data for RF register */

+		PHY_SetBBReg(Adapter, pPhyReg->rfHSSIPara2, b3WireAddressLength, 0x0); 	// Set 1 to 4 bits for 8255

+		rtw_udelay_os(1);//PlatformStallExecution(1);

+

+		PHY_SetBBReg(Adapter, pPhyReg->rfHSSIPara2, b3WireDataLength, 0x0);	// Set 0 to 12  bits for 8255

+		rtw_udelay_os(1);//PlatformStallExecution(1);

+

+		/*----Initialize RF fom connfiguration file----*/

+		switch(eRFPath)

+		{

+		case RF_PATH_A:

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+			if (PHY_ConfigRFWithParaFile(Adapter, pszRadioAFile, eRFPath) == _FAIL)

+#endif

+			{

+#ifdef CONFIG_EMBEDDED_FWIMG

+				if(HAL_STATUS_FAILURE ==ODM_ConfigRFWithHeaderFile(&pHalData->odmpriv,CONFIG_RF_RADIO, (ODM_RF_RADIO_PATH_E)eRFPath))

+					rtStatus= _FAIL;			

+#endif

+			}

+			break;

+		case RF_PATH_B:

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+			if (PHY_ConfigRFWithParaFile(Adapter, pszRadioBFile, eRFPath) == _FAIL)

+#endif

+			{

+#ifdef CONFIG_EMBEDDED_FWIMG

+				if(HAL_STATUS_FAILURE ==ODM_ConfigRFWithHeaderFile(&pHalData->odmpriv,CONFIG_RF_RADIO, (ODM_RF_RADIO_PATH_E)eRFPath))

+					rtStatus= _FAIL;		

+#endif

+			}

+			break;

+		case RF_PATH_C:

+			break;

+		case RF_PATH_D:

+			break;

+		}

+

+		/*----Restore RFENV control type----*/;

+		switch(eRFPath)

+		{

+		case RF_PATH_A:

+		case RF_PATH_C:

+			PHY_SetBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV, u4RegValue);

+			break;

+		case RF_PATH_B :

+		case RF_PATH_D:

+			PHY_SetBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV<<16, u4RegValue);

+			break;

+		}

+

+		if(rtStatus != _SUCCESS){

+			//RT_TRACE(COMP_FPGA, DBG_LOUD, ("phy_RF6052_Config_ParaFile():Radio[%d] Fail!!", eRFPath));

+			goto phy_RF6052_Config_ParaFile_Fail;

+		}

+

+	}

+

+

+	//3 -----------------------------------------------------------------

+	//3 Configuration of Tx Power Tracking 

+	//3 -----------------------------------------------------------------

+

+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE

+	if (PHY_ConfigRFWithTxPwrTrackParaFile(Adapter, pszTxPwrTrack) == _FAIL)

+#endif

+	{

+#ifdef CONFIG_EMBEDDED_FWIMG

+		ODM_ConfigRFWithTxPwrTrackHeaderFile(&pHalData->odmpriv);

+#endif

+	}

+

+	//RT_TRACE(COMP_INIT, DBG_LOUD, ("<---phy_RF6052_Config_ParaFile()\n"));

+	return rtStatus;

+

+phy_RF6052_Config_ParaFile_Fail:

+	return rtStatus;

+}

+

+

+int

+PHY_RF6052_Config8188E(

+	IN	PADAPTER		Adapter)

+{

+	HAL_DATA_TYPE				*pHalData = GET_HAL_DATA(Adapter);

+	int					rtStatus = _SUCCESS;

+

+	//

+	// Initialize general global value

+	//

+	// TODO: Extend RF_PATH_C and RF_PATH_D in the future

+	if(pHalData->rf_type == RF_1T1R)

+		pHalData->NumTotalRFPath = 1;

+	else

+		pHalData->NumTotalRFPath = 2;

+

+	//

+	// Config BB and RF

+	//

+	rtStatus = phy_RF6052_Config_ParaFile(Adapter);

+#if 0

+	switch( Adapter->MgntInfo.bRegHwParaFile )

+	{

+		case 0:

+			phy_RF6052_Config_HardCode(Adapter);

+			break;

+

+		case 1:

+			rtStatus = phy_RF6052_Config_ParaFile(Adapter);

+			break;

+

+		case 2:

+			// Partial Modify.

+			phy_RF6052_Config_HardCode(Adapter);

+			phy_RF6052_Config_ParaFile(Adapter);

+			break;

+

+		default:

+			phy_RF6052_Config_HardCode(Adapter);

+			break;

+	}

+#endif

+	return rtStatus;

+

+}

+

+/* End of HalRf6052.c */

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rxdesc.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rxdesc.c
new file mode 100644
index 00000000..0039b767
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_rxdesc.c
@@ -0,0 +1,357 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _RTL8188E_REDESC_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+static s32  translate2dbm(u8 signal_strength_idx)
+{
+	s32	signal_power; // in dBm.
+
+
+	// Translate to dBm (x=0.5y-95).
+	signal_power = (s32)((signal_strength_idx + 1) >> 1);
+	signal_power -= 95;
+
+	return signal_power;
+}
+
+
+static void process_rssi(_adapter *padapter,union recv_frame *prframe)
+{
+	u32	last_rssi, tmp_val;
+	struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+	struct signal_stat * signal_stat = &padapter->recvpriv.signal_strength_data;
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+	//DBG_8192C("process_rssi=> pattrib->rssil(%d) signal_strength(%d)\n ",pattrib->RecvSignalPower,pattrib->signal_strength);
+	//if(pRfd->Status.bPacketToSelf || pRfd->Status.bPacketBeacon)
+	{
+	
+	#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+		if(signal_stat->update_req) {
+			signal_stat->total_num = 0;
+			signal_stat->total_val = 0;
+			signal_stat->update_req = 0;
+		}
+
+		signal_stat->total_num++;
+		signal_stat->total_val  += pattrib->phy_info.SignalStrength;
+		signal_stat->avg_val = signal_stat->total_val / signal_stat->total_num;		
+	#else //CONFIG_NEW_SIGNAL_STAT_PROCESS
+	
+		//Adapter->RxStats.RssiCalculateCnt++;	//For antenna Test
+		if(padapter->recvpriv.signal_strength_data.total_num++ >= PHY_RSSI_SLID_WIN_MAX)
+		{
+			padapter->recvpriv.signal_strength_data.total_num = PHY_RSSI_SLID_WIN_MAX;
+			last_rssi = padapter->recvpriv.signal_strength_data.elements[padapter->recvpriv.signal_strength_data.index];
+			padapter->recvpriv.signal_strength_data.total_val -= last_rssi;
+		}
+		padapter->recvpriv.signal_strength_data.total_val  +=pattrib->phy_info.SignalStrength;
+
+		padapter->recvpriv.signal_strength_data.elements[padapter->recvpriv.signal_strength_data.index++] = pattrib->phy_info.SignalStrength;
+		if(padapter->recvpriv.signal_strength_data.index >= PHY_RSSI_SLID_WIN_MAX)
+			padapter->recvpriv.signal_strength_data.index = 0;
+
+
+		tmp_val = padapter->recvpriv.signal_strength_data.total_val/padapter->recvpriv.signal_strength_data.total_num;
+		
+		if(padapter->recvpriv.is_signal_dbg) {
+			padapter->recvpriv.signal_strength= padapter->recvpriv.signal_strength_dbg;
+			padapter->recvpriv.rssi=(s8)translate2dbm((u8)padapter->recvpriv.signal_strength_dbg);
+		} else {
+			padapter->recvpriv.signal_strength= tmp_val;
+			padapter->recvpriv.rssi=(s8)translate2dbm((u8)tmp_val);
+		}
+
+		RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("UI RSSI = %d, ui_rssi.TotalVal = %d, ui_rssi.TotalNum = %d\n", tmp_val, padapter->recvpriv.signal_strength_data.total_val,padapter->recvpriv.signal_strength_data.total_num));
+	#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+	}
+
+}// Process_UI_RSSI_8192C
+
+
+
+static void process_link_qual(_adapter *padapter,union recv_frame *prframe)
+{
+	u32	last_evm=0, tmpVal;
+ 	struct rx_pkt_attrib *pattrib;
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+	struct signal_stat * signal_stat;
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+	if(prframe == NULL || padapter==NULL){
+		return;
+	}
+
+	pattrib = &prframe->u.hdr.attrib;
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+	signal_stat = &padapter->recvpriv.signal_qual_data;
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+	//DBG_8192C("process_link_qual=> pattrib->signal_qual(%d)\n ",pattrib->signal_qual);
+
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+	if(signal_stat->update_req) {
+		signal_stat->total_num = 0;
+		signal_stat->total_val = 0;
+		signal_stat->update_req = 0;
+	}
+
+	signal_stat->total_num++;
+	signal_stat->total_val  += pattrib->phy_info.SignalQuality;
+	signal_stat->avg_val = signal_stat->total_val / signal_stat->total_num;
+	
+#else //CONFIG_NEW_SIGNAL_STAT_PROCESS
+	if(pattrib->phy_info.SignalQuality != 0)
+	{
+			//
+			// 1. Record the general EVM to the sliding window.
+			//
+			if(padapter->recvpriv.signal_qual_data.total_num++ >= PHY_LINKQUALITY_SLID_WIN_MAX)
+			{
+				padapter->recvpriv.signal_qual_data.total_num = PHY_LINKQUALITY_SLID_WIN_MAX;
+				last_evm = padapter->recvpriv.signal_qual_data.elements[padapter->recvpriv.signal_qual_data.index];
+				padapter->recvpriv.signal_qual_data.total_val -= last_evm;
+			}
+			padapter->recvpriv.signal_qual_data.total_val += pattrib->phy_info.SignalQuality;
+
+			padapter->recvpriv.signal_qual_data.elements[padapter->recvpriv.signal_qual_data.index++] = pattrib->phy_info.SignalQuality;
+			if(padapter->recvpriv.signal_qual_data.index >= PHY_LINKQUALITY_SLID_WIN_MAX)
+				padapter->recvpriv.signal_qual_data.index = 0;
+
+			RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("Total SQ=%d  pattrib->signal_qual= %d\n", padapter->recvpriv.signal_qual_data.total_val, pattrib->phy_info.SignalQuality));
+
+			// <1> Showed on UI for user, in percentage.
+			tmpVal = padapter->recvpriv.signal_qual_data.total_val/padapter->recvpriv.signal_qual_data.total_num;
+			padapter->recvpriv.signal_qual=(u8)tmpVal;
+
+	}
+	else
+	{
+		RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,(" pattrib->signal_qual =%d\n", pattrib->phy_info.SignalQuality));
+	}
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+}
+
+//void rtl8188e_process_phy_info(_adapter *padapter, union recv_frame *prframe)
+void rtl8188e_process_phy_info(_adapter *padapter, void *prframe)
+{
+	union recv_frame *precvframe = (union recv_frame *)prframe;
+
+	//
+	// Check RSSI
+	//
+	process_rssi(padapter, precvframe);
+	//
+	// Check PWDB.
+	//
+	//process_PWDB(padapter, precvframe); 
+
+	//UpdateRxSignalStatistics8192C(Adapter, pRfd);
+	//
+	// Check EVM
+	//
+	process_link_qual(padapter,  precvframe);
+	#ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
+	rtw_store_phy_info( padapter,prframe);
+	#endif
+	
+
+}
+
+
+void update_recvframe_attrib_88e(
+	union recv_frame *precvframe,
+	struct recv_stat *prxstat)
+{
+	struct rx_pkt_attrib	*pattrib;
+	struct recv_stat	report;
+	PRXREPORT		prxreport;
+	//struct recv_frame_hdr	*phdr;
+
+	//phdr = &precvframe->u.hdr;
+
+	report.rxdw0 = le32_to_cpu(prxstat->rxdw0);
+	report.rxdw1 = le32_to_cpu(prxstat->rxdw1);
+	report.rxdw2 = le32_to_cpu(prxstat->rxdw2);
+	report.rxdw3 = le32_to_cpu(prxstat->rxdw3);
+	report.rxdw4 = le32_to_cpu(prxstat->rxdw4);
+	report.rxdw5 = le32_to_cpu(prxstat->rxdw5);
+
+	prxreport = (PRXREPORT)&report;
+
+	pattrib = &precvframe->u.hdr.attrib;
+	_rtw_memset(pattrib, 0, sizeof(struct rx_pkt_attrib));
+
+	pattrib->crc_err = (u8)((report.rxdw0 >> 14) & 0x1);;//(u8)prxreport->crc32;	
+	
+	// update rx report to recv_frame attribute
+	pattrib->pkt_rpt_type = (u8)((report.rxdw3 >> 14) & 0x3);//prxreport->rpt_sel;
+	
+	if(pattrib->pkt_rpt_type == NORMAL_RX)//Normal rx packet	
+	{
+		pattrib->pkt_len = (u16)(report.rxdw0 &0x00003fff);//(u16)prxreport->pktlen;
+		pattrib->drvinfo_sz = (u8)((report.rxdw0 >> 16) & 0xf) * 8;//(u8)(prxreport->drvinfosize << 3);
+			
+		pattrib->physt =  (u8)((report.rxdw0 >> 26) & 0x1);//(u8)prxreport->physt;	
+
+		pattrib->bdecrypted = (report.rxdw0 & BIT(27))? 0:1;//(u8)(prxreport->swdec ? 0 : 1);
+		pattrib->encrypt = (u8)((report.rxdw0 >> 20) & 0x7);//(u8)prxreport->security;
+
+		pattrib->qos = (u8)((report.rxdw0 >> 23) & 0x1);//(u8)prxreport->qos;
+		pattrib->priority = (u8)((report.rxdw1 >> 8) & 0xf);//(u8)prxreport->tid;
+
+		pattrib->amsdu = (u8)((report.rxdw1 >> 13) & 0x1);//(u8)prxreport->amsdu;
+
+		pattrib->seq_num = (u16)(report.rxdw2 & 0x00000fff);//(u16)prxreport->seq;
+		pattrib->frag_num = (u8)((report.rxdw2 >> 12) & 0xf);//(u8)prxreport->frag;
+		pattrib->mfrag = (u8)((report.rxdw1 >> 27) & 0x1);//(u8)prxreport->mf;
+		pattrib->mdata = (u8)((report.rxdw1 >> 26) & 0x1);//(u8)prxreport->md;
+
+		pattrib->data_rate = (u8)(report.rxdw3 & 0x3f);//(u8)prxreport->rxmcs;
+		
+		pattrib->icv_err = (u8)((report.rxdw0 >> 15) & 0x1);//(u8)prxreport->icverr;
+		pattrib->shift_sz = (u8)((report.rxdw0 >> 24) & 0x3);
+	
+	}
+	else if(pattrib->pkt_rpt_type == TX_REPORT1)//CCX
+	{
+		pattrib->pkt_len = TX_RPT1_PKT_LEN;
+		pattrib->drvinfo_sz = 0;
+	}
+	else if(pattrib->pkt_rpt_type == TX_REPORT2)// TX RPT
+	{
+		pattrib->pkt_len =(u16)(report.rxdw0 & 0x3FF);//Rx length[9:0]
+		pattrib->drvinfo_sz = 0;
+
+		//
+		// Get TX report MAC ID valid.
+		//
+		pattrib->MacIDValidEntry[0] = report.rxdw4;
+		pattrib->MacIDValidEntry[1] = report.rxdw5;
+		
+	}
+	else if(pattrib->pkt_rpt_type == HIS_REPORT)// USB HISR RPT
+	{
+		pattrib->pkt_len = (u16)(report.rxdw0 &0x00003fff);//(u16)prxreport->pktlen;
+	}	
+	
+}
+
+/*
+ * Notice:
+ *	Before calling this function,
+ *	precvframe->u.hdr.rx_data should be ready!
+ */
+void update_recvframe_phyinfo_88e(
+	union recv_frame	*precvframe,
+	struct phy_stat *pphy_status)
+{
+	PADAPTER 			padapter = precvframe->u.hdr.adapter;
+	struct rx_pkt_attrib	*pattrib = &precvframe->u.hdr.attrib;
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(padapter);	
+	PODM_PHY_INFO_T 	pPHYInfo  = (PODM_PHY_INFO_T)(&pattrib->phy_info);
+	u8					*wlanhdr;
+	ODM_PACKET_INFO_T	pkt_info;
+	u8 *sa = NULL;
+	struct sta_priv *pstapriv;
+	struct sta_info *psta;
+	//_irqL		irqL;
+	
+	pkt_info.bPacketMatchBSSID =_FALSE;
+	pkt_info.bPacketToSelf = _FALSE;
+	pkt_info.bPacketBeacon = _FALSE;
+	
+	wlanhdr = get_recvframe_data(precvframe);
+
+	pkt_info.bPacketMatchBSSID = ((!IsFrameTypeCtrl(wlanhdr)) &&
+		!pattrib->icv_err && !pattrib->crc_err &&
+		_rtw_memcmp(get_hdr_bssid(wlanhdr), get_bssid(&padapter->mlmepriv), ETH_ALEN));
+
+	pkt_info.bPacketToSelf = pkt_info.bPacketMatchBSSID && (_rtw_memcmp(get_ra(wlanhdr), myid(&padapter->eeprompriv), ETH_ALEN));
+
+	pkt_info.bPacketBeacon = pkt_info.bPacketMatchBSSID && (GetFrameSubType(wlanhdr) == WIFI_BEACON);
+
+/*
+	if(pkt_info.bPacketBeacon){
+		if(check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _TRUE){				
+			sa = padapter->mlmepriv.cur_network.network.MacAddress;
+			#if 0
+			{					
+				DBG_8192C("==> rx beacon from AP[%02x:%02x:%02x:%02x:%02x:%02x]\n",
+					sa[0],sa[1],sa[2],sa[3],sa[4],sa[5]);					
+			}
+			#endif
+		}
+		else
+		{
+			//to do Ad-hoc
+			sa = NULL;
+		}
+	}
+	else{	
+		sa = get_sa(wlanhdr);		
+	}	
+*/	
+	sa = get_ta(wlanhdr);	
+	
+	pstapriv = &padapter->stapriv;
+	pkt_info.StationID = 0xFF;
+	psta = rtw_get_stainfo(pstapriv, sa);
+	if (psta)
+	{
+		pkt_info.StationID = psta->mac_id;		
+		//DBG_8192C("%s ==> StationID(%d)\n",__FUNCTION__,pkt_info.StationID);
+	}			
+	pkt_info.DataRate = pattrib->data_rate;	
+	//rtl8188e_query_rx_phy_status(precvframe, pphy_status);
+
+	//_enter_critical_bh(&pHalData->odm_stainfo_lock, &irqL);	
+	ODM_PhyStatusQuery(&pHalData->odmpriv,pPHYInfo,(u8 *)pphy_status,&(pkt_info));
+	//_exit_critical_bh(&pHalData->odm_stainfo_lock, &irqL);
+
+	precvframe->u.hdr.psta = NULL;
+	if (pkt_info.bPacketMatchBSSID &&
+		(check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE))
+	{		
+		if (psta)
+		{			
+			precvframe->u.hdr.psta = psta;
+			rtl8188e_process_phy_info(padapter, precvframe);
+			
+		}		
+	}
+	else if (pkt_info.bPacketToSelf || pkt_info.bPacketBeacon)
+	{
+		if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == _TRUE)
+		{		
+			if (psta)
+			{				
+				precvframe->u.hdr.psta = psta;
+			}
+		}
+		rtl8188e_process_phy_info(padapter, precvframe);		
+	}
+}
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_sreset.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_sreset.c
new file mode 100644
index 00000000..a76668d6
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_sreset.c
@@ -0,0 +1,125 @@
+/******************************************************************************

+ *

+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

+ *

+ * This program is free software; you can redistribute it and/or modify it

+ * under the terms of version 2 of the GNU General Public License as

+ * published by the Free Software Foundation.

+ *

+ * This program is distributed in the hope that it will be useful, but WITHOUT

+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

+ * more details.

+ *

+ * You should have received a copy of the GNU General Public License along with

+ * this program; if not, write to the Free Software Foundation, Inc.,

+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

+ *

+ *

+ ******************************************************************************/

+#define _RTL8188E_SRESET_C_

+

+//#include <rtl8188e_sreset.h>

+#include <rtl8188e_hal.h>

+

+#ifdef DBG_CONFIG_ERROR_DETECT

+

+void rtl8188e_sreset_xmit_status_check(_adapter *padapter)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	struct sreset_priv *psrtpriv = &pHalData->srestpriv;

+

+	unsigned long current_time;

+	struct xmit_priv	*pxmitpriv = &padapter->xmitpriv;

+	unsigned int diff_time;

+	u32 txdma_status;

+	

+	if( (txdma_status=rtw_read32(padapter, REG_TXDMA_STATUS)) !=0x00){

+		DBG_871X("%s REG_TXDMA_STATUS:0x%08x\n", __FUNCTION__, txdma_status);	

+		rtw_hal_sreset_reset(padapter);

+	}

+#ifdef CONFIG_USB_HCI

+	//total xmit irp = 4

+	//DBG_8192C("==>%s free_xmitbuf_cnt(%d),txirp_cnt(%d)\n",__FUNCTION__,pxmitpriv->free_xmitbuf_cnt,pxmitpriv->txirp_cnt);

+	//if(pxmitpriv->txirp_cnt == NR_XMITBUFF+1)

+	current_time = rtw_get_current_time();

+

+	if(0 == pxmitpriv->free_xmitbuf_cnt || 0 == pxmitpriv->free_xmit_extbuf_cnt) {

+

+		diff_time = rtw_get_passing_time_ms(psrtpriv->last_tx_time);

+

+		if (diff_time > 2000) {

+			if (psrtpriv->last_tx_complete_time == 0) {

+				psrtpriv->last_tx_complete_time = current_time;

+			}

+			else{

+				diff_time = rtw_get_passing_time_ms(psrtpriv->last_tx_complete_time);

+				if (diff_time > 4000) {

+					u32 ability;

+

+					//padapter->Wifi_Error_Status = WIFI_TX_HANG;

+					rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8*)&ability);

+

+					DBG_871X("%s tx hang %s\n", __FUNCTION__,

+						(ability & ODM_BB_ADAPTIVITY)? "ODM_BB_ADAPTIVITY" : "");

+

+					if (!(ability & ODM_BB_ADAPTIVITY))

+						rtw_hal_sreset_reset(padapter);

+				}

+			}

+		}

+	}

+#endif //CONFIG_USB_HCI

+

+	if (psrtpriv->dbg_trigger_point == SRESET_TGP_XMIT_STATUS) {

+		psrtpriv->dbg_trigger_point = SRESET_TGP_NULL;

+		rtw_hal_sreset_reset(padapter);

+		return;

+	}

+}

+

+void rtl8188e_sreset_linked_status_check(_adapter *padapter)

+{

+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);

+	struct sreset_priv *psrtpriv = &pHalData->srestpriv;

+

+	u32 rx_dma_status = 0;

+	u8 fw_status=0;

+	rx_dma_status = rtw_read32(padapter,REG_RXDMA_STATUS);

+	if(rx_dma_status!= 0x00){

+		DBG_8192C("%s REG_RXDMA_STATUS:0x%08x \n",__FUNCTION__,rx_dma_status);

+		rtw_write32(padapter,REG_RXDMA_STATUS,rx_dma_status);

+	}	

+	fw_status = rtw_read8(padapter,REG_FMETHR);

+	if(fw_status != 0x00)

+	{		

+		if(fw_status == 1)

+			DBG_8192C("%s REG_FW_STATUS (0x%02x), Read_Efuse_Fail !!   \n",__FUNCTION__,fw_status);

+		else if(fw_status == 2)

+			DBG_8192C("%s REG_FW_STATUS (0x%02x), Condition_No_Match !!   \n",__FUNCTION__,fw_status);

+	}

+#if 0

+	u32 regc50,regc58,reg824,reg800;

+	regc50 = rtw_read32(padapter,0xc50);

+	regc58 = rtw_read32(padapter,0xc58);

+	reg824 = rtw_read32(padapter,0x824);

+	reg800 = rtw_read32(padapter,0x800);

+	if(	((regc50&0xFFFFFF00)!= 0x69543400)||

+		((regc58&0xFFFFFF00)!= 0x69543400)||

+		(((reg824&0xFFFFFF00)!= 0x00390000)&&(((reg824&0xFFFFFF00)!= 0x80390000)))||

+		( ((reg800&0xFFFFFF00)!= 0x03040000)&&((reg800&0xFFFFFF00)!= 0x83040000)))

+	{

+		DBG_8192C("%s regc50:0x%08x, regc58:0x%08x, reg824:0x%08x, reg800:0x%08x,\n", __FUNCTION__,

+			regc50, regc58, reg824, reg800);

+		rtw_hal_sreset_reset(padapter);

+	}

+#endif

+

+	if (psrtpriv->dbg_trigger_point == SRESET_TGP_LINK_STATUS) {

+		psrtpriv->dbg_trigger_point = SRESET_TGP_NULL;

+		rtw_hal_sreset_reset(padapter);

+		return;

+	}

+}

+#endif

+

diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_xmit.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_xmit.c
new file mode 100644
index 00000000..9fd239f9
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/rtl8188e_xmit.c
@@ -0,0 +1,290 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _RTL8188E_XMIT_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+#ifdef CONFIG_XMIT_ACK
+void dump_txrpt_ccx_88e(void *buf)
+{
+	struct txrpt_ccx_88e *txrpt_ccx = (struct txrpt_ccx_88e *)buf;
+
+	DBG_871X("%s:\n"
+		"tag1:%u, pkt_num:%u, txdma_underflow:%u, int_bt:%u, int_tri:%u, int_ccx:%u\n"
+		"mac_id:%u, pkt_ok:%u, bmc:%u\n"
+		"retry_cnt:%u, lifetime_over:%u, retry_over:%u\n"
+		"ccx_qtime:%u\n"
+		"final_data_rate:0x%02x\n"
+		"qsel:%u, sw:0x%03x\n"
+		, __func__
+		, txrpt_ccx->tag1, txrpt_ccx->pkt_num, txrpt_ccx->txdma_underflow, txrpt_ccx->int_bt, txrpt_ccx->int_tri, txrpt_ccx->int_ccx
+		, txrpt_ccx->mac_id, txrpt_ccx->pkt_ok, txrpt_ccx->bmc
+		, txrpt_ccx->retry_cnt, txrpt_ccx->lifetime_over, txrpt_ccx->retry_over 
+		, txrpt_ccx_qtime_88e(txrpt_ccx)
+		, txrpt_ccx->final_data_rate
+		, txrpt_ccx->qsel, txrpt_ccx_sw_88e(txrpt_ccx)
+	);
+}
+
+void handle_txrpt_ccx_88e(_adapter *adapter, u8 *buf)
+{
+	struct txrpt_ccx_88e *txrpt_ccx = (struct txrpt_ccx_88e *)buf;
+
+	#ifdef DBG_CCX
+	dump_txrpt_ccx_88e(buf);
+	#endif
+
+	if (txrpt_ccx->int_ccx) {
+		if (txrpt_ccx->pkt_ok)
+			rtw_ack_tx_done(&adapter->xmitpriv, RTW_SCTX_DONE_SUCCESS);
+		else
+			rtw_ack_tx_done(&adapter->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
+	}
+}
+#endif //CONFIG_XMIT_ACK
+
+void _dbg_dump_tx_info(_adapter	*padapter,int frame_tag,struct tx_desc *ptxdesc)
+{
+	u8 bDumpTxPkt;
+	u8 bDumpTxDesc = _FALSE;
+	rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DUMP_TXPKT, &(bDumpTxPkt));
+
+	if(bDumpTxPkt ==1){//dump txdesc for data frame
+		DBG_871X("dump tx_desc for data frame\n");
+		if((frame_tag&0x0f) == DATA_FRAMETAG){	
+			bDumpTxDesc = _TRUE;		
+		}
+	}	
+	else if(bDumpTxPkt ==2){//dump txdesc for mgnt frame
+		DBG_871X("dump tx_desc for mgnt frame\n");
+		if((frame_tag&0x0f) == MGNT_FRAMETAG){	
+			bDumpTxDesc = _TRUE;		
+		}
+	}	
+	else if(bDumpTxPkt ==3){//dump early info
+	}
+
+	if(bDumpTxDesc){
+		//	ptxdesc->txdw4 = cpu_to_le32(0x00001006);//RTS Rate=24M
+		//	ptxdesc->txdw6 = 0x6666f800;
+		DBG_8192C("=====================================\n");
+		DBG_8192C("txdw0(0x%08x)\n",ptxdesc->txdw0);
+		DBG_8192C("txdw1(0x%08x)\n",ptxdesc->txdw1);
+		DBG_8192C("txdw2(0x%08x)\n",ptxdesc->txdw2);
+		DBG_8192C("txdw3(0x%08x)\n",ptxdesc->txdw3);
+		DBG_8192C("txdw4(0x%08x)\n",ptxdesc->txdw4);
+		DBG_8192C("txdw5(0x%08x)\n",ptxdesc->txdw5);
+		DBG_8192C("txdw6(0x%08x)\n",ptxdesc->txdw6);
+		DBG_8192C("txdw7(0x%08x)\n",ptxdesc->txdw7);
+		DBG_8192C("=====================================\n");
+	}
+
+}
+
+/*
+ * Description:
+ *	Aggregation packets and send to hardware
+ *
+ * Return:
+ *	0	Success
+ *	-1	Hardware resource(TX FIFO) not ready
+ *	-2	Software resource(xmitbuf) not ready
+ */
+#ifdef CONFIG_TX_EARLY_MODE
+
+//#define DBG_EMINFO
+
+#if RTL8188E_EARLY_MODE_PKT_NUM_10 == 1	
+	#define EARLY_MODE_MAX_PKT_NUM	10
+#else
+	#define EARLY_MODE_MAX_PKT_NUM	5
+#endif
+
+
+struct EMInfo{
+	u8 	EMPktNum;
+	u16  EMPktLen[EARLY_MODE_MAX_PKT_NUM];
+};
+
+
+void
+InsertEMContent_8188E(
+	struct EMInfo *pEMInfo,
+	IN pu1Byte	VirtualAddress)
+{
+
+#if RTL8188E_EARLY_MODE_PKT_NUM_10 == 1
+	u1Byte index=0;
+	u4Byte	dwtmp=0;
+#endif
+
+	_rtw_memset(VirtualAddress, 0, EARLY_MODE_INFO_SIZE);
+	if(pEMInfo->EMPktNum==0)
+		return;
+
+	#ifdef DBG_EMINFO
+	{
+		int i;
+		DBG_8192C("\n%s ==> pEMInfo->EMPktNum =%d\n",__FUNCTION__,pEMInfo->EMPktNum);
+		for(i=0;i< EARLY_MODE_MAX_PKT_NUM;i++){
+			DBG_8192C("%s ==> pEMInfo->EMPktLen[%d] =%d\n",__FUNCTION__,i,pEMInfo->EMPktLen[i]);
+		}
+
+	}
+	#endif
+	
+#if RTL8188E_EARLY_MODE_PKT_NUM_10 == 1
+	SET_EARLYMODE_PKTNUM(VirtualAddress, pEMInfo->EMPktNum);
+
+	if(pEMInfo->EMPktNum == 1){
+		dwtmp = pEMInfo->EMPktLen[0];
+	}else{
+		dwtmp = pEMInfo->EMPktLen[0];
+		dwtmp += ((dwtmp%4)?(4-dwtmp%4):0)+4;
+		dwtmp += pEMInfo->EMPktLen[1];
+	}
+	SET_EARLYMODE_LEN0(VirtualAddress, dwtmp);
+	if(pEMInfo->EMPktNum <= 3){
+		dwtmp = pEMInfo->EMPktLen[2];
+	}else{
+		dwtmp = pEMInfo->EMPktLen[2];
+		dwtmp += ((dwtmp%4)?(4-dwtmp%4):0)+4;
+		dwtmp += pEMInfo->EMPktLen[3];
+	}
+	SET_EARLYMODE_LEN1(VirtualAddress, dwtmp);
+	if(pEMInfo->EMPktNum <= 5){
+		dwtmp = pEMInfo->EMPktLen[4];
+	}else{
+		dwtmp = pEMInfo->EMPktLen[4];
+		dwtmp += ((dwtmp%4)?(4-dwtmp%4):0)+4;
+		dwtmp += pEMInfo->EMPktLen[5];
+	}
+	SET_EARLYMODE_LEN2_1(VirtualAddress, dwtmp&0xF);
+	SET_EARLYMODE_LEN2_2(VirtualAddress, dwtmp>>4);
+	if(pEMInfo->EMPktNum <= 7){
+		dwtmp = pEMInfo->EMPktLen[6];
+	}else{
+		dwtmp = pEMInfo->EMPktLen[6];
+		dwtmp += ((dwtmp%4)?(4-dwtmp%4):0)+4;
+		dwtmp += pEMInfo->EMPktLen[7];
+	}
+	SET_EARLYMODE_LEN3(VirtualAddress, dwtmp);
+	if(pEMInfo->EMPktNum <= 9){
+		dwtmp = pEMInfo->EMPktLen[8];
+	}else{
+		dwtmp = pEMInfo->EMPktLen[8];
+		dwtmp += ((dwtmp%4)?(4-dwtmp%4):0)+4;
+		dwtmp += pEMInfo->EMPktLen[9];
+	}
+	SET_EARLYMODE_LEN4(VirtualAddress, dwtmp);
+#else	
+	SET_EARLYMODE_PKTNUM(VirtualAddress, pEMInfo->EMPktNum);
+	SET_EARLYMODE_LEN0(VirtualAddress, pEMInfo->EMPktLen[0]);
+	SET_EARLYMODE_LEN1(VirtualAddress, pEMInfo->EMPktLen[1]);
+	SET_EARLYMODE_LEN2_1(VirtualAddress, pEMInfo->EMPktLen[2]&0xF);
+	SET_EARLYMODE_LEN2_2(VirtualAddress, pEMInfo->EMPktLen[2]>>4);
+	SET_EARLYMODE_LEN3(VirtualAddress, pEMInfo->EMPktLen[3]);
+	SET_EARLYMODE_LEN4(VirtualAddress, pEMInfo->EMPktLen[4]);
+#endif	
+	//RT_PRINT_DATA(COMP_SEND, DBG_LOUD, "EMHdr:", VirtualAddress, 8);
+
+}
+
+
+
+void UpdateEarlyModeInfo8188E(struct xmit_priv *pxmitpriv,struct xmit_buf *pxmitbuf )
+{
+	//_adapter *padapter, struct xmit_frame *pxmitframe,struct tx_servq	*ptxservq
+	int index,j;
+	u16 offset,pktlen;
+	PTXDESC_8188E ptxdesc;
+	
+	u8 *pmem,*pEMInfo_mem;
+	s8 node_num_0=0,node_num_1=0;
+	struct EMInfo eminfo;
+	struct agg_pkt_info *paggpkt;
+	struct xmit_frame *pframe = (struct xmit_frame*)pxmitbuf->priv_data;	
+	pmem= pframe->buf_addr;	
+	
+	#ifdef DBG_EMINFO			
+	DBG_8192C("\n%s ==> agg_num:%d\n",__FUNCTION__, pframe->agg_num);
+	for(index=0;index<pframe->agg_num;index++){
+		offset = 	pxmitpriv->agg_pkt[index].offset;
+		pktlen = pxmitpriv->agg_pkt[index].pkt_len;
+		DBG_8192C("%s ==> agg_pkt[%d].offset=%d\n",__FUNCTION__,index,offset);
+		DBG_8192C("%s ==> agg_pkt[%d].pkt_len=%d\n",__FUNCTION__,index,pktlen);
+	}
+	#endif
+	
+	if( pframe->agg_num > EARLY_MODE_MAX_PKT_NUM)
+	{	
+		node_num_0 = pframe->agg_num;
+		node_num_1= EARLY_MODE_MAX_PKT_NUM-1;
+	}
+	
+	for(index=0;index<pframe->agg_num;index++){
+
+		offset = pxmitpriv->agg_pkt[index].offset;
+		pktlen = pxmitpriv->agg_pkt[index].pkt_len;		
+
+		_rtw_memset(&eminfo,0,sizeof(struct EMInfo));
+		if( pframe->agg_num > EARLY_MODE_MAX_PKT_NUM){
+			if(node_num_0 > EARLY_MODE_MAX_PKT_NUM){
+				eminfo.EMPktNum = EARLY_MODE_MAX_PKT_NUM;
+				node_num_0--;
+			}
+			else{
+				eminfo.EMPktNum = node_num_1;
+				node_num_1--;				
+			}			
+		}
+		else{
+			eminfo.EMPktNum = pframe->agg_num-(index+1);	
+		}				
+		for(j=0;j< eminfo.EMPktNum ;j++){
+			eminfo.EMPktLen[j] = pxmitpriv->agg_pkt[index+1+j].pkt_len+4;// 4 bytes CRC
+		}
+			
+		if(pmem){
+			if(index==0){
+				ptxdesc = (PTXDESC_8188E)(pmem);
+				pEMInfo_mem = ((u8 *)ptxdesc)+TXDESC_SIZE;				
+			}
+			else{
+				pmem = pmem + pxmitpriv->agg_pkt[index-1].offset;
+				ptxdesc = (PTXDESC_8188E)(pmem);
+				pEMInfo_mem = ((u8 *)ptxdesc)+TXDESC_SIZE;					
+			}
+			
+			#ifdef DBG_EMINFO
+			DBG_8192C("%s ==> desc.pkt_len=%d\n",__FUNCTION__,ptxdesc->pktlen);
+			#endif
+			InsertEMContent_8188E(&eminfo,pEMInfo_mem);
+		}	
+		
+		
+	} 
+	_rtw_memset(pxmitpriv->agg_pkt,0,sizeof(struct agg_pkt_info)*MAX_AGG_PKT_NUM);
+
+}
+#endif
+
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_led.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_led.c
new file mode 100644
index 00000000..be0119a3
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_led.c
@@ -0,0 +1,171 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+//================================================================================
+// LED object.
+//================================================================================
+
+
+//================================================================================
+//	Prototype of protected function.
+//================================================================================
+
+
+//================================================================================
+// LED_819xUsb routines. 
+//================================================================================
+
+//
+//	Description:
+//		Turn on LED according to LedPin specified.
+//
+static void
+SwLedOn_8188EU(
+	_adapter			*padapter, 
+	PLED_USB		pLed
+)
+{
+	u8	LedCfg;
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
+	{
+		return;
+	}
+
+	LedCfg = rtw_read8(padapter, REG_LEDCFG2);
+	switch(pLed->LedPin)
+	{	
+		case LED_PIN_LED0:
+			rtw_write8(padapter, REG_LEDCFG2, (LedCfg&0xf0)|BIT5|BIT6); // SW control led0 on.
+			break;
+
+		case LED_PIN_LED1:
+			rtw_write8(padapter, REG_LEDCFG2, (LedCfg&0x0f)|BIT5); // SW control led1 on.
+			break;
+
+		default:
+			break;
+	}
+	
+	pLed->bLedOn = _TRUE;
+}
+
+
+//
+//	Description:
+//		Turn off LED according to LedPin specified.
+//
+static void
+SwLedOff_8188EU(
+	_adapter			*padapter, 
+	PLED_USB		pLed
+)
+{
+	u8	LedCfg;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	if(padapter->bSurpriseRemoved == _TRUE)
+	{
+		goto exit;
+	}
+
+
+	LedCfg = rtw_read8(padapter, REG_LEDCFG2);//0x4E
+
+	switch(pLed->LedPin)
+	{
+		case LED_PIN_LED0:
+			if(pHalData->bLedOpenDrain == _TRUE) // Open-drain arrangement for controlling the LED)
+			{
+				LedCfg &= 0x90; // Set to software control.				
+				rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3));				
+				LedCfg = rtw_read8(padapter, REG_MAC_PINMUX_CFG);
+				LedCfg &= 0xFE;
+				rtw_write8(padapter, REG_MAC_PINMUX_CFG, LedCfg);									
+			}
+			else
+			{
+				rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3|BIT5|BIT6));
+			}
+			break;
+
+		case LED_PIN_LED1:
+			LedCfg &= 0x0f; // Set to software control.
+			rtw_write8(padapter, REG_LEDCFG2, (LedCfg|BIT3));
+			break;
+
+		default:
+			break;
+	}
+exit:
+	pLed->bLedOn = _FALSE;
+	
+}
+
+//================================================================================
+// Interface to manipulate LED objects.
+//================================================================================
+
+
+//================================================================================
+// Default LED behavior.
+//================================================================================
+
+//
+//	Description:
+//		Initialize all LED_871x objects.
+//
+void
+rtl8188eu_InitSwLeds(
+	_adapter	*padapter
+	)
+{
+	struct led_priv *pledpriv = &(padapter->ledpriv);
+
+	pledpriv->LedControlHandler = LedControlUSB;
+
+	pledpriv->SwLedOn = SwLedOn_8188EU;
+	pledpriv->SwLedOff = SwLedOff_8188EU;
+
+	InitLed(padapter, &(pledpriv->SwLed0), LED_PIN_LED0);
+
+	InitLed(padapter, &(pledpriv->SwLed1), LED_PIN_LED1);
+}
+
+
+//
+//	Description:
+//		DeInitialize all LED_819xUsb objects.
+//
+void
+rtl8188eu_DeInitSwLeds(
+	_adapter	*padapter
+	)
+{
+	struct led_priv	*ledpriv = &(padapter->ledpriv);
+
+	DeInitLed( &(ledpriv->SwLed0) );
+	DeInitLed( &(ledpriv->SwLed1) );
+}
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_recv.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_recv.c
new file mode 100644
index 00000000..11701adb
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_recv.c
@@ -0,0 +1,214 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _RTL8188EU_RECV_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+
+void rtl8188eu_init_recvbuf(_adapter *padapter, struct recv_buf *precvbuf)
+{
+
+	precvbuf->transfer_len = 0;
+
+	precvbuf->len = 0;
+
+	precvbuf->ref_cnt = 0;
+
+	if(precvbuf->pbuf)
+	{
+		precvbuf->pdata = precvbuf->phead = precvbuf->ptail = precvbuf->pbuf;
+		precvbuf->pend = precvbuf->pdata + MAX_RECVBUF_SZ;
+	}
+
+}
+
+int	rtl8188eu_init_recv_priv(_adapter *padapter)
+{
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+	int	i, res = _SUCCESS;
+	struct recv_buf *precvbuf;
+
+#ifdef CONFIG_RECV_THREAD_MODE	
+	_rtw_init_sema(&precvpriv->recv_sema, 0);//will be removed
+	_rtw_init_sema(&precvpriv->terminate_recvthread_sema, 0);//will be removed
+#endif
+
+#ifdef PLATFORM_LINUX
+	tasklet_init(&precvpriv->recv_tasklet,
+	     (void(*)(unsigned long))rtl8188eu_recv_tasklet,
+	     (unsigned long)padapter);
+#endif
+
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+#ifdef PLATFORM_LINUX
+	precvpriv->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
+	if(precvpriv->int_in_urb == NULL){
+		res= _FAIL;
+		DBG_8192C("alloc_urb for interrupt in endpoint fail !!!!\n");
+		goto exit;
+	}
+#endif
+	precvpriv->int_in_buf = rtw_zmalloc(INTERRUPT_MSG_FORMAT_LEN);
+	if(precvpriv->int_in_buf == NULL){
+		res= _FAIL;
+		DBG_8192C("alloc_mem for interrupt in endpoint fail !!!!\n");
+		goto exit;
+	}
+#endif
+
+	//init recv_buf
+	_rtw_init_queue(&precvpriv->free_recv_buf_queue);
+
+	_rtw_init_queue(&precvpriv->recv_buf_pending_queue);
+
+	precvpriv->pallocated_recv_buf = rtw_zmalloc(NR_RECVBUFF *sizeof(struct recv_buf) + 4);
+	if(precvpriv->pallocated_recv_buf==NULL){
+		res= _FAIL;
+		RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,("alloc recv_buf fail!\n"));
+		goto exit;
+	}
+	_rtw_memset(precvpriv->pallocated_recv_buf, 0, NR_RECVBUFF *sizeof(struct recv_buf) + 4);
+
+	precvpriv->precv_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(precvpriv->pallocated_recv_buf), 4);
+	//precvpriv->precv_buf = precvpriv->pallocated_recv_buf + 4 -
+	//						((uint) (precvpriv->pallocated_recv_buf) &(4-1));
+
+
+	precvbuf = (struct recv_buf*)precvpriv->precv_buf;
+
+	for(i=0; i < NR_RECVBUFF ; i++)
+	{
+		_rtw_init_listhead(&precvbuf->list);
+
+		_rtw_spinlock_init(&precvbuf->recvbuf_lock);
+
+		precvbuf->alloc_sz = MAX_RECVBUF_SZ;
+
+		res = rtw_os_recvbuf_resource_alloc(padapter, precvbuf);
+		if(res==_FAIL)
+			break;
+
+		precvbuf->ref_cnt = 0;
+		precvbuf->adapter =padapter;
+
+
+		//rtw_list_insert_tail(&precvbuf->list, &(precvpriv->free_recv_buf_queue.queue));
+
+		precvbuf++;
+
+	}
+
+	precvpriv->free_recv_buf_queue_cnt = NR_RECVBUFF;
+
+#ifdef PLATFORM_LINUX
+
+	skb_queue_head_init(&precvpriv->rx_skb_queue);
+
+#ifdef CONFIG_PREALLOC_RECV_SKB
+	{
+		int i;
+		SIZE_PTR tmpaddr=0;
+		SIZE_PTR alignment=0;
+		struct sk_buff *pskb=NULL;
+
+		skb_queue_head_init(&precvpriv->free_recv_skb_queue);
+
+		for(i=0; i<NR_PREALLOC_RECV_SKB; i++)
+		{
+			pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
+
+			if(pskb)
+			{
+				pskb->dev = padapter->pnetdev;
+
+				tmpaddr = (SIZE_PTR)pskb->data;
+				alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
+				skb_reserve(pskb, (RECVBUFF_ALIGN_SZ - alignment));
+
+				skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
+			}
+
+			pskb=NULL;
+
+		}
+	}
+#endif
+
+#endif
+
+exit:
+
+	return res;
+
+}
+
+void rtl8188eu_free_recv_priv (_adapter *padapter)
+{
+	int	i;
+	struct recv_buf	*precvbuf;
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+
+	precvbuf = (struct recv_buf *)precvpriv->precv_buf;
+
+	for(i=0; i < NR_RECVBUFF ; i++)
+	{
+		rtw_os_recvbuf_resource_free(padapter, precvbuf);
+		precvbuf++;
+	}
+
+	if(precvpriv->pallocated_recv_buf)
+		rtw_mfree(precvpriv->pallocated_recv_buf, NR_RECVBUFF *sizeof(struct recv_buf) + 4);
+
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+#ifdef PLATFORM_LINUX
+	if(precvpriv->int_in_urb)
+	{
+		usb_free_urb(precvpriv->int_in_urb);
+	}
+#endif//PLATFORM_LINUX
+
+	if(precvpriv->int_in_buf)
+		rtw_mfree(precvpriv->int_in_buf, INTERRUPT_MSG_FORMAT_LEN);
+#endif//CONFIG_USB_INTERRUPT_IN_PIPE
+
+#ifdef PLATFORM_LINUX
+
+	if (skb_queue_len(&precvpriv->rx_skb_queue)) {
+		DBG_8192C(KERN_WARNING "rx_skb_queue not empty\n");
+	}
+
+	rtw_skb_queue_purge(&precvpriv->rx_skb_queue);
+
+#ifdef CONFIG_PREALLOC_RECV_SKB
+
+	if (skb_queue_len(&precvpriv->free_recv_skb_queue)) {
+		DBG_8192C(KERN_WARNING "free_recv_skb_queue not empty, %d\n", skb_queue_len(&precvpriv->free_recv_skb_queue));
+	}
+
+	rtw_skb_queue_purge(&precvpriv->free_recv_skb_queue);
+
+#endif
+
+#endif
+
+}
+
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_xmit.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_xmit.c
new file mode 100644
index 00000000..081c8074
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/rtl8188eu_xmit.c
@@ -0,0 +1,1332 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _RTL8188E_XMIT_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+
+s32	rtl8188eu_init_xmit_priv(_adapter *padapter)
+{
+	struct xmit_priv	*pxmitpriv = &padapter->xmitpriv;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+#ifdef PLATFORM_LINUX
+	tasklet_init(&pxmitpriv->xmit_tasklet,
+	     (void(*)(unsigned long))rtl8188eu_xmit_tasklet,
+	     (unsigned long)padapter);
+#endif
+#ifdef CONFIG_TX_EARLY_MODE
+	pHalData->bEarlyModeEnable = padapter->registrypriv.early_mode;
+#endif
+
+	return _SUCCESS;
+}
+
+void	rtl8188eu_free_xmit_priv(_adapter *padapter)
+{
+}
+
+u8 urb_zero_packet_chk(_adapter *padapter, int sz)
+{
+	u8 blnSetTxDescOffset;
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(padapter);
+	blnSetTxDescOffset = (((sz + TXDESC_SIZE) %  pHalData->UsbBulkOutSize) ==0)?1:0;
+
+	return blnSetTxDescOffset;
+}
+
+void rtl8188eu_cal_txdesc_chksum(struct tx_desc	*ptxdesc)
+{
+		u16	*usPtr = (u16*)ptxdesc;
+		u32 count = 16;		// (32 bytes / 2 bytes per XOR) => 16 times
+		u32 index;
+		u16 checksum = 0;
+
+		//Clear first
+		ptxdesc->txdw7 &= cpu_to_le32(0xffff0000);
+	
+		for(index = 0 ; index < count ; index++){
+			checksum = checksum ^ le16_to_cpu(*(usPtr + index));
+		}
+
+		ptxdesc->txdw7 |= cpu_to_le32(0x0000ffff&checksum);	
+
+}
+//
+// Description: In normal chip, we should send some packet to Hw which will be used by Fw
+//			in FW LPS mode. The function is to fill the Tx descriptor of this packets, then
+//			Fw can tell Hw to send these packet derectly.
+//
+void rtl8188e_fill_fake_txdesc(
+	PADAPTER	padapter,
+	u8*			pDesc,
+	u32			BufferLen,
+	u8			IsPsPoll,
+	u8			IsBTQosNull)
+{
+	struct tx_desc *ptxdesc;
+
+
+	// Clear all status
+	ptxdesc = (struct tx_desc*)pDesc;
+	_rtw_memset(pDesc, 0, TXDESC_SIZE);
+
+	//offset 0
+	ptxdesc->txdw0 |= cpu_to_le32( OWN | FSG | LSG); //own, bFirstSeg, bLastSeg;
+
+	ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ)<<OFFSET_SHT)&0x00ff0000); //32 bytes for TX Desc
+
+	ptxdesc->txdw0 |= cpu_to_le32(BufferLen&0x0000ffff); // Buffer size + command header
+
+	//offset 4
+	ptxdesc->txdw1 |= cpu_to_le32((QSLT_MGNT<<QSEL_SHT)&0x00001f00); // Fixed queue of Mgnt queue
+
+	//Set NAVUSEHDR to prevent Ps-poll AId filed to be changed to error vlaue by Hw.
+	if (IsPsPoll)
+	{
+		ptxdesc->txdw1 |= cpu_to_le32(NAVUSEHDR);
+	}
+	else
+	{
+		ptxdesc->txdw4 |= cpu_to_le32(BIT(7)); // Hw set sequence number
+		ptxdesc->txdw3 |= cpu_to_le32((8 <<28)); //set bit3 to 1. Suugested by TimChen. 2009.12.29.
+	}
+
+	if (_TRUE == IsBTQosNull)
+	{
+		ptxdesc->txdw2 |= cpu_to_le32(BIT(23)); // BT NULL
+	}
+
+	//offset 16
+	ptxdesc->txdw4 |= cpu_to_le32(BIT(8));//driver uses rate
+
+#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI)
+	// USB interface drop packet if the checksum of descriptor isn't correct.
+	// Using this checksum can let hardware recovery from packet bulk out error (e.g. Cancel URC, Bulk out error.).
+	rtl8188eu_cal_txdesc_chksum(ptxdesc);
+#endif
+}
+
+void fill_txdesc_sectype(struct pkt_attrib *pattrib, struct tx_desc *ptxdesc)
+{
+	if ((pattrib->encrypt > 0) && !pattrib->bswenc)
+	{
+		switch (pattrib->encrypt)
+		{	
+			//SEC_TYPE : 0:NO_ENC,1:WEP40/TKIP,2:WAPI,3:AES
+			case _WEP40_:
+			case _WEP104_:
+					ptxdesc->txdw1 |= cpu_to_le32((0x01<<SEC_TYPE_SHT)&0x00c00000);
+					ptxdesc->txdw2 |= cpu_to_le32(0x7 << AMPDU_DENSITY_SHT);
+					break;				
+			case _TKIP_:
+			case _TKIP_WTMIC_:	
+					ptxdesc->txdw1 |= cpu_to_le32((0x01<<SEC_TYPE_SHT)&0x00c00000);
+					ptxdesc->txdw2 |= cpu_to_le32(0x7 << AMPDU_DENSITY_SHT);
+					break;
+#ifdef CONFIG_WAPI_SUPPORT
+			case _SMS4_:
+					ptxdesc->txdw1 |= cpu_to_le32((0x02<<SEC_TYPE_SHT)&0x00c00000);
+					ptxdesc->txdw2 |= cpu_to_le32(0x7 << AMPDU_DENSITY_SHT);
+				break;
+#endif
+			case _AES_:
+					ptxdesc->txdw1 |= cpu_to_le32((0x03<<SEC_TYPE_SHT)&0x00c00000);
+					ptxdesc->txdw2 |= cpu_to_le32(0x7 << AMPDU_DENSITY_SHT);
+					break;
+			case _NO_PRIVACY_:
+			default:
+					break;
+		
+		}
+		
+	}
+
+}
+
+void fill_txdesc_vcs(struct pkt_attrib *pattrib, u32 *pdw)
+{
+	//DBG_8192C("cvs_mode=%d\n", pattrib->vcs_mode);	
+
+	switch(pattrib->vcs_mode)
+	{
+		case RTS_CTS:
+			*pdw |= cpu_to_le32(RTS_EN);
+			break;
+		case CTS_TO_SELF:
+			*pdw |= cpu_to_le32(CTS_2_SELF);
+			break;
+		case NONE_VCS:
+		default:
+			break;		
+	}
+
+	if(pattrib->vcs_mode) {
+		*pdw |= cpu_to_le32(HW_RTS_EN);
+
+		// Set RTS BW
+		if(pattrib->ht_en)
+		{
+			*pdw |= (pattrib->bwmode&CHANNEL_WIDTH_40)?	cpu_to_le32(BIT(27)):0;
+
+			if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
+				*pdw |= cpu_to_le32((0x01<<28)&0x30000000);
+			else if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
+				*pdw |= cpu_to_le32((0x02<<28)&0x30000000);
+			else if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_DONT_CARE)
+				*pdw |= 0;
+			else
+				*pdw |= cpu_to_le32((0x03<<28)&0x30000000);
+		}
+	}
+}
+
+void fill_txdesc_phy(struct pkt_attrib *pattrib, u32 *pdw)
+{
+	//DBG_8192C("bwmode=%d, ch_off=%d\n", pattrib->bwmode, pattrib->ch_offset);
+
+	if(pattrib->ht_en)
+	{
+		*pdw |= (pattrib->bwmode&CHANNEL_WIDTH_40)?	cpu_to_le32(BIT(25)):0;
+
+		if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
+			*pdw |= cpu_to_le32((0x01<<DATA_SC_SHT)&0x003f0000);		
+		else if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
+			*pdw |= cpu_to_le32((0x02<<DATA_SC_SHT)&0x003f0000);
+		else if(pattrib->ch_offset == HAL_PRIME_CHNL_OFFSET_DONT_CARE)
+			*pdw |= 0;
+		else
+			*pdw |= cpu_to_le32((0x03<<DATA_SC_SHT)&0x003f0000);
+	}
+}
+
+
+static s32 update_txdesc(struct xmit_frame *pxmitframe, u8 *pmem, s32 sz ,u8 bagg_pkt)
+{	
+      int	pull=0;
+	uint	qsel;
+	bool sgi = 0;
+	u8 data_rate,pwr_status,offset;
+	_adapter			*padapter = pxmitframe->padapter;
+	struct mlme_priv	*pmlmepriv = &padapter->mlmepriv;		
+	struct pkt_attrib	*pattrib = &pxmitframe->attrib;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	//struct dm_priv	*pdmpriv = &pHalData->dmpriv;
+	struct tx_desc	*ptxdesc = (struct tx_desc *)pmem;
+	struct mlme_ext_priv	*pmlmeext = &padapter->mlmeextpriv;
+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+	sint	bmcst = IS_MCAST(pattrib->ra);	
+#ifdef CONFIG_P2P
+	struct wifidirect_info*	pwdinfo = &padapter->wdinfo;
+#endif //CONFIG_P2P
+
+#ifndef CONFIG_USE_USB_BUFFER_ALLOC_TX 
+if (padapter->registrypriv.mp_mode == 0)
+{
+	//if((!bagg_pkt) &&(urb_zero_packet_chk(padapter, sz)==0))//(sz %512) != 0
+	if((PACKET_OFFSET_SZ != 0) && (!bagg_pkt) &&(rtw_usb_bulk_size_boundary(padapter,TXDESC_SIZE+sz)==_FALSE))	
+	{
+		ptxdesc = (struct tx_desc *)(pmem+PACKET_OFFSET_SZ);
+		//DBG_8192C("==> non-agg-pkt,shift pointer...\n");
+		pull = 1;
+	}
+}
+#endif	// CONFIG_USE_USB_BUFFER_ALLOC_TX
+
+	_rtw_memset(ptxdesc, 0, sizeof(struct tx_desc));
+	
+        //4 offset 0
+	ptxdesc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
+	//DBG_8192C("%s==> pkt_len=%d,bagg_pkt=%02x\n",__FUNCTION__,sz,bagg_pkt);
+	ptxdesc->txdw0 |= cpu_to_le32(sz & 0x0000ffff);//update TXPKTSIZE
+	
+	offset = TXDESC_SIZE + OFFSET_SZ;		
+
+	#ifdef CONFIG_TX_EARLY_MODE	
+	if(bagg_pkt){		
+		offset += EARLY_MODE_INFO_SIZE ;//0x28			
+	}
+	#endif
+	//DBG_8192C("%s==>offset(0x%02x)  \n",__FUNCTION__,offset);
+	ptxdesc->txdw0 |= cpu_to_le32(((offset) << OFFSET_SHT) & 0x00ff0000);//32 bytes for TX Desc
+
+	if (bmcst) ptxdesc->txdw0 |= cpu_to_le32(BMC);
+
+#ifndef CONFIG_USE_USB_BUFFER_ALLOC_TX
+if (padapter->registrypriv.mp_mode == 0)
+{
+	if((PACKET_OFFSET_SZ != 0) && (!bagg_pkt)) {
+		if((pull) && (pxmitframe->pkt_offset>0)) {	
+			pxmitframe->pkt_offset = pxmitframe->pkt_offset -1;		
+		}
+	}
+}	
+#endif
+	//DBG_8192C("%s, pkt_offset=0x%02x\n",__FUNCTION__,pxmitframe->pkt_offset);
+
+	// pkt_offset, unit:8 bytes padding
+	if (pxmitframe->pkt_offset > 0)
+		ptxdesc->txdw1 |= cpu_to_le32((pxmitframe->pkt_offset << 26) & 0x7c000000);
+
+	//driver uses rate
+	ptxdesc->txdw4 |= cpu_to_le32(USERATE);//rate control always by driver
+
+	if((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG)
+	{
+		//DBG_8192C("pxmitframe->frame_tag == DATA_FRAMETAG\n");		
+
+		//offset 4
+		ptxdesc->txdw1 |= cpu_to_le32(pattrib->mac_id&0x3F);
+
+		qsel = (uint)(pattrib->qsel & 0x0000001f);
+		//DBG_8192C("==> macid(%d) qsel:0x%02x \n",pattrib->mac_id,qsel);
+		ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00);
+
+		ptxdesc->txdw1 |= cpu_to_le32((pattrib->raid<< RATE_ID_SHT) & 0x000F0000);
+
+		fill_txdesc_sectype(pattrib, ptxdesc);
+
+		if(pattrib->ampdu_en==_TRUE){
+			ptxdesc->txdw2 |= cpu_to_le32(AGG_EN);//AGG EN
+		
+			//SET_TX_DESC_MAX_AGG_NUM_88E(pDesc, 0x1F);
+			//SET_TX_DESC_MCSG1_MAX_LEN_88E(pDesc, 0x6);
+			//SET_TX_DESC_MCSG2_MAX_LEN_88E(pDesc, 0x6);
+			//SET_TX_DESC_MCSG3_MAX_LEN_88E(pDesc, 0x6);
+			//SET_TX_DESC_MCS7_SGI_MAX_LEN_88E(pDesc, 0x6);
+			ptxdesc->txdw6 = 0x6666f800;		
+		}
+		else{
+			ptxdesc->txdw2 |= cpu_to_le32(AGG_BK);//AGG BK
+		}
+		
+		//offset 8
+		
+
+		//offset 12
+		ptxdesc->txdw3 |= cpu_to_le32((pattrib->seqnum<< SEQ_SHT)&0x0FFF0000);
+
+
+		//offset 16 , offset 20
+		if (pattrib->qos_en)
+			ptxdesc->txdw4 |= cpu_to_le32(QOS);//QoS
+
+		//offset 20
+	#ifdef CONFIG_USB_TX_AGGREGATION
+		if (pxmitframe->agg_num > 1){
+			//DBG_8192C("%s agg_num:%d\n",__FUNCTION__,pxmitframe->agg_num );
+			ptxdesc->txdw5 |= cpu_to_le32((pxmitframe->agg_num << USB_TXAGG_NUM_SHT) & 0xFF000000);
+		}
+	#endif
+
+		if ((pattrib->ether_type != 0x888e) &&
+		    (pattrib->ether_type != 0x0806) &&
+		    (pattrib->ether_type != 0x88b4) &&
+		    (pattrib->dhcp_pkt != 1))
+		{
+			//Non EAP & ARP & DHCP type data packet
+              	
+			fill_txdesc_vcs(pattrib, &ptxdesc->txdw4);
+			fill_txdesc_phy(pattrib, &ptxdesc->txdw4);
+
+			ptxdesc->txdw4 |= cpu_to_le32(0x00000008);//RTS Rate=24M
+			ptxdesc->txdw5 |= cpu_to_le32(0x0001ff00);//DATA/RTS  Rate FB LMT			
+
+#if (RATE_ADAPTIVE_SUPPORT == 1)
+			/* driver-based RA*/
+			if (pattrib->ht_en)
+				sgi = ODM_RA_GetShortGI_8188E(&pHalData->odmpriv,pattrib->mac_id);
+
+			data_rate = ODM_RA_GetDecisionRate_8188E(&pHalData->odmpriv,pattrib->mac_id);
+
+			#if (POWER_TRAINING_ACTIVE==1)
+			pwr_status = ODM_RA_GetHwPwrStatus_8188E(&pHalData->odmpriv,pattrib->mac_id);
+			ptxdesc->txdw4 |= cpu_to_le32((pwr_status & 0x7) << PWR_STATUS_SHT);
+			#endif
+#else//if (RATE_ADAPTIVE_SUPPORT == 1)
+			/* FW-based RA, TODO */
+			if(pattrib->ht_en)
+				sgi = 1;
+
+			data_rate = 0x13; //default rate: MCS7
+#endif//if (RATE_ADAPTIVE_SUPPORT == 1)
+
+			if (padapter->fix_rate != 0xFF) {
+				data_rate = padapter->fix_rate;
+				ptxdesc->txdw4 |= cpu_to_le32(USERATE);
+				ptxdesc->txdw4 |= cpu_to_le32(DISDATAFB);
+				sgi = (padapter->fix_rate & BIT(7))?1:0;
+			}
+
+			if (sgi)
+				ptxdesc->txdw5 |= cpu_to_le32(SGI);
+
+			ptxdesc->txdw5 |= cpu_to_le32(data_rate & 0x3F);
+		}
+		else
+		{
+			// EAP data packet and ARP packet and DHCP.
+			// Use the 1M data rate to send the EAP/ARP packet.
+			// This will maybe make the handshake smooth.
+
+			ptxdesc->txdw2 |= cpu_to_le32(AGG_BK);//AGG BK		   
+
+			if (pmlmeinfo->preamble_mode == PREAMBLE_SHORT)
+				ptxdesc->txdw4 |= cpu_to_le32(BIT(24));// DATA_SHORT
+
+			ptxdesc->txdw5 |= cpu_to_le32(MRateToHwRate(pmlmeext->tx_rate));
+		}
+
+#ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
+		//offset 24
+		if ( pattrib->hw_tcp_csum == 1 ) {
+			// ptxdesc->txdw6 = 0; // clear TCP_CHECKSUM and IP_CHECKSUM. It's zero already!!
+			u8 ip_hdr_offset = 32 + pattrib->hdrlen + pattrib->iv_len + 8;
+			ptxdesc->txdw7 = (1 << 31) | (ip_hdr_offset << 16);
+			DBG_8192C("ptxdesc->txdw7 = %08x\n", ptxdesc->txdw7);
+		}
+#endif
+	}
+	else if((pxmitframe->frame_tag&0x0f)== MGNT_FRAMETAG)
+	{
+		//DBG_8192C("pxmitframe->frame_tag == MGNT_FRAMETAG\n");	
+		
+		//offset 4		
+		ptxdesc->txdw1 |= cpu_to_le32(pattrib->mac_id&0x3f);
+		
+		qsel = (uint)(pattrib->qsel&0x0000001f);
+		ptxdesc->txdw1 |= cpu_to_le32((qsel<<QSEL_SHT)&0x00001f00);
+
+		ptxdesc->txdw1 |= cpu_to_le32((pattrib->raid<< RATE_ID_SHT) & 0x000f0000);
+		
+		//fill_txdesc_sectype(pattrib, ptxdesc);
+		
+		//offset 8		
+#ifdef CONFIG_XMIT_ACK
+		//CCX-TXRPT ack for xmit mgmt frames.
+		if (pxmitframe->ack_report) {
+			#ifdef DBG_CCX
+			static u16 ccx_sw = 0x123;
+			ptxdesc->txdw7 |= cpu_to_le32(((ccx_sw)<<16)&0x0fff0000);
+			DBG_871X("%s set ccx, sw:0x%03x\n", __func__, ccx_sw);
+			ccx_sw = (ccx_sw+1)%0xfff;
+			#endif
+			ptxdesc->txdw2 |= cpu_to_le32(BIT(19));
+		}
+#endif //CONFIG_XMIT_ACK
+
+		//offset 12
+		ptxdesc->txdw3 |= cpu_to_le32((pattrib->seqnum<<SEQ_SHT)&0x0FFF0000);
+				
+		//offset 20
+		ptxdesc->txdw5 |= cpu_to_le32(RTY_LMT_EN);//retry limit enable
+		if(pattrib->retry_ctrl == _TRUE)
+			ptxdesc->txdw5 |= cpu_to_le32(0x00180000);//retry limit = 6
+		else
+			ptxdesc->txdw5 |= cpu_to_le32(0x00300000);//retry limit = 12
+
+#ifdef CONFIG_INTEL_PROXIM
+		if((padapter->proximity.proxim_on==_TRUE)&&(pattrib->intel_proxim==_TRUE)){
+			DBG_871X("\n %s pattrib->rate=%d\n",__FUNCTION__,pattrib->rate);
+			ptxdesc->txdw5 |= cpu_to_le32( pattrib->rate);
+		}
+		else
+#endif
+		{
+			ptxdesc->txdw5 |= cpu_to_le32(MRateToHwRate(pmlmeext->tx_rate));
+		}
+	}
+	else if((pxmitframe->frame_tag&0x0f) == TXAGG_FRAMETAG)
+	{
+		DBG_8192C("pxmitframe->frame_tag == TXAGG_FRAMETAG\n");
+	}
+#ifdef CONFIG_MP_INCLUDED
+	else if(((pxmitframe->frame_tag&0x0f) == MP_FRAMETAG) &&
+			(padapter->registrypriv.mp_mode == 1))
+	{
+		fill_txdesc_for_mp(padapter, (u8 *)ptxdesc);
+	}
+#endif
+	else
+	{
+		DBG_8192C("pxmitframe->frame_tag = %d\n", pxmitframe->frame_tag);
+
+		//offset 4	
+		ptxdesc->txdw1 |= cpu_to_le32((4)&0x3f);//CAM_ID(MAC_ID)
+
+		ptxdesc->txdw1 |= cpu_to_le32((6<< RATE_ID_SHT) & 0x000f0000);//raid
+
+		//offset 8		
+
+		//offset 12
+		ptxdesc->txdw3 |= cpu_to_le32((pattrib->seqnum<<SEQ_SHT)&0x0fff0000);
+
+		//offset 20
+		ptxdesc->txdw5 |= cpu_to_le32(MRateToHwRate(pmlmeext->tx_rate));
+	}
+
+	// 2009.11.05. tynli_test. Suggested by SD4 Filen for FW LPS.
+	// (1) The sequence number of each non-Qos frame / broadcast / multicast /
+	// mgnt frame should be controled by Hw because Fw will also send null data
+	// which we cannot control when Fw LPS enable.
+	// --> default enable non-Qos data sequense number. 2010.06.23. by tynli.
+	// (2) Enable HW SEQ control for beacon packet, because we use Hw beacon.
+	// (3) Use HW Qos SEQ to control the seq num of Ext port non-Qos packets.
+	// 2010.06.23. Added by tynli.
+	if(!pattrib->qos_en)
+	{		
+		//ptxdesc->txdw4 |= cpu_to_le32(BIT(7)); // Hw set sequence number
+		//ptxdesc->txdw3 |= cpu_to_le32((8 <<28)); //set bit3 to 1. Suugested by TimChen. 2009.12.29.
+
+		ptxdesc->txdw3 |= cpu_to_le32(EN_HWSEQ); // Hw set sequence number
+		ptxdesc->txdw4 |= cpu_to_le32(HW_SSN); 	// Hw set sequence number
+		
+	}
+
+#ifdef CONFIG_HW_ANTENNA_DIVERSITY //CONFIG_ANTENNA_DIVERSITY 
+	ODM_SetTxAntByTxInfo(&pHalData->odmpriv, pmem, pattrib->mac_id);
+#endif
+
+	rtl8188eu_cal_txdesc_chksum(ptxdesc);
+	_dbg_dump_tx_info(padapter,pxmitframe->frame_tag,ptxdesc);	
+	return pull;
+		
+}
+
+
+#ifdef CONFIG_XMIT_THREAD_MODE
+/*
+ * Description
+ *	Transmit xmitbuf to hardware tx fifo
+ *
+ * Return
+ *	_SUCCESS	ok
+ *	_FAIL		something error
+ */
+s32 rtl8188eu_xmit_buf_handler(PADAPTER padapter)
+{
+	//PHAL_DATA_TYPE phal;
+	struct xmit_priv *pxmitpriv;
+	struct xmit_buf *pxmitbuf;
+	s32 ret;
+
+
+	//phal = GET_HAL_DATA(padapter);
+	pxmitpriv = &padapter->xmitpriv;
+
+	ret = _rtw_down_sema(&pxmitpriv->xmit_sema);
+	if (_FAIL == ret) {
+		RT_TRACE(_module_hal_xmit_c_, _drv_emerg_,
+				 ("%s: down SdioXmitBufSema fail!\n", __FUNCTION__));
+		return _FAIL;
+	}
+
+	ret = (padapter->bDriverStopped == _TRUE) || (padapter->bSurpriseRemoved == _TRUE);
+	if (ret) {
+		RT_TRACE(_module_hal_xmit_c_, _drv_notice_,
+				 ("%s: bDriverStopped(%d) bSurpriseRemoved(%d)!\n",
+				  __FUNCTION__, padapter->bDriverStopped, padapter->bSurpriseRemoved));
+		return _FAIL;
+	}
+
+	if(check_pending_xmitbuf(pxmitpriv) == _FALSE)
+		return _SUCCESS;
+
+#ifdef CONFIG_LPS_LCLK
+	ret = rtw_register_tx_alive(padapter);
+	if (ret != _SUCCESS) {
+		RT_TRACE(_module_hal_xmit_c_, _drv_notice_,
+				 ("%s: wait to leave LPS_LCLK\n", __FUNCTION__));
+		return _SUCCESS;
+	}
+#endif
+
+	do {
+		pxmitbuf = dequeue_pending_xmitbuf(pxmitpriv);
+		if (pxmitbuf == NULL) break;
+
+		rtw_write_port(padapter, pxmitbuf->ff_hwaddr, pxmitbuf->len, (unsigned char*)pxmitbuf);
+
+	} while (1);
+
+#ifdef CONFIG_LPS_LCLK
+	rtw_unregister_tx_alive(padapter);
+#endif
+
+	return _SUCCESS;
+}
+#endif
+
+#ifdef CONFIG_IOL_IOREG_CFG_DBG
+#include <rtw_iol.h>
+#endif
+//for non-agg data frame or  management frame
+static s32 rtw_dump_xframe(_adapter *padapter, struct xmit_frame *pxmitframe)
+{
+	s32 ret = _SUCCESS;
+	s32 inner_ret = _SUCCESS;
+	int t, sz, w_sz, pull=0;
+	u8 *mem_addr;
+	u32 ff_hwaddr;
+	struct xmit_buf *pxmitbuf = pxmitframe->pxmitbuf;
+	struct pkt_attrib *pattrib = &pxmitframe->attrib;
+	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
+	struct security_priv *psecuritypriv = &padapter->securitypriv;
+#ifdef CONFIG_80211N_HT
+	if ((pxmitframe->frame_tag == DATA_FRAMETAG) &&
+	    (pxmitframe->attrib.ether_type != 0x0806) &&
+	    (pxmitframe->attrib.ether_type != 0x888e) &&
+	    (pxmitframe->attrib.ether_type != 0x88b4) &&
+	    (pxmitframe->attrib.dhcp_pkt != 1))
+	{
+		rtw_issue_addbareq_cmd(padapter, pxmitframe);
+	}
+#endif //CONFIG_80211N_HT
+	mem_addr = pxmitframe->buf_addr;
+
+       RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_dump_xframe()\n"));
+	
+	for (t = 0; t < pattrib->nr_frags; t++)
+	{
+		if (inner_ret != _SUCCESS && ret == _SUCCESS)
+			ret = _FAIL;
+			
+		if (t != (pattrib->nr_frags - 1))
+		{
+			RT_TRACE(_module_rtl871x_xmit_c_,_drv_err_,("pattrib->nr_frags=%d\n", pattrib->nr_frags));
+
+			sz = pxmitpriv->frag_len;
+			sz = sz - 4 - (psecuritypriv->sw_encrypt ? 0 : pattrib->icv_len);					
+		}
+		else //no frag
+		{
+			sz = pattrib->last_txcmdsz;
+		}
+
+		pull = update_txdesc(pxmitframe, mem_addr, sz, _FALSE);
+             
+		if(pull)
+		{
+			mem_addr += PACKET_OFFSET_SZ; //pull txdesc head
+			
+			//pxmitbuf ->pbuf = mem_addr;			
+			pxmitframe->buf_addr = mem_addr;
+
+			w_sz = sz + TXDESC_SIZE;
+		}
+		else
+		{
+			w_sz = sz + TXDESC_SIZE + PACKET_OFFSET_SZ;
+		}	
+#ifdef CONFIG_IOL_IOREG_CFG_DBG		
+		rtw_IOL_cmd_buf_dump(padapter,w_sz,pxmitframe->buf_addr);
+#endif		
+		ff_hwaddr = rtw_get_ff_hwaddr(pxmitframe);
+
+#ifdef CONFIG_XMIT_THREAD_MODE
+		pxmitbuf->len = w_sz;
+		pxmitbuf->ff_hwaddr = ff_hwaddr;
+		enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
+#else
+	//	DBG_871X("%s:  rtw_write_port size =%d\n", __func__,w_sz);
+		inner_ret = rtw_write_port(padapter, ff_hwaddr, w_sz, (unsigned char*)pxmitbuf);
+#endif
+
+		rtw_count_tx_stats(padapter, pxmitframe, sz);
+
+		RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("rtw_write_port, w_sz=%d\n", w_sz));
+		//DBG_8192C("rtw_write_port, w_sz=%d, sz=%d, txdesc_sz=%d, tid=%d\n", w_sz, sz, w_sz-sz, pattrib->priority);      
+
+		mem_addr += w_sz;
+
+		mem_addr = (u8 *)RND4(((SIZE_PTR)(mem_addr)));
+
+	}
+	
+	rtw_free_xmitframe(pxmitpriv, pxmitframe);
+	
+	if  (ret != _SUCCESS)
+		rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_UNKNOWN);
+	
+	return ret;
+}
+
+#ifdef CONFIG_USB_TX_AGGREGATION
+static u32 xmitframe_need_length(struct xmit_frame *pxmitframe)
+{
+	struct pkt_attrib *pattrib = &pxmitframe->attrib;
+
+	u32	len = 0;
+
+	// no consider fragement
+	len = pattrib->hdrlen + pattrib->iv_len +
+		SNAP_SIZE + sizeof(u16) +
+		pattrib->pktlen +
+		((pattrib->bswenc) ? pattrib->icv_len : 0);
+
+	if(pattrib->encrypt ==_TKIP_)
+		len += 8;
+
+	return len;
+}
+
+#define IDEA_CONDITION 1	// check all packets before enqueue
+s32 rtl8188eu_xmitframe_complete(_adapter *padapter, struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	struct xmit_frame *pxmitframe = NULL;
+	struct xmit_frame *pfirstframe = NULL;
+
+	// aggregate variable
+	struct hw_xmit *phwxmit;
+	struct sta_info *psta = NULL;
+	struct tx_servq *ptxservq = NULL;
+
+	_irqL irqL;
+	_list *xmitframe_plist = NULL, *xmitframe_phead = NULL;
+
+	u32	pbuf;	// next pkt address
+	u32	pbuf_tail;	// last pkt tail
+	u32	len;	// packet length, except TXDESC_SIZE and PKT_OFFSET
+
+	u32	bulkSize = pHalData->UsbBulkOutSize;
+	u8	descCount;
+	u32	bulkPtr;
+
+	// dump frame variable
+	u32 ff_hwaddr;
+
+#ifndef IDEA_CONDITION
+	int res = _SUCCESS;
+#endif
+
+	RT_TRACE(_module_rtl8192c_xmit_c_, _drv_info_, ("+xmitframe_complete\n"));
+
+
+	// check xmitbuffer is ok
+	if (pxmitbuf == NULL) {
+		pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
+		if (pxmitbuf == NULL){
+			//DBG_871X("%s #1, connot alloc xmitbuf!!!! \n",__FUNCTION__);
+			return _FALSE;
+		}
+	}
+
+//DBG_8192C("%s ===================================== \n",__FUNCTION__);
+	//3 1. pick up first frame
+	do {
+		rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			
+		pxmitframe = rtw_dequeue_xframe(pxmitpriv, pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
+		if (pxmitframe == NULL) {
+			// no more xmit frame, release xmit buffer
+			//DBG_8192C("no more xmit frame ,return\n");
+			rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
+			return _FALSE;
+		}
+
+#ifndef IDEA_CONDITION
+		if (pxmitframe->frame_tag != DATA_FRAMETAG) {
+			RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_,
+				 ("xmitframe_complete: frame tag(%d) is not DATA_FRAMETAG(%d)!\n",
+				  pxmitframe->frame_tag, DATA_FRAMETAG));
+//			rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			continue;
+		}
+
+		// TID 0~15
+		if ((pxmitframe->attrib.priority < 0) ||
+		    (pxmitframe->attrib.priority > 15)) {
+			RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_,
+				 ("xmitframe_complete: TID(%d) should be 0~15!\n",
+				  pxmitframe->attrib.priority));
+//			rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			continue;
+		}
+#endif
+		//DBG_8192C("==> pxmitframe->attrib.priority:%d\n",pxmitframe->attrib.priority);
+		pxmitframe->pxmitbuf = pxmitbuf;
+		pxmitframe->buf_addr = pxmitbuf->pbuf;
+		pxmitbuf->priv_data = pxmitframe;
+
+		pxmitframe->agg_num = 1; // alloc xmitframe should assign to 1.
+		#ifdef CONFIG_TX_EARLY_MODE
+		pxmitframe->pkt_offset = (PACKET_OFFSET_SZ/8)+1; // 2; // first frame of aggregation, reserve one offset for EM info ,another for usb bulk-out block check
+		#else
+		pxmitframe->pkt_offset = (PACKET_OFFSET_SZ/8); // 1; // first frame of aggregation, reserve offset
+		#endif
+
+		if (rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe) == _FALSE) {
+			DBG_871X("%s coalesce 1st xmitframe failed \n",__FUNCTION__);
+			continue;
+		}
+
+		// always return ndis_packet after rtw_xmitframe_coalesce
+		rtw_os_xmit_complete(padapter, pxmitframe);
+
+		break;
+	} while (1);
+
+	//3 2. aggregate same priority and same DA(AP or STA) frames
+	pfirstframe = pxmitframe;
+	len = xmitframe_need_length(pfirstframe) + TXDESC_SIZE+(pfirstframe->pkt_offset*PACKET_OFFSET_SZ);
+	pbuf_tail = len;
+	pbuf = _RND8(pbuf_tail);
+
+	// check pkt amount in one bulk
+	descCount = 0;
+	bulkPtr = bulkSize;
+	if (pbuf < bulkPtr) {
+		descCount++;
+		if (descCount == pHalData->UsbTxAggDescNum)
+			goto agg_end;
+	} else {
+		descCount = 0;
+		bulkPtr = ((pbuf / bulkSize) + 1) * bulkSize; // round to next bulkSize
+	}
+
+	// dequeue same priority packet from station tx queue
+	//psta = pfirstframe->attrib.psta;
+	psta = rtw_get_stainfo(&padapter->stapriv, pfirstframe->attrib.ra);
+	if(pfirstframe->attrib.psta != psta){
+		DBG_871X("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pfirstframe->attrib.psta, psta);		
+	}
+	if (psta == NULL) {		
+		DBG_8192C("rtw_xmit_classifier: psta == NULL\n");		
+	}
+	if(!(psta->state &_FW_LINKED)){
+		DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state);		
+	}
+	
+	switch (pfirstframe->attrib.priority) {
+		case 1:
+		case 2:
+			ptxservq = &(psta->sta_xmitpriv.bk_q);
+			phwxmit = pxmitpriv->hwxmits + 3;
+			break;
+
+		case 4:
+		case 5:
+			ptxservq = &(psta->sta_xmitpriv.vi_q);
+			phwxmit = pxmitpriv->hwxmits + 1;
+			break;
+
+		case 6:
+		case 7:
+			ptxservq = &(psta->sta_xmitpriv.vo_q);
+			phwxmit = pxmitpriv->hwxmits;
+			break;
+
+		case 0:
+		case 3:
+		default:
+			ptxservq = &(psta->sta_xmitpriv.be_q);
+			phwxmit = pxmitpriv->hwxmits + 2;
+			break;
+	}
+//DBG_8192C("==> pkt_no=%d,pkt_len=%d,len=%d,RND8_LEN=%d,pkt_offset=0x%02x\n",
+	//pxmitframe->agg_num,pxmitframe->attrib.last_txcmdsz,len,pbuf,pxmitframe->pkt_offset );
+
+	_enter_critical_bh(&pxmitpriv->lock, &irqL);
+
+	xmitframe_phead = get_list_head(&ptxservq->sta_pending);
+	xmitframe_plist = get_next(xmitframe_phead);
+	
+	while (rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist) == _FALSE)
+	{
+		pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list);
+		xmitframe_plist = get_next(xmitframe_plist);
+
+		if(_FAIL == rtw_hal_busagg_qsel_check(padapter,pfirstframe->attrib.qsel,pxmitframe->attrib.qsel))
+			break;
+
+		pxmitframe->agg_num = 0; // not first frame of aggregation
+		#ifdef CONFIG_TX_EARLY_MODE
+		pxmitframe->pkt_offset = 1;// not first frame of aggregation,reserve offset for EM Info
+		#else
+		pxmitframe->pkt_offset = 0; // not first frame of aggregation, no need to reserve offset
+		#endif	
+
+		len = xmitframe_need_length(pxmitframe) + TXDESC_SIZE +(pxmitframe->pkt_offset*PACKET_OFFSET_SZ);
+		
+		if (_RND8(pbuf + len) > MAX_XMITBUF_SZ)
+		//if (_RND8(pbuf + len) > (MAX_XMITBUF_SZ/2))//to do : for TX TP finial tune , Georgia 2012-0323
+		{
+			//DBG_8192C("%s....len> MAX_XMITBUF_SZ\n",__FUNCTION__);
+			pxmitframe->agg_num = 1;
+			pxmitframe->pkt_offset = 1;			
+			break;		
+		}
+		rtw_list_delete(&pxmitframe->list);
+		ptxservq->qcnt--;
+		phwxmit->accnt--;
+
+#ifndef IDEA_CONDITION
+		// suppose only data frames would be in queue
+		if (pxmitframe->frame_tag != DATA_FRAMETAG) {
+			RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_,
+				 ("xmitframe_complete: frame tag(%d) is not DATA_FRAMETAG(%d)!\n",
+				  pxmitframe->frame_tag, DATA_FRAMETAG));
+			rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			continue;
+		}
+
+		// TID 0~15
+		if ((pxmitframe->attrib.priority < 0) ||
+		    (pxmitframe->attrib.priority > 15)) {
+			RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_,
+				 ("xmitframe_complete: TID(%d) should be 0~15!\n",
+				  pxmitframe->attrib.priority));
+			rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			continue;
+		}
+#endif
+
+//		pxmitframe->pxmitbuf = pxmitbuf;
+		pxmitframe->buf_addr = pxmitbuf->pbuf + pbuf;
+	
+		if (rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe) == _FALSE) {
+			DBG_871X("%s coalesce failed \n",__FUNCTION__);
+			rtw_free_xmitframe(pxmitpriv, pxmitframe);
+			continue;
+		}
+
+		//DBG_8192C("==> pxmitframe->attrib.priority:%d\n",pxmitframe->attrib.priority);
+		// always return ndis_packet after rtw_xmitframe_coalesce
+		rtw_os_xmit_complete(padapter, pxmitframe);
+
+		// (len - TXDESC_SIZE) == pxmitframe->attrib.last_txcmdsz
+		update_txdesc(pxmitframe, pxmitframe->buf_addr, pxmitframe->attrib.last_txcmdsz,_TRUE);
+				
+		// don't need xmitframe any more
+		rtw_free_xmitframe(pxmitpriv, pxmitframe);
+
+		// handle pointer and stop condition
+		pbuf_tail = pbuf + len;
+		pbuf = _RND8(pbuf_tail);
+
+
+		pfirstframe->agg_num++;
+#ifdef CONFIG_TX_EARLY_MODE	
+		pxmitpriv->agg_pkt[pfirstframe->agg_num-1].offset = _RND8(len); 			
+		pxmitpriv->agg_pkt[pfirstframe->agg_num-1].pkt_len = pxmitframe->attrib.last_txcmdsz;						
+#endif
+		if (MAX_TX_AGG_PACKET_NUMBER == pfirstframe->agg_num)
+			break;
+
+		if (pbuf < bulkPtr) {
+			descCount++;
+			if (descCount == pHalData->UsbTxAggDescNum)
+				break;
+		} else {
+			descCount = 0;
+			bulkPtr = ((pbuf / bulkSize) + 1) * bulkSize;
+		}
+	}//end while( aggregate same priority and same DA(AP or STA) frames)
+
+	if (_rtw_queue_empty(&ptxservq->sta_pending) == _TRUE)
+		rtw_list_delete(&ptxservq->tx_pending);
+
+	_exit_critical_bh(&pxmitpriv->lock, &irqL);
+
+agg_end:
+
+#ifdef CONFIG_80211N_HT
+	if ((pfirstframe->attrib.ether_type != 0x0806) &&
+	    (pfirstframe->attrib.ether_type != 0x888e) &&
+	    (pfirstframe->attrib.ether_type != 0x88b4) &&
+	    (pfirstframe->attrib.dhcp_pkt != 1))
+	{
+		rtw_issue_addbareq_cmd(padapter, pfirstframe);
+	}
+#endif //CONFIG_80211N_HT
+#ifndef CONFIG_USE_USB_BUFFER_ALLOC_TX
+	//3 3. update first frame txdesc
+	if ((PACKET_OFFSET_SZ != 0) && ((pbuf_tail % bulkSize) == 0)) {
+		// remove pkt_offset
+		pbuf_tail -= PACKET_OFFSET_SZ;
+		pfirstframe->buf_addr += PACKET_OFFSET_SZ;
+		pfirstframe->pkt_offset--;
+		//DBG_8192C("$$$$$ buf size equal to USB block size $$$$$$\n");
+	}
+#endif	// CONFIG_USE_USB_BUFFER_ALLOC_TX
+
+	update_txdesc(pfirstframe, pfirstframe->buf_addr, pfirstframe->attrib.last_txcmdsz,_TRUE);
+		
+        #ifdef CONFIG_TX_EARLY_MODE
+	//prepare EM info for first frame, agg_num value start from 1
+	pxmitpriv->agg_pkt[0].offset = _RND8(pfirstframe->attrib.last_txcmdsz +TXDESC_SIZE +(pfirstframe->pkt_offset*PACKET_OFFSET_SZ));
+	pxmitpriv->agg_pkt[0].pkt_len = pfirstframe->attrib.last_txcmdsz;//get from rtw_xmitframe_coalesce 			
+
+	UpdateEarlyModeInfo8188E(pxmitpriv,pxmitbuf );
+	#endif
+	
+	//3 4. write xmit buffer to USB FIFO
+	ff_hwaddr = rtw_get_ff_hwaddr(pfirstframe);
+//DBG_8192C("%s ===================================== write port,buf_size(%d) \n",__FUNCTION__,pbuf_tail);
+	// xmit address == ((xmit_frame*)pxmitbuf->priv_data)->buf_addr
+	rtw_write_port(padapter, ff_hwaddr, pbuf_tail, (u8*)pxmitbuf);
+
+
+	//3 5. update statisitc
+	pbuf_tail -= (pfirstframe->agg_num * TXDESC_SIZE);
+	pbuf_tail -= (pfirstframe->pkt_offset * PACKET_OFFSET_SZ);
+	
+	
+	rtw_count_tx_stats(padapter, pfirstframe, pbuf_tail);
+
+	rtw_free_xmitframe(pxmitpriv, pfirstframe);
+
+	return _TRUE;
+}
+
+#else
+
+s32 rtl8188eu_xmitframe_complete(_adapter *padapter, struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
+{		
+
+	struct hw_xmit *phwxmits;
+	sint hwentry;
+	struct xmit_frame *pxmitframe=NULL;	
+	int res=_SUCCESS, xcnt = 0;
+
+	phwxmits = pxmitpriv->hwxmits;
+	hwentry = pxmitpriv->hwxmit_entry;
+
+	RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("xmitframe_complete()\n"));
+
+	if(pxmitbuf==NULL)
+	{
+		pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);		
+		if(!pxmitbuf)
+		{
+			return _FALSE;
+		}			
+	}	
+
+
+	do
+	{		
+		pxmitframe =  rtw_dequeue_xframe(pxmitpriv, phwxmits, hwentry);
+		
+		if(pxmitframe)
+		{
+			pxmitframe->pxmitbuf = pxmitbuf;				
+
+			pxmitframe->buf_addr = pxmitbuf->pbuf;
+
+			pxmitbuf->priv_data = pxmitframe;	
+
+			if((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG)
+			{	
+				if(pxmitframe->attrib.priority<=15)//TID0~15
+				{
+					res = rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
+				}	
+				//DBG_8192C("==> pxmitframe->attrib.priority:%d\n",pxmitframe->attrib.priority);
+				rtw_os_xmit_complete(padapter, pxmitframe);//always return ndis_packet after rtw_xmitframe_coalesce 			
+			}
+
+				
+			RT_TRACE(_module_rtl871x_xmit_c_,_drv_info_,("xmitframe_complete(): rtw_dump_xframe\n"));
+
+			
+			if(res == _SUCCESS)
+			{
+				rtw_dump_xframe(padapter, pxmitframe);		 
+			}
+			else
+			{
+				rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
+				rtw_free_xmitframe(pxmitpriv, pxmitframe);	
+			}
+	 			 		
+			xcnt++;
+			
+		}
+		else
+		{			
+			rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
+			return _FALSE;
+		}
+
+		break;
+		
+	}while(0/*xcnt < (NR_XMITFRAME >> 3)*/);
+
+	return _TRUE;
+	
+}
+#endif
+
+
+
+static s32 xmitframe_direct(_adapter *padapter, struct xmit_frame *pxmitframe)
+{
+	s32 res = _SUCCESS;
+//DBG_8192C("==> %s \n",__FUNCTION__);
+
+	res = rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
+	if (res == _SUCCESS) {
+		rtw_dump_xframe(padapter, pxmitframe);
+	}
+	else{
+		DBG_8192C("==> %s xmitframe_coalsece failed\n",__FUNCTION__);
+	}
+
+	return res;
+}
+
+/*
+ * Return
+ *	_TRUE	dump packet directly
+ *	_FALSE	enqueue packet
+ */
+static s32 pre_xmitframe(_adapter *padapter, struct xmit_frame *pxmitframe)
+{
+        _irqL irqL;
+	s32 res;
+	struct xmit_buf *pxmitbuf = NULL;
+	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
+	struct pkt_attrib *pattrib = &pxmitframe->attrib;
+	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+	
+	_enter_critical_bh(&pxmitpriv->lock, &irqL);
+
+//DBG_8192C("==> %s \n",__FUNCTION__);
+
+	if (rtw_txframes_sta_ac_pending(padapter, pattrib) > 0)
+	{
+		//DBG_8192C("enqueue AC(%d)\n",pattrib->priority);
+		goto enqueue;
+	}
+
+
+	if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE)
+		goto enqueue;
+
+#ifdef CONFIG_CONCURRENT_MODE	
+	if (check_buddy_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE)
+		goto enqueue;
+#endif
+
+	pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
+	if (pxmitbuf == NULL)
+		goto enqueue;
+
+	_exit_critical_bh(&pxmitpriv->lock, &irqL);
+
+	pxmitframe->pxmitbuf = pxmitbuf;
+	pxmitframe->buf_addr = pxmitbuf->pbuf;
+	pxmitbuf->priv_data = pxmitframe;
+
+	if (xmitframe_direct(padapter, pxmitframe) != _SUCCESS) {
+		rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
+		rtw_free_xmitframe(pxmitpriv, pxmitframe);
+	}
+
+	return _TRUE;
+
+enqueue:
+	res = rtw_xmitframe_enqueue(padapter, pxmitframe);
+	_exit_critical_bh(&pxmitpriv->lock, &irqL);
+
+	if (res != _SUCCESS) {
+		RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("pre_xmitframe: enqueue xmitframe fail\n"));
+		rtw_free_xmitframe(pxmitpriv, pxmitframe);
+
+		pxmitpriv->tx_drop++;
+		return _TRUE;
+	}
+
+	return _FALSE;
+}
+
+s32 rtl8188eu_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe)
+{
+	return rtw_dump_xframe(padapter, pmgntframe);
+}
+
+/*
+ * Return
+ *	_TRUE	dump packet directly ok
+ *	_FALSE	temporary can't transmit packets to hardware
+ */
+s32 rtl8188eu_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe)
+{
+	return pre_xmitframe(padapter, pxmitframe);
+}
+
+s32	rtl8188eu_hal_xmitframe_enqueue(_adapter *padapter, struct xmit_frame *pxmitframe)
+{
+	struct xmit_priv 	*pxmitpriv = &padapter->xmitpriv;
+	s32 err;
+	
+	if ((err=rtw_xmitframe_enqueue(padapter, pxmitframe)) != _SUCCESS) 
+	{
+		rtw_free_xmitframe(pxmitpriv, pxmitframe);
+
+		pxmitpriv->tx_drop++;					
+	}
+	else
+	{
+#ifdef PLATFORM_LINUX
+		tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
+#endif
+	}
+	
+	return err;
+	
+}
+
+
+#ifdef  CONFIG_HOSTAPD_MLME
+
+static void rtl8188eu_hostap_mgnt_xmit_cb(struct urb *urb)
+{	
+#ifdef PLATFORM_LINUX
+	struct sk_buff *skb = (struct sk_buff *)urb->context;
+
+	//DBG_8192C("%s\n", __FUNCTION__);
+
+	rtw_skb_free(skb);
+#endif	
+}
+
+s32 rtl8188eu_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt)
+{
+#ifdef PLATFORM_LINUX
+	u16 fc;
+	int rc, len, pipe;	
+	unsigned int bmcst, tid, qsel;
+	struct sk_buff *skb, *pxmit_skb;
+	struct urb *urb;
+	unsigned char *pxmitbuf;
+	struct tx_desc *ptxdesc;
+	struct rtw_ieee80211_hdr *tx_hdr;
+	struct hostapd_priv *phostapdpriv = padapter->phostapdpriv;	
+	struct net_device *pnetdev = padapter->pnetdev;
+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
+	struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);	
+
+	
+	//DBG_8192C("%s\n", __FUNCTION__);
+
+	skb = pkt;
+	
+	len = skb->len;
+	tx_hdr = (struct rtw_ieee80211_hdr *)(skb->data);
+	fc = le16_to_cpu(tx_hdr->frame_ctl);
+	bmcst = IS_MCAST(tx_hdr->addr1);
+
+	if ((fc & RTW_IEEE80211_FCTL_FTYPE) != RTW_IEEE80211_FTYPE_MGMT)
+		goto _exit;
+
+	pxmit_skb = rtw_skb_alloc(len + TXDESC_SIZE);
+
+	if(!pxmit_skb)
+		goto _exit;
+
+	pxmitbuf = pxmit_skb->data;
+
+	urb = usb_alloc_urb(0, GFP_ATOMIC);
+	if (!urb) {
+		goto _exit;
+	}
+
+	// ----- fill tx desc -----	
+	ptxdesc = (struct tx_desc *)pxmitbuf;	
+	_rtw_memset(ptxdesc, 0, sizeof(*ptxdesc));
+		
+	//offset 0	
+	ptxdesc->txdw0 |= cpu_to_le32(len&0x0000ffff); 
+	ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ)<<OFFSET_SHT)&0x00ff0000);//default = 32 bytes for TX Desc
+	ptxdesc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
+
+	if(bmcst)	
+	{
+		ptxdesc->txdw0 |= cpu_to_le32(BIT(24));
+	}	
+
+	//offset 4	
+	ptxdesc->txdw1 |= cpu_to_le32(0x00);//MAC_ID
+
+	ptxdesc->txdw1 |= cpu_to_le32((0x12<<QSEL_SHT)&0x00001f00);
+
+	ptxdesc->txdw1 |= cpu_to_le32((0x06<< 16) & 0x000f0000);//b mode
+
+	//offset 8			
+
+	//offset 12		
+	ptxdesc->txdw3 |= cpu_to_le32((le16_to_cpu(tx_hdr->seq_ctl)<<16)&0xffff0000);
+
+	//offset 16		
+	ptxdesc->txdw4 |= cpu_to_le32(BIT(8));//driver uses rate
+		
+	//offset 20
+
+
+	//HW append seq
+	ptxdesc->txdw4 |= cpu_to_le32(BIT(7)); // Hw set sequence number
+	ptxdesc->txdw3 |= cpu_to_le32((8 <<28)); //set bit3 to 1. Suugested by TimChen. 2009.12.29.
+	
+
+	rtl8188eu_cal_txdesc_chksum(ptxdesc);
+	// ----- end of fill tx desc -----
+
+	//
+	skb_put(pxmit_skb, len + TXDESC_SIZE);
+	pxmitbuf = pxmitbuf + TXDESC_SIZE;
+	_rtw_memcpy(pxmitbuf, skb->data, len);
+
+	//DBG_8192C("mgnt_xmit, len=%x\n", pxmit_skb->len);
+
+
+	// ----- prepare urb for submit -----
+	
+	//translate DMA FIFO addr to pipehandle
+	//pipe = ffaddr2pipehdl(pdvobj, MGT_QUEUE_INX);
+	pipe = usb_sndbulkpipe(pdvobj->pusbdev, pHalData->Queue2EPNum[(u8)MGT_QUEUE_INX]&0x0f);
+	
+	usb_fill_bulk_urb(urb, pdvobj->pusbdev, pipe,
+			  pxmit_skb->data, pxmit_skb->len, rtl8192cu_hostap_mgnt_xmit_cb, pxmit_skb);
+	
+	urb->transfer_flags |= URB_ZERO_PACKET;
+	usb_anchor_urb(urb, &phostapdpriv->anchored);
+	rc = usb_submit_urb(urb, GFP_ATOMIC);
+	if (rc < 0) {
+		usb_unanchor_urb(urb);
+		kfree_skb(skb);
+	}
+	usb_free_urb(urb);
+
+	
+_exit:	
+	
+	rtw_skb_free(skb);
+
+#endif
+
+	return 0;
+
+}
+#endif
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_halinit.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_halinit.c
new file mode 100644
index 00000000..97128ff2
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_halinit.c
@@ -0,0 +1,4616 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _HCI_HAL_INIT_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+#include "hal_com_h2c.h"
+
+#ifndef CONFIG_USB_HCI
+
+#error "CONFIG_USB_HCI shall be on!\n"
+
+#endif
+
+
+static VOID
+_ConfigNormalChipOutEP_8188E(
+	IN	PADAPTER	pAdapter,
+	IN	u8		NumOutPipe
+	)
+{	
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(pAdapter);
+
+	switch(NumOutPipe){
+		case 	3:
+				pHalData->OutEpQueueSel=TX_SELE_HQ| TX_SELE_LQ|TX_SELE_NQ;
+				pHalData->OutEpNumber=3;
+				break;
+		case 	2:
+				pHalData->OutEpQueueSel=TX_SELE_HQ| TX_SELE_NQ;
+				pHalData->OutEpNumber=2;
+				break;
+		case 	1:
+				pHalData->OutEpQueueSel=TX_SELE_HQ;
+				pHalData->OutEpNumber=1;
+				break;
+		default:				
+				break;
+			
+	}
+	DBG_871X("%s OutEpQueueSel(0x%02x), OutEpNumber(%d) \n",__FUNCTION__,pHalData->OutEpQueueSel,pHalData->OutEpNumber );
+
+}
+
+static BOOLEAN HalUsbSetQueuePipeMapping8188EUsb(
+	IN	PADAPTER	pAdapter,
+	IN	u8		NumInPipe,
+	IN	u8		NumOutPipe
+	)
+{
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(pAdapter);
+	BOOLEAN			result		= _FALSE;
+
+	_ConfigNormalChipOutEP_8188E(pAdapter, NumOutPipe);
+	
+	// Normal chip with one IN and one OUT doesn't have interrupt IN EP.
+	if(1 == pHalData->OutEpNumber){
+		if(1 != NumInPipe){
+			return result;
+		}
+	}
+
+	// All config other than above support one Bulk IN and one Interrupt IN.
+	//if(2 != NumInPipe){
+	//	return result;
+	//}
+
+	result = Hal_MappingOutPipe(pAdapter, NumOutPipe);
+	
+	return result;
+
+}
+
+void rtl8188eu_interface_configure(_adapter *padapter)
+{
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(padapter);
+	struct dvobj_priv	*pdvobjpriv = adapter_to_dvobj(padapter);
+
+	if (IS_HIGH_SPEED_USB(padapter))
+	{
+		pHalData->UsbBulkOutSize = USB_HIGH_SPEED_BULK_SIZE;//512 bytes
+	}
+	else
+	{
+		pHalData->UsbBulkOutSize = USB_FULL_SPEED_BULK_SIZE;//64 bytes
+	}
+
+	pHalData->interfaceIndex = pdvobjpriv->InterfaceNumber;
+
+#ifdef CONFIG_USB_TX_AGGREGATION
+	pHalData->UsbTxAggMode		= 1;
+	pHalData->UsbTxAggDescNum	= 0x1;	// only 4 bits
+#endif
+
+#ifdef CONFIG_USB_RX_AGGREGATION
+	pHalData->UsbRxAggMode		= USB_RX_AGG_DMA;// USB_RX_AGG_DMA;
+	pHalData->UsbRxAggBlockCount	= 8; //unit : 512b
+	pHalData->UsbRxAggBlockTimeout	= 0x6;
+	pHalData->UsbRxAggPageCount	= 48; //uint :128 b //0x0A;	// 10 = MAX_RX_DMA_BUFFER_SIZE/2/pHalData->UsbBulkOutSize
+	pHalData->UsbRxAggPageTimeout	= 0x4; //6, absolute time = 34ms/(2^6)
+#endif
+
+	HalUsbSetQueuePipeMapping8188EUsb(padapter,
+				pdvobjpriv->RtNumInPipes, pdvobjpriv->RtNumOutPipes);
+
+}
+
+static u32 _InitPowerOn_8188EU(_adapter *padapter)
+{
+	u16 value16;
+	// HW Power on sequence
+	u8 bMacPwrCtrlOn=_FALSE;
+
+	
+	rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
+	if(bMacPwrCtrlOn == _TRUE)	
+		return _SUCCESS;
+	
+	if(!HalPwrSeqCmdParsing(padapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_USB_MSK, Rtl8188E_NIC_PWR_ON_FLOW))
+	{
+		DBG_871X(KERN_ERR "%s: run power on flow fail\n", __func__);
+		return _FAIL;	
+	}
+
+	// Enable MAC DMA/WMAC/SCHEDULE/SEC block
+	// Set CR bit10 to enable 32k calibration. Suggested by SD1 Gimmy. Added by tynli. 2011.08.31.
+	rtw_write16(padapter, REG_CR, 0x00);  //suggseted by zhouzhou, by page, 20111230
+
+
+		// Enable MAC DMA/WMAC/SCHEDULE/SEC block
+	value16 = rtw_read16(padapter, REG_CR);
+	value16 |= (HCI_TXDMA_EN | HCI_RXDMA_EN | TXDMA_EN | RXDMA_EN
+				| PROTOCOL_EN | SCHEDULE_EN | ENSEC | CALTMR_EN);
+	// for SDIO - Set CR bit10 to enable 32k calibration. Suggested by SD1 Gimmy. Added by tynli. 2011.08.31.
+	
+	rtw_write16(padapter, REG_CR, value16);
+
+	bMacPwrCtrlOn = _TRUE;
+	rtw_hal_set_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
+
+
+	return _SUCCESS;
+
+}
+
+
+static void _dbg_dump_macreg(_adapter *padapter)
+{
+	u32 offset = 0;
+	u32 val32 = 0;
+	u32 index =0 ;
+	for(index=0;index<64;index++)
+	{
+		offset = index*4;
+		val32 = rtw_read32(padapter,offset);
+		DBG_8192C("offset : 0x%02x ,val:0x%08x\n",offset,val32);
+	}
+}
+
+
+static void _InitPABias(_adapter *padapter)
+{
+	HAL_DATA_TYPE		*pHalData	= GET_HAL_DATA(padapter);
+	u8			pa_setting;
+	BOOLEAN		is92C = IS_92C_SERIAL(pHalData->VersionID);
+	
+	//FIXED PA current issue
+	//efuse_one_byte_read(padapter, 0x1FA, &pa_setting);
+	pa_setting = EFUSE_Read1Byte(padapter, 0x1FA);
+
+	//RT_TRACE(COMP_INIT, DBG_LOUD, ("_InitPABias 0x1FA 0x%x \n",pa_setting));
+
+	if(!(pa_setting & BIT0))
+	{
+		PHY_SetRFReg(padapter, RF_PATH_A, 0x15, 0x0FFFFF, 0x0F406);
+		PHY_SetRFReg(padapter, RF_PATH_A, 0x15, 0x0FFFFF, 0x4F406);		
+		PHY_SetRFReg(padapter, RF_PATH_A, 0x15, 0x0FFFFF, 0x8F406);		
+		PHY_SetRFReg(padapter, RF_PATH_A, 0x15, 0x0FFFFF, 0xCF406);		
+		//RT_TRACE(COMP_INIT, DBG_LOUD, ("PA BIAS path A\n"));
+	}	
+
+	if(!(pa_setting & BIT1) && is92C)
+	{
+		PHY_SetRFReg(padapter,RF_PATH_B, 0x15, 0x0FFFFF, 0x0F406);
+		PHY_SetRFReg(padapter,RF_PATH_B, 0x15, 0x0FFFFF, 0x4F406);
+		PHY_SetRFReg(padapter,RF_PATH_B, 0x15, 0x0FFFFF, 0x8F406);
+		PHY_SetRFReg(padapter,RF_PATH_B, 0x15, 0x0FFFFF, 0xCF406);
+		//RT_TRACE(COMP_INIT, DBG_LOUD, ("PA BIAS path B\n"));
+	}
+
+	if(!(pa_setting & BIT4))
+	{
+		pa_setting = rtw_read8(padapter, 0x16);
+		pa_setting &= 0x0F;
+		rtw_write8(padapter, 0x16, pa_setting | 0x80);
+		rtw_write8(padapter, 0x16, pa_setting | 0x90);		
+	}
+}
+#ifdef CONFIG_BT_COEXIST
+static void _InitBTCoexist(_adapter *padapter)
+{
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(padapter);
+	struct btcoexist_priv	*pbtpriv = &(pHalData->bt_coexist);
+	u8 u1Tmp;
+
+	if(pbtpriv->BT_Coexist && pbtpriv->BT_CoexistType == BT_CSR_BC4)
+	{
+
+//#if MP_DRIVER != 1
+	if (padapter->registrypriv.mp_mode == 0)
+	{	
+		if(pbtpriv->BT_Ant_isolation)
+		{
+			rtw_write8( padapter,REG_GPIO_MUXCFG, 0xa0);
+			DBG_8192C("BT write 0x%x = 0x%x\n", REG_GPIO_MUXCFG, 0xa0);
+		}
+	}
+//#endif		
+
+		u1Tmp = rtw_read8(padapter, 0x4fd) & BIT0;
+		u1Tmp = u1Tmp | 
+				((pbtpriv->BT_Ant_isolation==1)?0:BIT1) | 
+				((pbtpriv->BT_Service==BT_SCO)?0:BIT2);
+		rtw_write8( padapter, 0x4fd, u1Tmp);
+		DBG_8192C("BT write 0x%x = 0x%x for non-isolation\n", 0x4fd, u1Tmp);
+		
+		
+		rtw_write32(padapter, REG_BT_COEX_TABLE+4, 0xaaaa9aaa);
+		DBG_8192C("BT write 0x%x = 0x%x\n", REG_BT_COEX_TABLE+4, 0xaaaa9aaa);
+		
+		rtw_write32(padapter, REG_BT_COEX_TABLE+8, 0xffbd0040);
+		DBG_8192C("BT write 0x%x = 0x%x\n", REG_BT_COEX_TABLE+8, 0xffbd0040);
+
+		rtw_write32(padapter,  REG_BT_COEX_TABLE+0xc, 0x40000010);
+		DBG_8192C("BT write 0x%x = 0x%x\n", REG_BT_COEX_TABLE+0xc, 0x40000010);
+
+		//Config to 1T1R
+		u1Tmp =  rtw_read8(padapter,rOFDM0_TRxPathEnable);
+		u1Tmp &= ~(BIT1);
+		rtw_write8( padapter, rOFDM0_TRxPathEnable, u1Tmp);
+		DBG_8192C("BT write 0xC04 = 0x%x\n", u1Tmp);
+			
+		u1Tmp = rtw_read8(padapter, rOFDM1_TRxPathEnable);
+		u1Tmp &= ~(BIT1);
+		rtw_write8( padapter, rOFDM1_TRxPathEnable, u1Tmp);
+		DBG_8192C("BT write 0xD04 = 0x%x\n", u1Tmp);
+
+	}
+}
+#endif
+
+
+
+//---------------------------------------------------------------
+//
+//	MAC init functions
+//
+//---------------------------------------------------------------
+static VOID
+_SetMacID(
+	IN  PADAPTER Adapter, u8* MacID
+	)
+{
+	u32 i;
+	for(i=0 ; i< MAC_ADDR_LEN ; i++){
+#ifdef  CONFIG_CONCURRENT_MODE		
+		if(Adapter->iface_type == IFACE_PORT1)
+			rtw_write32(Adapter, REG_MACID1+i, MacID[i]);
+		else
+#endif			
+		rtw_write32(Adapter, REG_MACID+i, MacID[i]);
+	}
+}
+
+static VOID
+_SetBSSID(
+	IN  PADAPTER Adapter, u8* BSSID
+	)
+{
+	u32 i;
+	for(i=0 ; i< MAC_ADDR_LEN ; i++){
+#ifdef  CONFIG_CONCURRENT_MODE		
+		if(Adapter->iface_type == IFACE_PORT1)
+			rtw_write32(Adapter, REG_BSSID1+i, BSSID[i]);
+		else
+#endif			
+		rtw_write32(Adapter, REG_BSSID+i, BSSID[i]);
+	}
+}
+
+
+// Shall USB interface init this?
+static VOID
+_InitInterrupt(
+	IN  PADAPTER Adapter
+	)
+{
+	u32	imr,imr_ex;
+	u8  usb_opt;
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+
+	//HISR write one to clear
+	rtw_write32(Adapter, REG_HISR_88E, 0xFFFFFFFF);
+	// HIMR - 	
+	imr = IMR_PSTIMEOUT_88E | IMR_TBDER_88E | IMR_CPWM_88E | IMR_CPWM2_88E ;		
+	rtw_write32(Adapter, REG_HIMR_88E, imr);
+	pHalData->IntrMask[0]=imr;
+	
+	imr_ex = IMR_TXERR_88E | IMR_RXERR_88E | IMR_TXFOVW_88E |IMR_RXFOVW_88E;	
+	rtw_write32(Adapter, REG_HIMRE_88E, imr_ex);
+	pHalData->IntrMask[1]=imr_ex;
+	
+#ifdef CONFIG_SUPPORT_USB_INT
+	// REG_USB_SPECIAL_OPTION - BIT(4)
+	// 0; Use interrupt endpoint to upload interrupt pkt
+	// 1; Use bulk endpoint to upload interrupt pkt,	
+	usb_opt = rtw_read8(Adapter, REG_USB_SPECIAL_OPTION);
+
+	if((IS_FULL_SPEED_USB(Adapter))
+		#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+		|| pHalData->RtIntInPipe == 0x05
+		#endif
+	)
+		usb_opt = usb_opt & (~INT_BULK_SEL);
+	else	
+		usb_opt = usb_opt | (INT_BULK_SEL);
+
+	rtw_write8(Adapter, REG_USB_SPECIAL_OPTION, usb_opt );			
+
+#endif//CONFIG_SUPPORT_USB_INT
+	
+}
+
+
+static VOID
+_InitQueueReservedPage(
+	IN  PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);
+	struct registry_priv	*pregistrypriv = &Adapter->registrypriv;
+	u32			outEPNum	= (u32)pHalData->OutEpNumber;
+	u32			numHQ		= NORMAL_PAGE_NUM_HPQ_88E;
+	u32			numLQ		= NORMAL_PAGE_NUM_LPQ_88E;
+	u32			numNQ		= NORMAL_PAGE_NUM_NPQ_88E;
+	u32			numPubQ	= 0x00;
+	u32			value32;
+	u8			value8;
+	BOOLEAN			bWiFiConfig	= pregistrypriv->wifi_spec;
+
+	if(bWiFiConfig || pregistrypriv->qos_opt_enable)
+	{
+		if (pHalData->OutEpQueueSel & TX_SELE_HQ)
+		{
+			numHQ =  WMM_NORMAL_PAGE_NUM_HPQ_88E;
+		}
+
+		if (pHalData->OutEpQueueSel & TX_SELE_LQ)
+		{
+			numLQ = WMM_NORMAL_PAGE_NUM_LPQ_88E;
+		}
+
+		// NOTE: This step shall be proceed before writting REG_RQPN.
+		if (pHalData->OutEpQueueSel & TX_SELE_NQ) {
+			numNQ = WMM_NORMAL_PAGE_NUM_NPQ_88E;
+		}
+	}
+
+	value8 = (u8)_NPQ(numNQ);
+	rtw_write8(Adapter, REG_RQPN_NPQ, value8);
+
+	numPubQ = TX_TOTAL_PAGE_NUMBER_88E - numHQ - numLQ - numNQ;
+
+	// TX DMA
+	value32 = _HPQ(numHQ) | _LPQ(numLQ) | _PUBQ(numPubQ) | LD_RQPN;
+	rtw_write32(Adapter, REG_RQPN, value32);
+}
+
+static VOID
+_InitTxBufferBoundary(
+	IN PADAPTER Adapter,
+	IN u8 txpktbuf_bndy
+	)
+{	
+	struct registry_priv *pregistrypriv = &Adapter->registrypriv;
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	//u16	txdmactrl;
+
+	rtw_write8(Adapter, REG_BCNQ_BDNY, txpktbuf_bndy);
+	rtw_write8(Adapter, REG_MGQ_BDNY, txpktbuf_bndy);
+	rtw_write8(Adapter, REG_WMAC_LBK_BF_HD, txpktbuf_bndy);
+	rtw_write8(Adapter, REG_TRXFF_BNDY, txpktbuf_bndy);
+	rtw_write8(Adapter, REG_TDECTRL+1, txpktbuf_bndy);
+
+}
+
+static VOID
+_InitPageBoundary(
+	IN  PADAPTER Adapter
+	)
+{
+	// RX Page Boundary	
+	// 	
+	u16 rxff_bndy = MAX_RX_DMA_BUFFER_SIZE_88E-1;
+
+	#if 0
+
+	// RX Page Boundary
+	//srand(static_cast<unsigned int>(time(NULL)) );
+	if(bSupportRemoteWakeUp)
+	{
+		Offset = MAX_RX_DMA_BUFFER_SIZE_88E+MAX_TX_REPORT_BUFFER_SIZE-MAX_SUPPORT_WOL_PATTERN_NUM(Adapter)*WKFMCAM_SIZE;
+		Offset = Offset / 128; // RX page size = 128 byte
+		rxff_bndy= (Offset*128) -1;	
+	}
+	else
+		
+	#endif
+	rtw_write16(Adapter, (REG_TRXFF_BNDY + 2), rxff_bndy);
+}
+
+
+static VOID
+_InitNormalChipRegPriority(
+	IN	PADAPTER	Adapter,
+	IN	u16		beQ,
+	IN	u16		bkQ,
+	IN	u16		viQ,
+	IN	u16		voQ,
+	IN	u16		mgtQ,
+	IN	u16		hiQ
+	)
+{
+	u16 value16	= (rtw_read16(Adapter, REG_TRXDMA_CTRL) & 0x7);
+
+	value16 |=	_TXDMA_BEQ_MAP(beQ) 	| _TXDMA_BKQ_MAP(bkQ) |
+				_TXDMA_VIQ_MAP(viQ) 	| _TXDMA_VOQ_MAP(voQ) |
+				_TXDMA_MGQ_MAP(mgtQ)| _TXDMA_HIQ_MAP(hiQ);
+	
+	rtw_write16(Adapter, REG_TRXDMA_CTRL, value16);
+}
+
+static VOID
+_InitNormalChipOneOutEpPriority(
+	IN	PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+
+	u16	value = 0;
+	switch(pHalData->OutEpQueueSel)
+	{
+		case TX_SELE_HQ:
+			value = QUEUE_HIGH;
+			break;
+		case TX_SELE_LQ:
+			value = QUEUE_LOW;
+			break;
+		case TX_SELE_NQ:
+			value = QUEUE_NORMAL;
+			break;
+		default:
+			//RT_ASSERT(FALSE,("Shall not reach here!\n"));
+			break;
+	}
+	
+	_InitNormalChipRegPriority(Adapter,
+								value,
+								value,
+								value,
+								value,
+								value,
+								value
+								);
+
+}
+
+static VOID
+_InitNormalChipTwoOutEpPriority(
+	IN	PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+	struct registry_priv *pregistrypriv = &Adapter->registrypriv;
+	u16			beQ,bkQ,viQ,voQ,mgtQ,hiQ;
+	
+
+	u16	valueHi = 0;
+	u16	valueLow = 0;
+	
+	switch(pHalData->OutEpQueueSel)
+	{
+		case (TX_SELE_HQ | TX_SELE_LQ):
+			valueHi = QUEUE_HIGH;
+			valueLow = QUEUE_LOW;
+			break;
+		case (TX_SELE_NQ | TX_SELE_LQ):
+			valueHi = QUEUE_NORMAL;
+			valueLow = QUEUE_LOW;
+			break;
+		case (TX_SELE_HQ | TX_SELE_NQ):
+			valueHi = QUEUE_HIGH;
+			valueLow = QUEUE_NORMAL;
+			break;
+		default:
+			//RT_ASSERT(FALSE,("Shall not reach here!\n"));
+			break;
+	}
+
+	if(!pregistrypriv->wifi_spec ){
+		beQ		= valueLow;
+		bkQ		= valueLow;
+		viQ		= valueHi;
+		voQ		= valueHi;
+		mgtQ	= valueHi; 
+		hiQ		= valueHi;								
+	}
+	else{//for WMM ,CONFIG_OUT_EP_WIFI_MODE
+		beQ		= valueLow;
+		bkQ		= valueHi;		
+		viQ		= valueHi;
+		voQ		= valueLow;
+		mgtQ	= valueHi;
+		hiQ		= valueHi;							
+	}
+
+	_InitNormalChipRegPriority(Adapter,beQ,bkQ,viQ,voQ,mgtQ,hiQ);
+
+}
+
+static VOID
+_InitNormalChipThreeOutEpPriority(
+	IN	PADAPTER Adapter
+	)
+{
+	struct registry_priv *pregistrypriv = &Adapter->registrypriv;
+	u16			beQ,bkQ,viQ,voQ,mgtQ,hiQ;
+
+	if(!pregistrypriv->wifi_spec ){// typical setting
+		beQ		= QUEUE_LOW;
+		bkQ 		= QUEUE_LOW;
+		viQ 		= QUEUE_NORMAL;
+		voQ 		= QUEUE_HIGH;
+		mgtQ 	= QUEUE_HIGH;
+		hiQ 		= QUEUE_HIGH;			
+	}
+	else{// for WMM
+		beQ		= QUEUE_LOW;
+		bkQ 		= QUEUE_NORMAL;
+		viQ 		= QUEUE_NORMAL;
+		voQ 		= QUEUE_HIGH;
+		mgtQ 	= QUEUE_HIGH;
+		hiQ 		= QUEUE_HIGH;			
+	}
+	_InitNormalChipRegPriority(Adapter,beQ,bkQ,viQ,voQ,mgtQ,hiQ);
+}
+
+static VOID
+_InitQueuePriority(
+	IN	PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+
+	switch(pHalData->OutEpNumber)
+	{
+		case 1:
+			_InitNormalChipOneOutEpPriority(Adapter);
+			break;
+		case 2:
+			_InitNormalChipTwoOutEpPriority(Adapter);
+			break;
+		case 3:
+			_InitNormalChipThreeOutEpPriority(Adapter);
+			break;
+		default:
+			//RT_ASSERT(FALSE,("Shall not reach here!\n"));
+			break;
+	}
+
+
+}
+
+
+
+static VOID
+_InitHardwareDropIncorrectBulkOut(
+	IN  PADAPTER Adapter
+	)
+{
+#ifdef ENABLE_USB_DROP_INCORRECT_OUT
+	u32	value32 = rtw_read32(Adapter, REG_TXDMA_OFFSET_CHK);
+	value32 |= DROP_DATA_EN;
+	rtw_write32(Adapter, REG_TXDMA_OFFSET_CHK, value32);
+#endif
+}
+
+static VOID
+_InitNetworkType(
+	IN  PADAPTER Adapter
+	)
+{
+	u32	value32;
+
+	value32 = rtw_read32(Adapter, REG_CR);
+	// TODO: use the other function to set network type
+	value32 = (value32 & ~MASK_NETTYPE) | _NETTYPE(NT_LINK_AP);
+
+	rtw_write32(Adapter, REG_CR, value32);
+//	RASSERT(pIoBase->rtw_read8(REG_CR + 2) == 0x2);
+}
+
+
+static VOID
+_InitDriverInfoSize(
+	IN  PADAPTER	Adapter,
+	IN	u8		drvInfoSize
+	)
+{
+	rtw_write8(Adapter,REG_RX_DRVINFO_SZ, drvInfoSize);
+}
+
+static VOID
+_InitWMACSetting(
+	IN  PADAPTER Adapter
+	)
+{
+	//u4Byte			value32;
+	//u16			value16;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+
+	//pHalData->ReceiveConfig = AAP | APM | AM | AB | APP_ICV | ADF | AMF | APP_FCS | HTC_LOC_CTRL | APP_MIC | APP_PHYSTS;
+	//pHalData->ReceiveConfig = 
+	//RCR_AAP | RCR_APM | RCR_AM | RCR_AB |RCR_CBSSID_DATA| RCR_CBSSID_BCN| RCR_APP_ICV | RCR_AMF | RCR_HTC_LOC_CTRL | RCR_APP_MIC | RCR_APP_PHYSTS;	  
+	 // don't turn on AAP, it will allow all packets to driver
+        pHalData->ReceiveConfig = RCR_APM | RCR_AM | RCR_AB |RCR_CBSSID_DATA| RCR_CBSSID_BCN| RCR_APP_ICV | RCR_AMF | RCR_HTC_LOC_CTRL | RCR_APP_MIC | RCR_APP_PHYST_RXFF;	 
+	 
+#if (1 == RTL8188E_RX_PACKET_INCLUDE_CRC)
+	pHalData->ReceiveConfig |= ACRC32;
+#endif
+
+	// some REG_RCR will be modified later by phy_ConfigMACWithHeaderFile()
+	rtw_write32(Adapter, REG_RCR, pHalData->ReceiveConfig);
+
+	// Accept all multicast address
+	rtw_write32(Adapter, REG_MAR, 0xFFFFFFFF);
+	rtw_write32(Adapter, REG_MAR + 4, 0xFFFFFFFF);
+
+
+	// Accept all data frames
+	//value16 = 0xFFFF;
+	//rtw_write16(Adapter, REG_RXFLTMAP2, value16);
+
+	// 2010.09.08 hpfan
+	// Since ADF is removed from RCR, ps-poll will not be indicate to driver,
+	// RxFilterMap should mask ps-poll to gurantee AP mode can rx ps-poll.
+	//value16 = 0x400;
+	//rtw_write16(Adapter, REG_RXFLTMAP1, value16);
+
+	// Accept all management frames
+	//value16 = 0xFFFF;
+	//rtw_write16(Adapter, REG_RXFLTMAP0, value16);
+
+	//enable RX_SHIFT bits
+	//rtw_write8(Adapter, REG_TRXDMA_CTRL, rtw_read8(Adapter, REG_TRXDMA_CTRL)|BIT(1));	
+
+}
+
+static VOID
+_InitAdaptiveCtrl(
+	IN  PADAPTER Adapter
+	)
+{
+	u16	value16;
+	u32	value32;
+
+	// Response Rate Set
+	value32 = rtw_read32(Adapter, REG_RRSR);
+	value32 &= ~RATE_BITMAP_ALL;
+	value32 |= RATE_RRSR_CCK_ONLY_1M;
+	rtw_write32(Adapter, REG_RRSR, value32);
+
+	// CF-END Threshold
+	//m_spIoBase->rtw_write8(REG_CFEND_TH, 0x1);
+
+	// SIFS (used in NAV)
+	value16 = _SPEC_SIFS_CCK(0x10) | _SPEC_SIFS_OFDM(0x10);
+	rtw_write16(Adapter, REG_SPEC_SIFS, value16);
+
+	// Retry Limit
+	value16 = _LRL(0x30) | _SRL(0x30);
+	rtw_write16(Adapter, REG_RL, value16);
+	
+}
+
+static VOID
+_InitRateFallback(
+	IN  PADAPTER Adapter
+	)
+{
+	// Set Data Auto Rate Fallback Retry Count register.
+	rtw_write32(Adapter, REG_DARFRC, 0x00000000);
+	rtw_write32(Adapter, REG_DARFRC+4, 0x10080404);
+	rtw_write32(Adapter, REG_RARFRC, 0x04030201);
+	rtw_write32(Adapter, REG_RARFRC+4, 0x08070605);
+
+}
+
+
+static VOID
+_InitEDCA(
+	IN  PADAPTER Adapter
+	)
+{
+	// Set Spec SIFS (used in NAV)
+	rtw_write16(Adapter,REG_SPEC_SIFS, 0x100a);
+	rtw_write16(Adapter,REG_MAC_SPEC_SIFS, 0x100a);
+
+	// Set SIFS for CCK
+	rtw_write16(Adapter,REG_SIFS_CTX, 0x100a);	
+
+	// Set SIFS for OFDM
+	rtw_write16(Adapter,REG_SIFS_TRX, 0x100a);
+
+	// TXOP
+	rtw_write32(Adapter, REG_EDCA_BE_PARAM, 0x005EA42B);
+	rtw_write32(Adapter, REG_EDCA_BK_PARAM, 0x0000A44F);
+	rtw_write32(Adapter, REG_EDCA_VI_PARAM, 0x005EA324);
+	rtw_write32(Adapter, REG_EDCA_VO_PARAM, 0x002FA226);
+}
+
+
+static VOID
+_InitBeaconMaxError(
+	IN  PADAPTER	Adapter,
+	IN	BOOLEAN		InfraMode
+	)
+{
+
+}
+
+
+#ifdef CONFIG_LED
+static void _InitHWLed(PADAPTER Adapter)
+{
+	struct led_priv *pledpriv = &(Adapter->ledpriv);
+	
+	if( pledpriv->LedStrategy != HW_LED)
+		return;
+	
+// HW led control
+// to do .... 
+//must consider cases of antenna diversity/ commbo card/solo card/mini card
+
+}
+#endif //CONFIG_LED
+
+static VOID
+_InitRDGSetting(
+	IN	PADAPTER Adapter
+	)
+{
+	rtw_write8(Adapter,REG_RD_CTRL,0xFF);
+	rtw_write16(Adapter, REG_RD_NAV_NXT, 0x200);
+	rtw_write8(Adapter,REG_RD_RESP_PKT_TH,0x05);
+}
+
+static VOID
+_InitRxSetting(
+	IN	PADAPTER Adapter
+	)
+{
+	rtw_write32(Adapter, REG_MACID, 0x87654321);
+	rtw_write32(Adapter, 0x0700, 0x87654321);
+}
+
+static VOID
+_InitRetryFunction(
+	IN  PADAPTER Adapter
+	)
+{
+	u8	value8;
+	
+	value8 = rtw_read8(Adapter, REG_FWHW_TXQ_CTRL);
+	value8 |= EN_AMPDU_RTY_NEW;
+	rtw_write8(Adapter, REG_FWHW_TXQ_CTRL, value8);
+
+	// Set ACK timeout
+	rtw_write8(Adapter, REG_ACKTO, 0x40);
+}
+
+/*-----------------------------------------------------------------------------
+ * Function:	usb_AggSettingTxUpdate()
+ *
+ * Overview:	Seperate TX/RX parameters update independent for TP detection and 
+ *			dynamic TX/RX aggreagtion parameters update.
+ *
+ * Input:			PADAPTER
+ *
+ * Output/Return:	NONE
+ *
+ * Revised History:
+ *	When		Who		Remark
+ *	12/10/2010	MHC		Seperate to smaller function.
+ *
+ *---------------------------------------------------------------------------*/
+static VOID
+usb_AggSettingTxUpdate(
+	IN	PADAPTER			Adapter
+	)
+{
+#ifdef CONFIG_USB_TX_AGGREGATION
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	//PMGNT_INFO		pMgntInfo = &(Adapter->MgntInfo);	
+	u32			value32;
+
+	if(Adapter->registrypriv.wifi_spec)
+		pHalData->UsbTxAggMode = _FALSE;
+
+	if(pHalData->UsbTxAggMode){
+		value32 = rtw_read32(Adapter, REG_TDECTRL);
+		value32 = value32 & ~(BLK_DESC_NUM_MASK << BLK_DESC_NUM_SHIFT);
+		value32 |= ((pHalData->UsbTxAggDescNum & BLK_DESC_NUM_MASK) << BLK_DESC_NUM_SHIFT);
+		
+		rtw_write32(Adapter, REG_TDECTRL, value32);
+	}
+	
+#endif
+}	// usb_AggSettingTxUpdate
+
+
+/*-----------------------------------------------------------------------------
+ * Function:	usb_AggSettingRxUpdate()
+ *
+ * Overview:	Seperate TX/RX parameters update independent for TP detection and 
+ *			dynamic TX/RX aggreagtion parameters update.
+ *
+ * Input:			PADAPTER
+ *
+ * Output/Return:	NONE
+ *
+ * Revised History:
+ *	When		Who		Remark
+ *	12/10/2010	MHC		Seperate to smaller function.
+ *
+ *---------------------------------------------------------------------------*/
+static VOID
+usb_AggSettingRxUpdate(
+	IN	PADAPTER			Adapter
+	)
+{
+#ifdef CONFIG_USB_RX_AGGREGATION
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	//PMGNT_INFO		pMgntInfo = &(Adapter->MgntInfo);
+	u8			valueDMA;
+	u8			valueUSB;
+
+	valueDMA = rtw_read8(Adapter, REG_TRXDMA_CTRL);
+	valueUSB = rtw_read8(Adapter, REG_USB_SPECIAL_OPTION);
+
+	switch(pHalData->UsbRxAggMode)
+	{
+		case USB_RX_AGG_DMA:
+			valueDMA |= RXDMA_AGG_EN;
+			valueUSB &= ~USB_AGG_EN;
+			break;
+		case USB_RX_AGG_USB:
+			valueDMA &= ~RXDMA_AGG_EN;
+			valueUSB |= USB_AGG_EN;
+			break;
+		case USB_RX_AGG_MIX:
+			valueDMA |= RXDMA_AGG_EN;
+			valueUSB |= USB_AGG_EN;
+			break;
+		case USB_RX_AGG_DISABLE:
+		default:
+			valueDMA &= ~RXDMA_AGG_EN;
+			valueUSB &= ~USB_AGG_EN;
+			break;
+	}
+
+	rtw_write8(Adapter, REG_TRXDMA_CTRL, valueDMA);
+	rtw_write8(Adapter, REG_USB_SPECIAL_OPTION, valueUSB);
+
+	switch(pHalData->UsbRxAggMode)
+	{
+		case USB_RX_AGG_DMA:
+			rtw_write8(Adapter, REG_RXDMA_AGG_PG_TH, pHalData->UsbRxAggPageCount);
+			rtw_write8(Adapter, REG_RXDMA_AGG_PG_TH+1, pHalData->UsbRxAggPageTimeout);
+			break;
+		case USB_RX_AGG_USB:
+			rtw_write8(Adapter, REG_USB_AGG_TH, pHalData->UsbRxAggBlockCount);
+			rtw_write8(Adapter, REG_USB_AGG_TO, pHalData->UsbRxAggBlockTimeout);
+			break;
+		case USB_RX_AGG_MIX:
+			rtw_write8(Adapter, REG_RXDMA_AGG_PG_TH, pHalData->UsbRxAggPageCount);
+			rtw_write8(Adapter, REG_RXDMA_AGG_PG_TH+1, (pHalData->UsbRxAggPageTimeout& 0x1F));//0x280[12:8]
+			
+			rtw_write8(Adapter, REG_USB_AGG_TH, pHalData->UsbRxAggBlockCount);
+			rtw_write8(Adapter, REG_USB_AGG_TO, pHalData->UsbRxAggBlockTimeout);			
+		
+			break;
+		case USB_RX_AGG_DISABLE:
+		default:
+			// TODO: 
+			break;
+	}
+
+	switch(PBP_128)
+	{
+		case PBP_128:
+			pHalData->HwRxPageSize = 128;
+			break;
+		case PBP_64:
+			pHalData->HwRxPageSize = 64;
+			break;
+		case PBP_256:
+			pHalData->HwRxPageSize = 256;
+			break;
+		case PBP_512:
+			pHalData->HwRxPageSize = 512;
+			break;
+		case PBP_1024:
+			pHalData->HwRxPageSize = 1024;
+			break;
+		default:
+			//RT_ASSERT(FALSE, ("RX_PAGE_SIZE_REG_VALUE definition is incorrect!\n"));
+			break;
+	}
+#endif
+}	// usb_AggSettingRxUpdate
+
+static VOID
+InitUsbAggregationSetting(
+	IN  PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+
+	// Tx aggregation setting
+	usb_AggSettingTxUpdate(Adapter);
+
+	// Rx aggregation setting
+	usb_AggSettingRxUpdate(Adapter);
+
+	// 201/12/10 MH Add for USB agg mode dynamic switch.
+	pHalData->UsbRxHighSpeedMode = _FALSE;
+}
+VOID
+HalRxAggr8188EUsb(
+	IN  PADAPTER Adapter,
+	IN BOOLEAN	Value
+	)
+{
+#if 0//USB_RX_AGGREGATION_92C
+
+	PMGNT_INFO		pMgntInfo = &Adapter->MgntInfo;
+	u1Byte			valueDMATimeout;
+	u1Byte			valueDMAPageCount;
+	u1Byte			valueUSBTimeout;
+	u1Byte			valueUSBBlockCount;
+
+	// selection to prevent bad TP.
+	if( IS_WIRELESS_MODE_B(Adapter) || IS_WIRELESS_MODE_G(Adapter) || IS_WIRELESS_MODE_A(Adapter)|| pMgntInfo->bWiFiConfg)
+	{
+		// 2010.04.27 hpfan
+		// Adjust RxAggrTimeout to close to zero disable RxAggr, suggested by designer
+		// Timeout value is calculated by 34 / (2^n)
+		valueDMATimeout = 0x0f;
+		valueDMAPageCount = 0x01;
+		valueUSBTimeout = 0x0f;
+		valueUSBBlockCount = 0x01;
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_PGTO, (pu1Byte)&valueDMATimeout);
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_PGTH, (pu1Byte)&valueDMAPageCount);
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_USBTO, (pu1Byte)&valueUSBTimeout);
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_USBTH, (pu1Byte)&valueUSBBlockCount);
+	}
+	else
+	{
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_USBTO, (pu1Byte)&pMgntInfo->RegRxAggBlockTimeout);
+		rtw_hal_set_hwreg(Adapter, HW_VAR_RX_AGGR_USBTH, (pu1Byte)&pMgntInfo->RegRxAggBlockCount);
+	}
+
+#endif
+}
+
+/*-----------------------------------------------------------------------------
+ * Function:	USB_AggModeSwitch()
+ *
+ * Overview:	When RX traffic is more than 40M, we need to adjust some parameters to increase
+ *			RX speed by increasing batch indication size. This will decrease TCP ACK speed, we
+ *			need to monitor the influence of FTP/network share.
+ *			For TX mode, we are still ubder investigation.
+ *
+ * Input:		PADAPTER
+ *
+ * Output:		NONE
+ *
+ * Return:		NONE
+ *
+ * Revised History:
+ *	When		Who		Remark
+ *	12/10/2010	MHC		Create Version 0.  
+ *
+ *---------------------------------------------------------------------------*/
+VOID
+USB_AggModeSwitch(
+	IN	PADAPTER			Adapter
+	)
+{
+#if 0
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	PMGNT_INFO		pMgntInfo = &(Adapter->MgntInfo);
+
+	//pHalData->UsbRxHighSpeedMode = FALSE;
+	// How to measure the RX speed? We assume that when traffic is more than 
+	if (pMgntInfo->bRegAggDMEnable == FALSE)
+	{
+		return;	// Inf not support.
+	}
+	
+	
+	if (pMgntInfo->LinkDetectInfo.bHigherBusyRxTraffic == TRUE && 
+		pHalData->UsbRxHighSpeedMode == FALSE)
+	{
+		pHalData->UsbRxHighSpeedMode = TRUE;
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("UsbAggModeSwitchCheck to HIGH\n"));
+	}
+	else if (pMgntInfo->LinkDetectInfo.bHigherBusyRxTraffic == FALSE && 
+		pHalData->UsbRxHighSpeedMode == TRUE)
+	{
+		pHalData->UsbRxHighSpeedMode = FALSE;
+		RT_TRACE(COMP_INIT, DBG_LOUD, ("UsbAggModeSwitchCheck to LOW\n"));
+	}
+	else
+	{
+		return; 
+	}
+	
+
+#if USB_RX_AGGREGATION_92C
+	if (pHalData->UsbRxHighSpeedMode == TRUE)	
+	{
+		// 2010/12/10 MH The parameter is tested by SD1 engineer and SD3 channel emulator.
+		// USB mode
+#if (RT_PLATFORM == PLATFORM_LINUX)
+		if (pMgntInfo->LinkDetectInfo.bTxBusyTraffic)
+		{
+			pHalData->RxAggBlockCount	= 16;
+			pHalData->RxAggBlockTimeout	= 7;
+		}
+		else
+#endif
+		{
+			pHalData->RxAggBlockCount	= 40;
+			pHalData->RxAggBlockTimeout	= 5;
+		}
+		// Mix mode
+		pHalData->RxAggPageCount	= 72;
+		pHalData->RxAggPageTimeout	= 6;		
+	}
+	else
+	{
+		// USB mode
+		pHalData->RxAggBlockCount	= pMgntInfo->RegRxAggBlockCount;
+		pHalData->RxAggBlockTimeout	= pMgntInfo->RegRxAggBlockTimeout;	
+		// Mix mode
+		pHalData->RxAggPageCount		= pMgntInfo->RegRxAggPageCount;
+		pHalData->RxAggPageTimeout	= pMgntInfo->RegRxAggPageTimeout;	
+	}
+
+	if (pHalData->RxAggBlockCount > MAX_RX_AGG_BLKCNT)
+		pHalData->RxAggBlockCount = MAX_RX_AGG_BLKCNT;
+#if (OS_WIN_FROM_VISTA(OS_VERSION)) || (RT_PLATFORM == PLATFORM_LINUX)	// do not support WINXP to prevent usbehci.sys BSOD
+	if (IS_WIRELESS_MODE_N_24G(Adapter) || IS_WIRELESS_MODE_N_5G(Adapter))
+	{
+		//
+		// 2010/12/24 MH According to V1012 QC IOT test, XP BSOD happen when running chariot test
+		// with the aggregation dynamic change!! We need to disable the function to prevent it is broken
+		// in usbehci.sys.
+		//
+		usb_AggSettingRxUpdate_8188E(Adapter);
+
+		// 2010/12/27 MH According to designer's suggstion, we can only modify Timeout value. Otheriwse
+		// there might many HW incorrect behavior, the XP BSOD at usbehci.sys may be relative to the 
+		// issue. Base on the newest test, we can not enable block cnt > 30, otherwise XP usbehci.sys may
+		// BSOD.
+	}
+#endif
+	
+#endif
+#endif
+}	// USB_AggModeSwitch
+
+static VOID
+_InitOperationMode(
+	IN	PADAPTER			Adapter
+	)
+{
+#if 0//gtest
+	PHAL_DATA_TYPE	pHalData = GET_HAL_DATA(Adapter);
+	u1Byte				regBwOpMode = 0;
+	u4Byte				regRATR = 0, regRRSR = 0;
+
+
+	//1 This part need to modified according to the rate set we filtered!!
+	//
+	// Set RRSR, RATR, and REG_BWOPMODE registers
+	//
+	switch(Adapter->RegWirelessMode)
+	{
+		case WIRELESS_MODE_B:
+			regBwOpMode = BW_OPMODE_20MHZ;
+			regRATR = RATE_ALL_CCK;
+			regRRSR = RATE_ALL_CCK;
+			break;
+		case WIRELESS_MODE_A:
+			regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
+			regRATR = RATE_ALL_OFDM_AG;
+			regRRSR = RATE_ALL_OFDM_AG;
+			break;
+		case WIRELESS_MODE_G:
+			regBwOpMode = BW_OPMODE_20MHZ;
+			regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			break;
+		case WIRELESS_MODE_AUTO:
+			if (Adapter->bInHctTest)
+			{
+			    regBwOpMode = BW_OPMODE_20MHZ;
+			    regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			    regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			}
+			else
+			{
+			    regBwOpMode = BW_OPMODE_20MHZ;
+			    regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
+			    regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			}
+			break;
+		case WIRELESS_MODE_N_24G:
+			// It support CCK rate by default.
+			// CCK rate will be filtered out only when associated AP does not support it.
+			regBwOpMode = BW_OPMODE_20MHZ;
+				regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
+				regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
+			break;
+		case WIRELESS_MODE_N_5G:
+			regBwOpMode = BW_OPMODE_5G;
+			regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
+			regRRSR = RATE_ALL_OFDM_AG;
+			break;
+			
+		default: //for MacOSX compiler warning.
+			break;
+	}
+
+	// Ziv ????????
+	//PlatformEFIOWrite4Byte(Adapter, REG_INIRTS_RATE_SEL, regRRSR);
+	PlatformEFIOWrite1Byte(Adapter, REG_BWOPMODE, regBwOpMode);
+#endif
+}
+
+
+ static VOID
+_InitBeaconParameters(
+	IN  PADAPTER Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+
+	rtw_write16(Adapter, REG_BCN_CTRL, 0x1010);
+
+	// TODO: Remove these magic number
+	rtw_write16(Adapter, REG_TBTT_PROHIBIT,0x6404);// ms
+	rtw_write8(Adapter, REG_DRVERLYINT, DRIVER_EARLY_INT_TIME_8188E);// 5ms
+	rtw_write8(Adapter, REG_BCNDMATIM, BCN_DMA_ATIME_INT_TIME_8188E); // 2ms
+
+	// Suggested by designer timchen. Change beacon AIFS to the largest number
+	// beacause test chip does not contension before sending beacon. by tynli. 2009.11.03
+	rtw_write16(Adapter, REG_BCNTCFG, 0x660F);
+
+	pHalData->RegBcnCtrlVal = rtw_read8(Adapter, REG_BCN_CTRL);
+	pHalData->RegTxPause = rtw_read8(Adapter, REG_TXPAUSE); 
+	pHalData->RegFwHwTxQCtrl = rtw_read8(Adapter, REG_FWHW_TXQ_CTRL+2);
+	pHalData->RegReg542 = rtw_read8(Adapter, REG_TBTT_PROHIBIT+2);
+	pHalData->RegCR_1 = rtw_read8(Adapter, REG_CR+1);
+}
+
+static VOID
+_InitRFType(
+	IN	PADAPTER Adapter
+	)
+{
+	struct registry_priv	 *pregpriv = &Adapter->registrypriv;
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+	BOOLEAN			is92CU		= IS_92C_SERIAL(pHalData->VersionID);
+
+#if	DISABLE_BB_RF
+	pHalData->rf_chip	= RF_PSEUDO_11N;
+	return;
+#endif
+
+	pHalData->rf_chip	= RF_6052;
+
+	if(_FALSE == is92CU){
+		pHalData->rf_type = RF_1T1R;
+		DBG_8192C("Set RF Chip ID to RF_6052 and RF type to 1T1R.\n");
+		return;
+	}
+
+	// TODO: Consider that EEPROM set 92CU to 1T1R later.
+	// Force to overwrite setting according to chip version. Ignore EEPROM setting.
+	//pHalData->RF_Type = is92CU ? RF_2T2R : RF_1T1R;
+	MSG_8192C("Set RF Chip ID to RF_6052 and RF type to %d.\n", pHalData->rf_type);
+
+}
+
+
+static VOID
+_BeaconFunctionEnable(
+	IN	PADAPTER		Adapter,
+	IN	BOOLEAN			Enable,
+	IN	BOOLEAN			Linked
+	)
+{
+	rtw_write8(Adapter, REG_BCN_CTRL, (BIT4 | BIT3 | BIT1));
+	//SetBcnCtrlReg(Adapter, (BIT4 | BIT3 | BIT1), 0x00);
+	//RT_TRACE(COMP_BEACON, DBG_LOUD, ("_BeaconFunctionEnable 0x550 0x%x\n", PlatformEFIORead1Byte(Adapter, 0x550)));			
+
+	rtw_write8(Adapter, REG_RD_CTRL+1, 0x6F);	
+}
+
+
+// Set CCK and OFDM Block "ON"
+static VOID _BBTurnOnBlock(
+	IN	PADAPTER		Adapter
+	)
+{
+#if (DISABLE_BB_RF)
+	return;
+#endif
+
+	PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bCCKEn, 0x1);
+	PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bOFDMEn, 0x1);
+}
+
+static VOID _RfPowerSave(
+	IN	PADAPTER		Adapter
+	)
+{
+#if 0
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+	PMGNT_INFO		pMgntInfo	= &(Adapter->MgntInfo);
+	u1Byte			eRFPath;
+
+#if (DISABLE_BB_RF)
+	return;
+#endif
+
+	if(pMgntInfo->RegRfOff == TRUE){ // User disable RF via registry.
+		RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter8192CUsb(): Turn off RF for RegRfOff.\n"));
+		MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
+		// Those action will be discard in MgntActSet_RF_State because off the same state
+		for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
+			PHY_SetRFReg(Adapter, eRFPath, 0x4, 0xC00, 0x0);
+	}
+	else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS){ // H/W or S/W RF OFF before sleep.
+		RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter8192CUsb(): Turn off RF for RfOffReason(%ld).\n", pMgntInfo->RfOffReason));
+		MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
+	}
+	else{
+		pHalData->eRFPowerState = eRfOn;
+		pMgntInfo->RfOffReason = 0; 
+		if(Adapter->bInSetPower || Adapter->bResetInProgress)
+			PlatformUsbEnableInPipes(Adapter);
+		RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter8192CUsb(): RF is on.\n"));
+	}
+#endif
+}
+
+enum {
+	Antenna_Lfet = 1,
+	Antenna_Right = 2,	
+};
+
+static VOID
+_InitAntenna_Selection(IN	PADAPTER Adapter)
+{
+
+	HAL_DATA_TYPE	*pHalData	= GET_HAL_DATA(Adapter);
+
+	if(pHalData->AntDivCfg==0)
+		return;
+	DBG_8192C("==>  %s ....\n",__FUNCTION__);		
+		
+	rtw_write32(Adapter, REG_LEDCFG0, rtw_read32(Adapter, REG_LEDCFG0)|BIT23);	
+	PHY_SetBBReg(Adapter, rFPGA0_XAB_RFParameter, BIT13, 0x01);
+		
+	if(PHY_QueryBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300) == MAIN_ANT)
+		pHalData->CurAntenna = MAIN_ANT;
+	else
+		pHalData->CurAntenna = AUX_ANT;
+	DBG_8192C("%s,Cur_ant:(%x)%s\n",__FUNCTION__,pHalData->CurAntenna,(pHalData->CurAntenna == MAIN_ANT)?"MAIN_ANT":"AUX_ANT");
+			
+
+}
+
+//
+// 2010/08/26 MH Add for selective suspend mode check.
+// If Efuse 0x0e bit1 is not enabled, we can not support selective suspend for Minicard and
+// slim card.
+//
+static VOID
+HalDetectSelectiveSuspendMode(
+	IN PADAPTER				Adapter
+	)
+{
+#if 0
+	u8	tmpvalue;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	struct dvobj_priv	*pdvobjpriv = adapter_to_dvobj(Adapter);
+
+	// If support HW radio detect, we need to enable WOL ability, otherwise, we 
+	// can not use FW to notify host the power state switch.
+	
+	EFUSE_ShadowRead(Adapter, 1, EEPROM_USB_OPTIONAL1, (u32 *)&tmpvalue);
+
+	DBG_8192C("HalDetectSelectiveSuspendMode(): SS ");
+	if(tmpvalue & BIT1)
+	{
+		DBG_8192C("Enable\n");
+	}
+	else
+	{
+		DBG_8192C("Disable\n");
+		pdvobjpriv->RegUsbSS = _FALSE;
+	}
+
+	// 2010/09/01 MH According to Dongle Selective Suspend INF. We can switch SS mode.
+	if (pdvobjpriv->RegUsbSS && !SUPPORT_HW_RADIO_DETECT(pHalData))
+	{
+		//PMGNT_INFO				pMgntInfo = &(Adapter->MgntInfo);
+
+		//if (!pMgntInfo->bRegDongleSS)	
+		//{
+		//	RT_TRACE(COMP_INIT, DBG_LOUD, ("Dongle disable SS\n"));
+			pdvobjpriv->RegUsbSS = _FALSE;
+		//}
+	}
+#endif
+}	// HalDetectSelectiveSuspendMode
+/*-----------------------------------------------------------------------------
+ * Function:	HwSuspendModeEnable92Cu()
+ *
+ * Overview:	HW suspend mode switch.
+ *
+ * Input:		NONE
+ *
+ * Output:	NONE
+ *
+ * Return:	NONE
+ *
+ * Revised History:
+ *	When		Who		Remark
+ *	08/23/2010	MHC		HW suspend mode switch test..
+ *---------------------------------------------------------------------------*/
+static VOID 
+HwSuspendModeEnable_88eu(
+	IN	PADAPTER	pAdapter,
+	IN	u8			Type
+	)
+{
+	//PRT_USB_DEVICE 		pDevice = GET_RT_USB_DEVICE(pAdapter);
+	u16	reg = rtw_read16(pAdapter, REG_GPIO_MUXCFG);	
+
+	//if (!pDevice->RegUsbSS)
+	{
+		return;
+	}
+
+	//
+	// 2010/08/23 MH According to Alfred's suggestion, we need to to prevent HW
+	// to enter suspend mode automatically. Otherwise, it will shut down major power 
+	// domain and 8051 will stop. When we try to enter selective suspend mode, we
+	// need to prevent HW to enter D2 mode aumotmatically. Another way, Host will
+	// issue a S10 signal to power domain. Then it will cleat SIC setting(from Yngli).
+	// We need to enable HW suspend mode when enter S3/S4 or disable. We need 
+	// to disable HW suspend mode for IPS/radio_off.
+	//
+	//RT_TRACE(COMP_RF, DBG_LOUD, ("HwSuspendModeEnable92Cu = %d\n", Type));
+	if (Type == _FALSE)
+	{
+		reg |= BIT14;
+		//RT_TRACE(COMP_RF, DBG_LOUD, ("REG_GPIO_MUXCFG = %x\n", reg));
+		rtw_write16(pAdapter, REG_GPIO_MUXCFG, reg);
+		reg |= BIT12;
+		//RT_TRACE(COMP_RF, DBG_LOUD, ("REG_GPIO_MUXCFG = %x\n", reg));
+		rtw_write16(pAdapter, REG_GPIO_MUXCFG, reg);
+	}
+	else
+	{
+		reg &= (~BIT12);
+		rtw_write16(pAdapter, REG_GPIO_MUXCFG, reg);
+		reg &= (~BIT14);
+		rtw_write16(pAdapter, REG_GPIO_MUXCFG, reg);
+	}
+	
+}	// HwSuspendModeEnable92Cu
+rt_rf_power_state RfOnOffDetect(IN	PADAPTER pAdapter )
+{
+	struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(pAdapter);
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(pAdapter);
+	u8	val8;
+	rt_rf_power_state rfpowerstate = rf_off;
+
+	if(pwrctl->bHWPowerdown)
+	{
+		val8 = rtw_read8(pAdapter, REG_HSISR);
+		DBG_8192C("pwrdown, 0x5c(BIT7)=%02x\n", val8);
+		rfpowerstate = (val8 & BIT7) ? rf_off: rf_on;				
+	}
+	else // rf on/off
+	{
+		rtw_write8(	pAdapter, REG_MAC_PINMUX_CFG,rtw_read8(pAdapter, REG_MAC_PINMUX_CFG)&~(BIT3));
+		val8 = rtw_read8(pAdapter, REG_GPIO_IO_SEL);
+		DBG_8192C("GPIO_IN=%02x\n", val8);
+		rfpowerstate = (val8 & BIT3) ? rf_on : rf_off;	
+	}
+	return rfpowerstate;
+}	// HalDetectPwrDownMode
+
+void _ps_open_RF(_adapter *padapter);
+
+u32 rtl8188eu_hal_init(PADAPTER Adapter)
+{
+	u8	value8 = 0;
+	u16  value16;
+	u8	txpktbuf_bndy;
+	u32	status = _SUCCESS;
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(Adapter);
+	struct pwrctrl_priv		*pwrctrlpriv = adapter_to_pwrctl(Adapter);
+	struct registry_priv	*pregistrypriv = &Adapter->registrypriv;
+	
+	rt_rf_power_state		eRfPowerStateToSet;
+#ifdef CONFIG_BT_COEXIST
+	struct btcoexist_priv	*pbtpriv = &(pHalData->bt_coexist);
+#endif
+
+	u32 init_start_time = rtw_get_current_time();
+
+
+#ifdef DBG_HAL_INIT_PROFILING
+
+	enum HAL_INIT_STAGES {
+		HAL_INIT_STAGES_BEGIN = 0,
+		HAL_INIT_STAGES_INIT_PW_ON,
+		HAL_INIT_STAGES_MISC01,
+		HAL_INIT_STAGES_DOWNLOAD_FW,
+		HAL_INIT_STAGES_MAC,
+		HAL_INIT_STAGES_BB,
+		HAL_INIT_STAGES_RF,	
+		HAL_INIT_STAGES_EFUSE_PATCH,
+		HAL_INIT_STAGES_INIT_LLTT,	
+		
+		HAL_INIT_STAGES_MISC02,
+		HAL_INIT_STAGES_TURN_ON_BLOCK,
+		HAL_INIT_STAGES_INIT_SECURITY,
+		HAL_INIT_STAGES_MISC11,
+		HAL_INIT_STAGES_INIT_HAL_DM,
+		//HAL_INIT_STAGES_RF_PS,
+		HAL_INIT_STAGES_IQK,
+		HAL_INIT_STAGES_PW_TRACK,
+		HAL_INIT_STAGES_LCK,
+		//HAL_INIT_STAGES_MISC21,
+		//HAL_INIT_STAGES_INIT_PABIAS,
+		#ifdef CONFIG_BT_COEXIST
+		HAL_INIT_STAGES_BT_COEXIST,
+		#endif
+		//HAL_INIT_STAGES_ANTENNA_SEL,
+		//HAL_INIT_STAGES_MISC31,
+		HAL_INIT_STAGES_END,
+		HAL_INIT_STAGES_NUM
+	};
+
+	char * hal_init_stages_str[] = {
+		"HAL_INIT_STAGES_BEGIN",
+		"HAL_INIT_STAGES_INIT_PW_ON",
+		"HAL_INIT_STAGES_MISC01",
+		"HAL_INIT_STAGES_DOWNLOAD_FW",		
+		"HAL_INIT_STAGES_MAC",		
+		"HAL_INIT_STAGES_BB",
+		"HAL_INIT_STAGES_RF",
+		"HAL_INIT_STAGES_EFUSE_PATCH",
+		"HAL_INIT_STAGES_INIT_LLTT",
+		"HAL_INIT_STAGES_MISC02",		
+		"HAL_INIT_STAGES_TURN_ON_BLOCK",
+		"HAL_INIT_STAGES_INIT_SECURITY",
+		"HAL_INIT_STAGES_MISC11",
+		"HAL_INIT_STAGES_INIT_HAL_DM",
+		//"HAL_INIT_STAGES_RF_PS",
+		"HAL_INIT_STAGES_IQK",
+		"HAL_INIT_STAGES_PW_TRACK",
+		"HAL_INIT_STAGES_LCK",
+		//"HAL_INIT_STAGES_MISC21",
+		#ifdef CONFIG_BT_COEXIST
+		"HAL_INIT_STAGES_BT_COEXIST",
+		#endif
+		//"HAL_INIT_STAGES_ANTENNA_SEL",
+		//"HAL_INIT_STAGES_MISC31",
+		"HAL_INIT_STAGES_END",
+	};
+
+	int hal_init_profiling_i;
+	u32 hal_init_stages_timestamp[HAL_INIT_STAGES_NUM]; //used to record the time of each stage's starting point
+
+	for(hal_init_profiling_i=0;hal_init_profiling_i<HAL_INIT_STAGES_NUM;hal_init_profiling_i++)
+		hal_init_stages_timestamp[hal_init_profiling_i]=0;
+
+	#define HAL_INIT_PROFILE_TAG(stage) hal_init_stages_timestamp[(stage)]=rtw_get_current_time();
+#else
+	#define HAL_INIT_PROFILE_TAG(stage) do {} while(0)
+#endif //DBG_HAL_INIT_PROFILING
+
+
+
+_func_enter_;
+	
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_BEGIN);
+
+#ifdef CONFIG_WOWLAN
+	
+	pwrctrlpriv->wowlan_wake_reason = rtw_read8(Adapter, REG_WOWLAN_WAKE_REASON);
+	DBG_8192C("%s wowlan_wake_reason: 0x%02x\n", 
+				__func__, pwrctrlpriv->wowlan_wake_reason);
+
+	if(rtw_read8(Adapter, REG_MCUFWDL)&BIT7){ /*&&
+		(pwrctrlpriv->wowlan_wake_reason & FWDecisionDisconnect)) {*/
+		u8 reg_val=0;
+		DBG_8192C("+Reset Entry+\n");
+		rtw_write8(Adapter, REG_MCUFWDL, 0x00);
+		_8051Reset88E(Adapter);
+		//reset BB
+		reg_val = rtw_read8(Adapter, REG_SYS_FUNC_EN);
+		reg_val &= ~(BIT(0) | BIT(1));
+		rtw_write8(Adapter, REG_SYS_FUNC_EN, reg_val);
+		//reset RF
+		rtw_write8(Adapter, REG_RF_CTRL, 0);
+		//reset TRX path
+		rtw_write16(Adapter, REG_CR, 0);
+		//reset MAC, Digital Core
+		reg_val = rtw_read8(Adapter, REG_SYS_FUNC_EN+1);
+		reg_val &= ~(BIT(4) | BIT(7));
+		rtw_write8(Adapter, REG_SYS_FUNC_EN+1, reg_val);
+		reg_val = rtw_read8(Adapter, REG_SYS_FUNC_EN+1);
+		reg_val |= BIT(4) | BIT(7);
+		rtw_write8(Adapter, REG_SYS_FUNC_EN+1, reg_val);
+		DBG_8192C("-Reset Entry-\n");
+	}
+#endif //CONFIG_WOWLAN
+
+	if(pwrctrlpriv->bkeepfwalive)
+	{
+		_ps_open_RF(Adapter);
+
+		if(pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized){
+//			PHY_IQCalibrate(padapter, _TRUE);
+			PHY_IQCalibrate_8188E(Adapter,_TRUE);
+		}
+		else
+		{
+//			PHY_IQCalibrate(padapter, _FALSE);
+			PHY_IQCalibrate_8188E(Adapter,_FALSE);
+			pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized = _TRUE;
+		}
+
+//		dm_CheckTXPowerTracking(padapter);
+//		PHY_LCCalibrate(padapter);
+		ODM_TXPowerTrackingCheck(&pHalData->odmpriv );
+		PHY_LCCalibrate_8188E(&pHalData->odmpriv );
+
+		goto exit;
+	}
+	
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_INIT_PW_ON);
+	status = _InitPowerOn_8188EU(Adapter);
+	if(status == _FAIL){
+		RT_TRACE(_module_hci_hal_init_c_, _drv_err_, ("Failed to init power on!\n"));
+		goto exit;
+	}
+
+	// Set RF type for BB/RF configuration	
+	_InitRFType(Adapter);//->_ReadRFType()
+
+	// Save target channel
+	// <Roger_Notes> Current Channel will be updated again later.
+	pHalData->CurrentChannel = 6;//default set to 6
+	if(pwrctrlpriv->reg_rfoff == _TRUE){
+		pwrctrlpriv->rf_pwrstate = rf_off;
+	}
+
+	// 2010/08/09 MH We need to check if we need to turnon or off RF after detecting
+	// HW GPIO pin. Before PHY_RFConfig8192C.
+	//HalDetectPwrDownMode(Adapter);
+	// 2010/08/26 MH If Efuse does not support sective suspend then disable the function.
+	//HalDetectSelectiveSuspendMode(Adapter);
+
+	if (!pregistrypriv->wifi_spec) {
+		txpktbuf_bndy = TX_PAGE_BOUNDARY_88E;
+	} else {
+		// for WMM
+		txpktbuf_bndy = WMM_NORMAL_TX_PAGE_BOUNDARY_88E;
+	}
+	
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_MISC01);
+	_InitQueueReservedPage(Adapter);		
+	_InitQueuePriority(Adapter);
+	_InitPageBoundary(Adapter);	
+	_InitTransferPageSize(Adapter);
+	
+#ifdef CONFIG_IOL_IOREG_CFG
+	_InitTxBufferBoundary(Adapter, 0);		
+#endif
+
+
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_DOWNLOAD_FW);
+#if (MP_DRIVER == 1)
+	if (Adapter->registrypriv.mp_mode == 1)
+	{
+		_InitRxSetting(Adapter);
+	}
+#endif  //MP_DRIVER == 1
+	{
+	#if 0		
+		Adapter->bFWReady = _FALSE; //because no fw for test chip	
+		pHalData->fw_ractrl = _FALSE;
+	#else
+
+
+		status = rtl8188e_FirmwareDownload(Adapter, _FALSE);
+
+		if (status != _SUCCESS) {
+			DBG_871X("%s: Download Firmware failed!!\n", __FUNCTION__);
+			Adapter->bFWReady = _FALSE;
+			pHalData->fw_ractrl = _FALSE;
+			return status;
+		} else {
+			RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("Initializepadapter8192CSdio(): Download Firmware Success!!\n"));
+			Adapter->bFWReady = _TRUE;
+			pHalData->fw_ractrl = _FALSE;
+		}
+	#endif
+	}
+
+
+	rtl8188e_InitializeFirmwareVars(Adapter);
+
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_MAC);
+#if (HAL_MAC_ENABLE == 1)
+	status = PHY_MACConfig8188E(Adapter);
+	if(status == _FAIL)
+	{
+		DBG_871X(" ### Failed to init MAC ...... \n ");				
+		goto exit;
+	}
+#endif	
+
+	//
+	//d. Initialize BB related configurations.
+	//
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_BB);
+#if (HAL_BB_ENABLE == 1)
+	status = PHY_BBConfig8188E(Adapter);
+	if(status == _FAIL)
+	{
+		DBG_871X(" ### Failed to init BB ...... \n ");
+		goto exit;
+	}
+#endif
+
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_RF);
+#if (HAL_RF_ENABLE == 1)
+	status = PHY_RFConfig8188E(Adapter);	
+	if(status == _FAIL)
+	{
+		DBG_871X(" ### Failed to init RF ...... \n ");
+		goto exit;
+	}
+#endif
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_EFUSE_PATCH);
+#if defined(CONFIG_IOL_EFUSE_PATCH)		
+	status = rtl8188e_iol_efuse_patch(Adapter);
+	if(status == _FAIL){	
+		DBG_871X("%s  rtl8188e_iol_efuse_patch failed \n",__FUNCTION__);
+		goto exit;
+	}	
+#endif
+
+	_InitTxBufferBoundary(Adapter, txpktbuf_bndy);	
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_INIT_LLTT);
+	status =  InitLLTTable(Adapter, txpktbuf_bndy);
+	if(status == _FAIL){
+		RT_TRACE(_module_hci_hal_init_c_, _drv_err_, ("Failed to init LLT table\n"));
+		goto exit;
+	}
+	
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_MISC02);
+	// Get Rx PHY status in order to report RSSI and others.
+	_InitDriverInfoSize(Adapter, DRVINFO_SZ);
+
+	_InitInterrupt(Adapter);
+	hal_init_macaddr(Adapter);//set mac_address
+	_InitNetworkType(Adapter);//set msr	
+	_InitWMACSetting(Adapter);
+	_InitAdaptiveCtrl(Adapter);
+	_InitEDCA(Adapter);
+	//_InitRateFallback(Adapter);//just follow MP Team ???Georgia
+	_InitRetryFunction(Adapter);
+	InitUsbAggregationSetting(Adapter);
+	_InitOperationMode(Adapter);//todo
+	_InitBeaconParameters(Adapter);
+	_InitBeaconMaxError(Adapter, _TRUE);
+
+	//
+	// Init CR MACTXEN, MACRXEN after setting RxFF boundary REG_TRXFF_BNDY to patch
+	// Hw bug which Hw initials RxFF boundry size to a value which is larger than the real Rx buffer size in 88E. 
+	//
+	// Enable MACTXEN/MACRXEN block
+	value16 = rtw_read16(Adapter, REG_CR);
+	value16 |= (MACTXEN | MACRXEN);
+	rtw_write8(Adapter, REG_CR, value16);		
+
+	_InitHardwareDropIncorrectBulkOut(Adapter);
+
+
+	if(pHalData->bRDGEnable){
+		_InitRDGSetting(Adapter);
+	}
+
+#if (RATE_ADAPTIVE_SUPPORT==1)
+	{//Enable TX Report
+		//Enable Tx Report Timer   
+		value8 = rtw_read8(Adapter, REG_TX_RPT_CTRL);
+		rtw_write8(Adapter,  REG_TX_RPT_CTRL, (value8|BIT1|BIT0));
+		//Set MAX RPT MACID
+		rtw_write8(Adapter,  REG_TX_RPT_CTRL+1, 2);//FOR sta mode ,0: bc/mc ,1:AP
+		//Tx RPT Timer. Unit: 32us
+		rtw_write16(Adapter, REG_TX_RPT_TIME, 0xCdf0);
+	}
+#endif	
+
+#if 0
+	if(pHTInfo->bRDGEnable){
+		_InitRDGSetting_8188E(Adapter);
+	}
+#endif
+
+#ifdef CONFIG_TX_EARLY_MODE	
+	if( pHalData->bEarlyModeEnable)
+	{
+		RT_TRACE(_module_hci_hal_init_c_, _drv_info_,("EarlyMode Enabled!!!\n"));
+
+		value8 = rtw_read8(Adapter, REG_EARLY_MODE_CONTROL);
+#if RTL8188E_EARLY_MODE_PKT_NUM_10 == 1
+		value8 = value8|0x1f;
+#else
+		value8 = value8|0xf;
+#endif
+		rtw_write8(Adapter, REG_EARLY_MODE_CONTROL, value8);
+
+		rtw_write8(Adapter, REG_EARLY_MODE_CONTROL+3, 0x80);
+
+		value8 = rtw_read8(Adapter, REG_TCR+1);
+		value8 = value8|0x40;
+		rtw_write8(Adapter,REG_TCR+1, value8);
+	}
+	else
+#endif
+	{
+		rtw_write8(Adapter, REG_EARLY_MODE_CONTROL, 0);
+	}
+
+	rtw_write32(Adapter,REG_MACID_NO_LINK_0,0xFFFFFFFF);
+	rtw_write32(Adapter,REG_MACID_NO_LINK_1,0xFFFFFFFF);
+	
+#if defined(CONFIG_CONCURRENT_MODE) || defined(CONFIG_TX_MCAST2UNI)
+
+#ifdef CONFIG_CHECK_AC_LIFETIME
+	// Enable lifetime check for the four ACs
+	rtw_write8(Adapter, REG_LIFETIME_CTRL, 0x0F);
+#endif	// CONFIG_CHECK_AC_LIFETIME
+
+#ifdef CONFIG_TX_MCAST2UNI
+	rtw_write16(Adapter, REG_PKT_VO_VI_LIFE_TIME, 0x0400);	// unit: 256us. 256ms
+	rtw_write16(Adapter, REG_PKT_BE_BK_LIFE_TIME, 0x0400);	// unit: 256us. 256ms
+#else	// CONFIG_TX_MCAST2UNI
+	rtw_write16(Adapter, REG_PKT_VO_VI_LIFE_TIME, 0x3000);	// unit: 256us. 3s
+	rtw_write16(Adapter, REG_PKT_BE_BK_LIFE_TIME, 0x3000);	// unit: 256us. 3s
+#endif	// CONFIG_TX_MCAST2UNI
+#endif	// CONFIG_CONCURRENT_MODE || CONFIG_TX_MCAST2UNI
+	
+
+#ifdef CONFIG_LED
+	_InitHWLed(Adapter);
+#endif //CONFIG_LED
+
+	
+	//
+	// Joseph Note: Keep RfRegChnlVal for later use.
+	//
+	pHalData->RfRegChnlVal[0] = PHY_QueryRFReg(Adapter, 0, RF_CHNLBW, bRFRegOffsetMask);
+	pHalData->RfRegChnlVal[1] = PHY_QueryRFReg(Adapter, 1, RF_CHNLBW, bRFRegOffsetMask);
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_TURN_ON_BLOCK);
+	_BBTurnOnBlock(Adapter);
+	//NicIFSetMacAddress(padapter, padapter->PermanentAddress);
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_INIT_SECURITY);
+	invalidate_cam_all(Adapter);
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_MISC11);
+	// 2010/12/17 MH We need to set TX power according to EFUSE content at first.
+	PHY_SetTxPowerLevel8188E(Adapter, pHalData->CurrentChannel);
+
+// Move by Neo for USB SS to below setp	
+//_RfPowerSave(Adapter);
+
+	_InitAntenna_Selection(Adapter);
+	
+	// 
+	// Disable BAR, suggested by Scott
+	// 2010.04.09 add by hpfan
+	//
+	rtw_write32(Adapter, REG_BAR_MODE_CTRL, 0x0201ffff);
+
+	// HW SEQ CTRL
+	//set 0x0 to 0xFF by tynli. Default enable HW SEQ NUM.
+	rtw_write8(Adapter,REG_HWSEQ_CTRL, 0xFF); 
+
+	if(pregistrypriv->wifi_spec)
+		rtw_write16(Adapter,REG_FAST_EDCA_CTRL ,0);
+
+	//Nav limit , suggest by scott
+	rtw_write8(Adapter, 0x652, 0x0);
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_INIT_HAL_DM);
+	rtl8188e_InitHalDm(Adapter);
+	
+#if (MP_DRIVER == 1)
+	if (Adapter->registrypriv.mp_mode == 1)
+	{
+		Adapter->mppriv.channel = pHalData->CurrentChannel;
+		MPT_InitializeAdapter(Adapter, Adapter->mppriv.channel);
+	}
+	else	
+#endif  //#if (MP_DRIVER == 1)
+	{
+	//
+	// 2010/08/11 MH Merge from 8192SE for Minicard init. We need to confirm current radio status
+	// and then decide to enable RF or not.!!!??? For Selective suspend mode. We may not 
+	// call init_adapter. May cause some problem??
+	//
+	// Fix the bug that Hw/Sw radio off before S3/S4, the RF off action will not be executed 
+	// in MgntActSet_RF_State() after wake up, because the value of pHalData->eRFPowerState 
+	// is the same as eRfOff, we should change it to eRfOn after we config RF parameters.
+	// Added by tynli. 2010.03.30.
+	pwrctrlpriv->rf_pwrstate = rf_on;
+
+#if 0  //to do
+	RT_CLEAR_PS_LEVEL(pwrctrlpriv, RT_RF_OFF_LEVL_HALT_NIC);
+#if 1 //Todo
+	// 20100326 Joseph: Copy from GPIOChangeRFWorkItemCallBack() function to check HW radio on/off.
+	// 20100329 Joseph: Revise and integrate the HW/SW radio off code in initialization.
+
+	eRfPowerStateToSet = (rt_rf_power_state) RfOnOffDetect(Adapter);
+	pwrctrlpriv->rfoff_reason |= eRfPowerStateToSet==rf_on ? RF_CHANGE_BY_INIT : RF_CHANGE_BY_HW;
+	pwrctrlpriv->rfoff_reason |= (pwrctrlpriv->reg_rfoff) ? RF_CHANGE_BY_SW : 0;
+
+	if(pwrctrlpriv->rfoff_reason&RF_CHANGE_BY_HW)
+		pwrctrlpriv->b_hw_radio_off = _TRUE;
+
+	DBG_8192C("eRfPowerStateToSet=%d\n", eRfPowerStateToSet);
+	
+	if(pwrctrlpriv->reg_rfoff == _TRUE)
+	{	// User disable RF via registry.
+		DBG_8192C("InitializeAdapter8192CU(): Turn off RF for RegRfOff.\n");
+		//MgntActSet_RF_State(Adapter, rf_off, RF_CHANGE_BY_SW, _TRUE);
+		
+		// Those action will be discard in MgntActSet_RF_State because off the same state
+		//for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
+			//PHY_SetRFReg(Adapter, eRFPath, 0x4, 0xC00, 0x0);
+	}
+	else if(pwrctrlpriv->rfoff_reason > RF_CHANGE_BY_PS)
+	{	// H/W or S/W RF OFF before sleep.
+		DBG_8192C(" Turn off RF for RfOffReason(%x) ----------\n", pwrctrlpriv->rfoff_reason);
+		//pwrctrlpriv->rfoff_reason = RF_CHANGE_BY_INIT;
+		pwrctrlpriv->rf_pwrstate = rf_on;
+		//MgntActSet_RF_State(Adapter, rf_off, pwrctrlpriv->rfoff_reason, _TRUE);
+	}
+	else
+	{
+		// Perform GPIO polling to find out current RF state. added by Roger, 2010.04.09.
+		if(pHalData->BoardType == BOARD_MINICARD /*&& (Adapter->MgntInfo.PowerSaveControl.bGpioRfSw)*/)
+		{
+			DBG_8192C("InitializeAdapter8192CU(): RF=%d \n", eRfPowerStateToSet);
+			if (eRfPowerStateToSet == rf_off)
+			{				
+				//MgntActSet_RF_State(Adapter, rf_off, RF_CHANGE_BY_HW, _TRUE);
+				pwrctrlpriv->b_hw_radio_off = _TRUE;	
+			}
+			else
+			{
+				pwrctrlpriv->rf_pwrstate = rf_off;
+				pwrctrlpriv->rfoff_reason = RF_CHANGE_BY_INIT; 
+				pwrctrlpriv->b_hw_radio_off = _FALSE;					
+				//MgntActSet_RF_State(Adapter, rf_on, pwrctrlpriv->rfoff_reason, _TRUE);
+			}
+		}	
+		else
+		{
+			pwrctrlpriv->rf_pwrstate = rf_off;
+			pwrctrlpriv->rfoff_reason = RF_CHANGE_BY_INIT; 			
+			//MgntActSet_RF_State(Adapter, rf_on, pwrctrlpriv->rfoff_reason, _TRUE);
+		}
+	
+		pwrctrlpriv->rfoff_reason = 0; 
+		pwrctrlpriv->b_hw_radio_off = _FALSE;
+		pwrctrlpriv->rf_pwrstate = rf_on;
+		rtw_led_control(Adapter, LED_CTL_POWER_ON);
+
+	}
+
+	// 2010/-8/09 MH For power down module, we need to enable register block contrl reg at 0x1c.
+	// Then enable power down control bit of register 0x04 BIT4 and BIT15 as 1.
+	if(pHalData->pwrdown && eRfPowerStateToSet == rf_off)
+	{
+		// Enable register area 0x0-0xc.
+		rtw_write8(Adapter, REG_RSV_CTRL, 0x0);
+
+		//
+		// <Roger_Notes> We should configure HW PDn source for WiFi ONLY, and then
+		// our HW will be set in power-down mode if PDn source from all  functions are configured.
+		// 2010.10.06.
+		//
+		//if(IS_HARDWARE_TYPE_8723AU(Adapter))
+		//{			
+		//	u1bTmp = rtw_read8(Adapter, REG_MULTI_FUNC_CTRL);
+		//	rtw_write8(Adapter, REG_MULTI_FUNC_CTRL, (u1bTmp|WL_HWPDN_EN));
+		//}
+		//else
+		//{
+			rtw_write16(Adapter, REG_APS_FSMCO, 0x8812);
+		//}
+	}
+	//DrvIFIndicateCurrentPhyStatus(Adapter); // 2010/08/17 MH Disable to prevent BSOD.
+#endif
+#endif
+
+
+	// enable Tx report.
+	rtw_write8(Adapter,  REG_FWHW_TXQ_CTRL+1, 0x0F);
+
+	// Suggested by SD1 pisa. Added by tynli. 2011.10.21.
+	rtw_write8(Adapter, REG_EARLY_MODE_CONTROL+3, 0x01);//Pretx_en, for WEP/TKIP SEC
+
+	//tynli_test_tx_report.
+	rtw_write16(Adapter, REG_TX_RPT_TIME, 0x3DF0);
+	//RT_TRACE(COMP_INIT, DBG_TRACE, ("InitializeAdapter8188EUsb() <====\n"));
+
+	//enable tx DMA to drop the redundate data of packet
+	rtw_write16(Adapter,REG_TXDMA_OFFSET_CHK, (rtw_read16(Adapter,REG_TXDMA_OFFSET_CHK) | DROP_DATA_EN));
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_IQK);
+	// 2010/08/26 MH Merge from 8192CE.
+	if(pwrctrlpriv->rf_pwrstate == rf_on)
+	{
+		if(pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized){
+			PHY_IQCalibrate_8188E(Adapter,_TRUE);
+		}
+		else
+		{
+			PHY_IQCalibrate_8188E(Adapter,_FALSE);
+			pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized = _TRUE;
+		}
+		
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_PW_TRACK);
+		
+		ODM_TXPowerTrackingCheck(&pHalData->odmpriv );
+		
+
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_LCK);
+		PHY_LCCalibrate_8188E(&pHalData->odmpriv );
+	}
+}
+
+//HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_INIT_PABIAS);
+//	_InitPABias(Adapter);
+	rtw_write8(Adapter, REG_USB_HRPWM, 0);
+
+#ifdef CONFIG_XMIT_ACK
+	//ack for xmit mgmt frames.
+	rtw_write32(Adapter, REG_FWHW_TXQ_CTRL, rtw_read32(Adapter, REG_FWHW_TXQ_CTRL)|BIT(12));
+#endif //CONFIG_XMIT_ACK
+
+exit:
+HAL_INIT_PROFILE_TAG(HAL_INIT_STAGES_END);
+
+	DBG_871X("%s in %dms\n", __FUNCTION__, rtw_get_passing_time_ms(init_start_time));
+
+	#ifdef DBG_HAL_INIT_PROFILING
+	hal_init_stages_timestamp[HAL_INIT_STAGES_END]=rtw_get_current_time();
+
+	for(hal_init_profiling_i=0;hal_init_profiling_i<HAL_INIT_STAGES_NUM-1;hal_init_profiling_i++) {
+		DBG_871X("DBG_HAL_INIT_PROFILING: %35s, %u, %5u, %5u\n"
+			, hal_init_stages_str[hal_init_profiling_i]
+			, hal_init_stages_timestamp[hal_init_profiling_i]
+			, (hal_init_stages_timestamp[hal_init_profiling_i+1]-hal_init_stages_timestamp[hal_init_profiling_i])
+			, rtw_get_time_interval_ms(hal_init_stages_timestamp[hal_init_profiling_i], hal_init_stages_timestamp[hal_init_profiling_i+1])
+		);
+	}	
+	#endif
+
+
+_func_exit_;
+
+	return status;
+}
+
+void _ps_open_RF(_adapter *padapter) {
+	//here call with bRegSSPwrLvl 1, bRegSSPwrLvl 2 needs to be verified
+	//phy_SsPwrSwitch92CU(padapter, rf_on, 1);
+}
+
+void _ps_close_RF(_adapter *padapter){
+	//here call with bRegSSPwrLvl 1, bRegSSPwrLvl 2 needs to be verified
+	//phy_SsPwrSwitch92CU(padapter, rf_off, 1);
+}
+
+
+VOID
+hal_poweroff_8188eu(
+	IN	PADAPTER			Adapter 
+)
+{
+
+	u8 	val8;
+	u16	val16;
+	u32	val32;
+	u8 bMacPwrCtrlOn = _FALSE;
+
+	rtw_hal_get_hwreg(Adapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
+	if(bMacPwrCtrlOn == _FALSE)	
+		return ;
+	
+	RT_TRACE(COMP_INIT, DBG_LOUD, ("%s\n",__FUNCTION__));
+
+	//Stop Tx Report Timer. 0x4EC[Bit1]=b'0
+	val8 = rtw_read8(Adapter, REG_TX_RPT_CTRL);
+	rtw_write8(Adapter, REG_TX_RPT_CTRL, val8&(~BIT1));
+
+	// stop rx 
+	rtw_write8(Adapter, REG_CR, 0x0);
+	
+	// Run LPS WL RFOFF flow
+	HalPwrSeqCmdParsing(Adapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_USB_MSK, Rtl8188E_NIC_LPS_ENTER_FLOW);
+
+	
+	// 2. 0x1F[7:0] = 0		// turn off RF
+	//rtw_write8(Adapter, REG_RF_CTRL, 0x00);
+
+	val8 = rtw_read8(Adapter, REG_MCUFWDL);
+	if ((val8 & RAM_DL_SEL) && Adapter->bFWReady) //8051 RAM code
+	{
+		//rtl8723a_FirmwareSelfReset(padapter);
+		//_8051Reset88E(padapter);		
+		
+		// Reset MCU 0x2[10]=0.
+		val8 = rtw_read8(Adapter, REG_SYS_FUNC_EN+1);
+		val8 &= ~BIT(2);	// 0x2[10], FEN_CPUEN
+		rtw_write8(Adapter, REG_SYS_FUNC_EN+1, val8);
+	}	
+
+	//val8 = rtw_read8(Adapter, REG_SYS_FUNC_EN+1);
+	//val8 &= ~BIT(2);	// 0x2[10], FEN_CPUEN
+	//rtw_write8(Adapter, REG_SYS_FUNC_EN+1, val8);
+
+	// MCUFWDL 0x80[1:0]=0
+	// reset MCU ready status
+	rtw_write8(Adapter, REG_MCUFWDL, 0);
+
+	//YJ,add,111212
+	//Disable 32k
+	val8 = rtw_read8(Adapter, REG_32K_CTRL);
+	rtw_write8(Adapter, REG_32K_CTRL, val8&(~BIT0));
+	
+	// Card disable power action flow
+	HalPwrSeqCmdParsing(Adapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_USB_MSK, Rtl8188E_NIC_DISABLE_FLOW);	
+	
+	// Reset MCU IO Wrapper
+	val8 = rtw_read8(Adapter, REG_RSV_CTRL+1);
+	rtw_write8(Adapter, REG_RSV_CTRL+1, (val8&(~BIT3)));	
+	val8 = rtw_read8(Adapter, REG_RSV_CTRL+1);
+	rtw_write8(Adapter, REG_RSV_CTRL+1, val8|BIT3);
+	
+#if 0
+	// 7. RSV_CTRL 0x1C[7:0] = 0x0E			// lock ISO/CLK/Power control register
+	rtw_write8(Adapter, REG_RSV_CTRL, 0x0e);
+#endif
+#if 1
+	//YJ,test add, 111207. For Power Consumption.
+	val8 = rtw_read8(Adapter, GPIO_IN);
+	rtw_write8(Adapter, GPIO_OUT, val8);
+	rtw_write8(Adapter, GPIO_IO_SEL, 0xFF);//Reg0x46
+
+	val8 = rtw_read8(Adapter, REG_GPIO_IO_SEL);
+	//rtw_write8(Adapter, REG_GPIO_IO_SEL, (val8<<4)|val8);
+	rtw_write8(Adapter, REG_GPIO_IO_SEL, (val8<<4));
+	val8 = rtw_read8(Adapter, REG_GPIO_IO_SEL+1);
+	rtw_write8(Adapter, REG_GPIO_IO_SEL+1, val8|0x0F);//Reg0x43
+	rtw_write32(Adapter, REG_BB_PAD_CTRL, 0x00080808);//set LNA ,TRSW,EX_PA Pin to output mode
+#endif
+
+	Adapter->bFWReady = _FALSE;
+
+	bMacPwrCtrlOn = _FALSE;
+	rtw_hal_set_hwreg(Adapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);	
+}
+static void rtl8192cu_hw_power_down(_adapter *padapter)
+{
+	// 2010/-8/09 MH For power down module, we need to enable register block contrl reg at 0x1c.
+	// Then enable power down control bit of register 0x04 BIT4 and BIT15 as 1.
+		
+	// Enable register area 0x0-0xc.
+	rtw_write8(padapter,REG_RSV_CTRL, 0x0);			
+	rtw_write16(padapter, REG_APS_FSMCO, 0x8812);
+}
+
+u32 rtl8188eu_hal_deinit(PADAPTER Adapter)
+ {
+	struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(Adapter);
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+   	DBG_8192C("==> %s \n",__FUNCTION__);
+
+#ifdef CONFIG_SUPPORT_USB_INT
+	rtw_write32(Adapter, REG_HIMR_88E, IMR_DISABLED_88E);
+	rtw_write32(Adapter, REG_HIMRE_88E, IMR_DISABLED_88E);
+#endif
+	
+ #ifdef SUPPORT_HW_RFOFF_DETECTED
+ 	DBG_8192C("bkeepfwalive(%x)\n", pwrctl->bkeepfwalive);
+ 	if(pwrctl->bkeepfwalive)
+ 	{
+		_ps_close_RF(Adapter);		
+		if((pwrctl->bHWPwrPindetect) && (pwrctl->bHWPowerdown))
+			rtl8192cu_hw_power_down(Adapter);
+ 	}
+	else
+#endif
+	{
+		if(Adapter->hw_init_completed == _TRUE){
+			hal_poweroff_8188eu(Adapter);
+
+			if((pwrctl->bHWPwrPindetect ) && (pwrctl->bHWPowerdown))
+				rtl8192cu_hw_power_down(Adapter);
+			
+		}
+	}	
+	return _SUCCESS;
+ }
+
+
+unsigned int rtl8188eu_inirp_init(PADAPTER Adapter)
+{	
+	u8 i;	
+	struct recv_buf *precvbuf;
+	uint	status;
+	struct dvobj_priv *pdev= adapter_to_dvobj(Adapter);
+	struct intf_hdl * pintfhdl=&Adapter->iopriv.intf;
+	struct recv_priv *precvpriv = &(Adapter->recvpriv);	
+	u32 (*_read_port)(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pmem);
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
+	u32 (*_read_interrupt)(struct intf_hdl *pintfhdl, u32 addr);
+#endif
+
+_func_enter_;
+
+	_read_port = pintfhdl->io_ops._read_port;
+
+	status = _SUCCESS;
+
+	RT_TRACE(_module_hci_hal_init_c_,_drv_info_,("===> usb_inirp_init \n"));	
+		
+	precvpriv->ff_hwaddr = RECV_BULK_IN_ADDR;
+
+	//issue Rx irp to receive data	
+	precvbuf = (struct recv_buf *)precvpriv->precv_buf;	
+	for(i=0; i<NR_RECVBUFF; i++)
+	{
+		if(_read_port(pintfhdl, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf) == _FALSE )
+		{
+			RT_TRACE(_module_hci_hal_init_c_,_drv_err_,("usb_rx_init: usb_read_port error \n"));
+			status = _FAIL;
+			goto exit;
+		}
+		
+		precvbuf++;		
+		precvpriv->free_recv_buf_queue_cnt--;
+	}
+
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+	if(pHalData->RtIntInPipe != 0x05)
+	{
+		status = _FAIL;
+		DBG_871X("%s =>Warning !! Have not USB Int-IN pipe,  pHalData->RtIntInPipe(%d)!!!\n",__FUNCTION__,pHalData->RtIntInPipe);
+		goto exit;
+	}	
+	_read_interrupt = pintfhdl->io_ops._read_interrupt;
+	if(_read_interrupt(pintfhdl, RECV_INT_IN_ADDR) == _FALSE )
+	{
+		RT_TRACE(_module_hci_hal_init_c_,_drv_err_,("usb_rx_init: usb_read_interrupt error \n"));
+		status = _FAIL;
+	}
+#endif
+
+exit:
+	
+	RT_TRACE(_module_hci_hal_init_c_,_drv_info_,("<=== usb_inirp_init \n"));
+
+_func_exit_;
+
+	return status;
+
+}
+
+unsigned int rtl8188eu_inirp_deinit(PADAPTER Adapter)
+{	
+	RT_TRACE(_module_hci_hal_init_c_,_drv_info_,("\n ===> usb_rx_deinit \n"));
+	
+	rtw_read_port_cancel(Adapter);
+
+	RT_TRACE(_module_hci_hal_init_c_,_drv_info_,("\n <=== usb_rx_deinit \n"));
+
+	return _SUCCESS;
+}
+
+
+
+//-------------------------------------------------------------------------
+//
+//	EEPROM Power index mapping
+//
+//-------------------------------------------------------------------------
+
+
+//-------------------------------------------------------------------
+//
+//	EEPROM/EFUSE Content Parsing
+//
+//-------------------------------------------------------------------
+static VOID
+_ReadBoardType(
+	IN	PADAPTER	Adapter,	
+	IN	u8*		PROMContent,
+	IN	BOOLEAN		AutoloadFail
+	)
+{
+ 
+}
+
+
+static VOID
+_ReadLEDSetting(
+	IN	PADAPTER	Adapter,	
+	IN	u8*		PROMContent,
+	IN	BOOLEAN		AutoloadFail
+	)
+{
+	struct led_priv *pledpriv = &(Adapter->ledpriv);
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);
+#ifdef CONFIG_SW_LED
+	pledpriv->bRegUseLed = _TRUE;
+
+	switch(pEEPROM->CustomerID)
+	{
+		default:
+			pledpriv->LedStrategy = SW_LED_MODE1;
+			break;
+	}
+	pHalData->bLedOpenDrain = _TRUE;// Support Open-drain arrangement for controlling the LED. Added by Roger, 2009.10.16.
+#else // HW LED
+	pledpriv->LedStrategy = HW_LED;
+#endif //CONFIG_SW_LED
+}
+
+static VOID
+_ReadRFSetting(
+	IN	PADAPTER	Adapter,	
+	IN	u8* 	PROMContent,
+	IN	BOOLEAN 	AutoloadFail
+	)
+{
+}
+
+static VOID
+hal_InitPGData(
+	IN	PADAPTER	pAdapter,
+	IN	OUT	u8		*PROMContent
+	)
+{
+#if 0
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(pAdapter);
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);
+	u32	i;
+	u16	value16;
+
+	if(_FALSE == pEEPROM->bautoload_fail_flag)
+	{ // autoload OK.
+		if (_TRUE == pEEPROM->EepromOrEfuse)
+		{
+			// Read all Content from EEPROM or EFUSE.
+			for(i = 0; i < HWSET_MAX_SIZE_88E; i += 2)
+			{
+				//value16 = EF2Byte(ReadEEprom(pAdapter, (u2Byte) (i>>1)));
+				//*((u16 *)(&PROMContent[i])) = value16; 				
+			}
+		}
+		else
+		{
+			// Read EFUSE real map to shadow.
+			EFUSE_ShadowMapUpdate(pAdapter, EFUSE_WIFI, _FALSE);
+			_rtw_memcpy((void*)PROMContent, (void*)pEEPROM->efuse_eeprom_data, HWSET_MAX_SIZE_88E);
+		}
+	}
+	else
+	{//autoload fail
+		//RT_TRACE(COMP_INIT, DBG_LOUD, ("AutoLoad Fail reported from CR9346!!\n")); 
+		pEEPROM->bautoload_fail_flag = _TRUE;
+		//update to default value 0xFF
+		if (_FALSE == pEEPROM->EepromOrEfuse)		
+		EFUSE_ShadowMapUpdate(pAdapter, EFUSE_WIFI, _FALSE);	
+	}
+#endif
+}
+static void
+Hal_EfuseParsePIDVID_8188EU(
+	IN	PADAPTER		pAdapter,
+	IN	u8*				hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(pAdapter);
+
+	if( !AutoLoadFail )
+	{
+		// VID, PID 
+		pHalData->EEPROMVID = EF2Byte( *(u16 *)&hwinfo[EEPROM_VID_88EU] );
+		pHalData->EEPROMPID = EF2Byte( *(u16 *)&hwinfo[EEPROM_PID_88EU] );
+		
+		// Customer ID, 0x00 and 0xff are reserved for Realtek. 		
+		pHalData->EEPROMCustomerID = *(u8 *)&hwinfo[EEPROM_CustomID_88E];
+		pHalData->EEPROMSubCustomerID = EEPROM_Default_SubCustomerID;
+
+	}
+	else
+	{
+		pHalData->EEPROMVID 			= EEPROM_Default_VID;
+		pHalData->EEPROMPID 			= EEPROM_Default_PID;
+
+		// Customer ID, 0x00 and 0xff are reserved for Realtek. 		
+		pHalData->EEPROMCustomerID		= EEPROM_Default_CustomerID;
+		pHalData->EEPROMSubCustomerID	= EEPROM_Default_SubCustomerID;
+
+	}
+
+	DBG_871X("VID = 0x%04X, PID = 0x%04X\n", pHalData->EEPROMVID, pHalData->EEPROMPID);
+	DBG_871X("Customer ID: 0x%02X, SubCustomer ID: 0x%02X\n", pHalData->EEPROMCustomerID, pHalData->EEPROMSubCustomerID);
+}
+
+static void
+Hal_EfuseParseMACAddr_8188EU(
+	IN	PADAPTER		padapter,
+	IN	u8*			hwinfo,
+	IN	BOOLEAN			AutoLoadFail
+	)
+{
+	u16			i, usValue;
+	u8			sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x88, 0x02};
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+
+	if (AutoLoadFail)
+	{
+//		sMacAddr[5] = (u1Byte)GetRandomNumber(1, 254);
+		for (i=0; i<6; i++)
+			pEEPROM->mac_addr[i] = sMacAddr[i];
+	}
+	else
+	{
+		//Read Permanent MAC address
+		_rtw_memcpy(pEEPROM->mac_addr, &hwinfo[EEPROM_MAC_ADDR_88EU], ETH_ALEN);
+
+	}
+//	NicIFSetMacAddress(pAdapter, pAdapter->PermanentAddress);
+
+	RT_TRACE(_module_hci_hal_init_c_, _drv_notice_,
+		 ("Hal_EfuseParseMACAddr_8188ES: Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
+		  pEEPROM->mac_addr[0], pEEPROM->mac_addr[1],
+		  pEEPROM->mac_addr[2], pEEPROM->mac_addr[3],
+		  pEEPROM->mac_addr[4], pEEPROM->mac_addr[5]));
+}
+
+
+static void
+Hal_CustomizeByCustomerID_8188EU(
+	IN	PADAPTER		padapter
+	)
+{
+#if 0
+	EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+
+	// For customized behavior.
+	if((pHalData->EEPROMVID == 0x103C) && (pHalData->EEPROMVID == 0x1629))// HP Lite-On for RTL8188CUS Slim Combo.
+		pEEPROM->CustomerID = RT_CID_819x_HP;
+
+	// Decide CustomerID according to VID/DID or EEPROM
+	switch(pHalData->EEPROMCustomerID)
+	{
+		case EEPROM_CID_DEFAULT:
+			if((pHalData->EEPROMVID == 0x2001) && (pHalData->EEPROMPID == 0x3308))
+				pEEPROM->CustomerID = RT_CID_DLINK;
+			else if((pHalData->EEPROMVID == 0x2001) && (pHalData->EEPROMPID == 0x3309))
+				pEEPROM->CustomerID = RT_CID_DLINK;
+			else if((pHalData->EEPROMVID == 0x2001) && (pHalData->EEPROMPID == 0x330a))
+				pEEPROM->CustomerID = RT_CID_DLINK;
+			break;
+		case EEPROM_CID_WHQL:
+			padapter->bInHctTest = TRUE;
+
+			pMgntInfo->bSupportTurboMode = FALSE;
+			pMgntInfo->bAutoTurboBy8186 = FALSE;
+
+			pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
+			pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
+			pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
+			pMgntInfo->PowerSaveControl.bLeisurePsModeBackup =FALSE;
+			pMgntInfo->keepAliveLevel = 0;
+
+			padapter->bUnloadDriverwhenS3S4 = FALSE;
+			break;
+		default:
+			pEEPROM->CustomerID = RT_CID_DEFAULT;
+			break;
+
+	}
+
+	RT_TRACE(_module_hci_hal_init_c_, _drv_info_, ("Mgnt Customer ID: 0x%02x\n", pEEPROM->CustomerID));
+
+	hal_CustomizedBehavior_8723U(padapter);
+#endif
+}
+
+#ifdef CONFIG_EFUSE_CONFIG_FILE
+static u32 Hal_readPGDataFromConfigFile(
+	PADAPTER	padapter)
+{
+	u32 i;
+	struct file *fp;
+	mm_segment_t fs;
+	u8 temp[3];
+	loff_t pos = 0;
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+	u8	*PROMContent = pEEPROM->efuse_eeprom_data;
+
+
+	temp[2] = 0; // add end of string '\0'
+
+	fp = filp_open("/system/etc/wifi/wifi_efuse.map", O_RDWR,  0644);
+	if (IS_ERR(fp)) {
+		pEEPROM->bloadfile_fail_flag = _TRUE;
+		DBG_871X("Error, Efuse configure file doesn't exist.\n");
+		return _FAIL;
+	}
+
+	fs = get_fs();
+	set_fs(KERNEL_DS);
+
+	DBG_871X("Efuse configure file:\n");
+	for (i=0; i<HWSET_MAX_SIZE_88E; i++) {
+		vfs_read(fp, temp, 2, &pos);
+		PROMContent[i] = simple_strtoul(temp, NULL, 16 );
+		pos += 1; // Filter the space character
+		DBG_871X("%02X \n", PROMContent[i]);
+	}
+	DBG_871X("\n");
+	set_fs(fs);
+
+	filp_close(fp, NULL);
+	
+	pEEPROM->bloadfile_fail_flag = _FALSE;
+	
+	return _SUCCESS;
+}
+
+static void
+Hal_ReadMACAddrFromFile_8188EU(
+	PADAPTER		padapter
+	)
+{
+	u32 i;
+	struct file *fp;
+	mm_segment_t fs;
+	u8 source_addr[18];
+	loff_t pos = 0;
+	u32 curtime = rtw_get_current_time();
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+	u8 *head, *end;
+
+	u8 null_mac_addr[ETH_ALEN] = {0, 0, 0,0, 0, 0};
+	u8 multi_mac_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+	
+	_rtw_memset(source_addr, 0, 18);
+	_rtw_memset(pEEPROM->mac_addr, 0, ETH_ALEN);
+
+	fp = filp_open("/data/wifimac.txt", O_RDWR,  0644);
+	if (IS_ERR(fp)) {
+		pEEPROM->bloadmac_fail_flag = _TRUE;
+		DBG_871X("Error, wifi mac address file doesn't exist.\n");
+	} else {
+		fs = get_fs();
+		set_fs(KERNEL_DS);
+
+		DBG_871X("wifi mac address:\n");
+		vfs_read(fp, source_addr, 18, &pos);
+		source_addr[17] = ':';
+
+		head = end = source_addr;
+		for (i=0; i<ETH_ALEN; i++) {
+			while (end && (*end != ':') )
+				end++;
+
+			if (end && (*end == ':') )
+				*end = '\0';
+
+			pEEPROM->mac_addr[i] = simple_strtoul(head, NULL, 16 );
+
+			if (end) {
+				end++;
+				head = end;
+			}
+			DBG_871X("%02x \n", pEEPROM->mac_addr[i]);
+		}
+		DBG_871X("\n");
+		set_fs(fs);
+		pEEPROM->bloadmac_fail_flag = _FALSE;
+		filp_close(fp, NULL);
+	}
+
+	if ( (_rtw_memcmp(pEEPROM->mac_addr, null_mac_addr, ETH_ALEN)) ||
+		(_rtw_memcmp(pEEPROM->mac_addr, multi_mac_addr, ETH_ALEN)) ) {
+		pEEPROM->mac_addr[0] = 0x00;
+		pEEPROM->mac_addr[1] = 0xe0;
+		pEEPROM->mac_addr[2] = 0x4c;
+		pEEPROM->mac_addr[3] = (u8)(curtime & 0xff) ;
+		pEEPROM->mac_addr[4] = (u8)((curtime>>8) & 0xff) ;
+		pEEPROM->mac_addr[5] = (u8)((curtime>>16) & 0xff) ;
+	}
+
+	DBG_871X("Hal_ReadMACAddrFromFile_8188ES: Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
+		  pEEPROM->mac_addr[0], pEEPROM->mac_addr[1],
+		  pEEPROM->mac_addr[2], pEEPROM->mac_addr[3],
+		  pEEPROM->mac_addr[4], pEEPROM->mac_addr[5]);
+}
+#endif //CONFIG_EFUSE_CONFIG_FILE
+
+
+static VOID
+readAdapterInfo_8188EU(
+	IN	PADAPTER	padapter
+	)
+{
+#if 1
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
+
+	/* parse the eeprom/efuse content */
+	Hal_EfuseParseIDCode88E(padapter, pEEPROM->efuse_eeprom_data);
+	Hal_EfuseParsePIDVID_8188EU(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+#ifdef CONFIG_EFUSE_CONFIG_FILE
+	Hal_ReadMACAddrFromFile_8188EU(padapter);
+#else //CONFIG_EFUSE_CONFIG_FILE	
+	Hal_EfuseParseMACAddr_8188EU(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+#endif //CONFIG_EFUSE_CONFIG_FILE	
+
+	Hal_ReadPowerSavingMode88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_ReadTxPowerInfo88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);	
+	Hal_EfuseParseEEPROMVer88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	rtl8188e_EfuseParseChnlPlan(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_EfuseParseXtal_8188E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_EfuseParseCustomerID88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_ReadAntennaDiversity88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_EfuseParseBoardType88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+	Hal_ReadThermalMeter_88E(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+
+	//
+	// The following part initialize some vars by PG info.
+	//
+	Hal_InitChannelPlan(padapter);
+#if defined(CONFIG_WOWLAN) && defined(CONFIG_SDIO_HCI)
+	Hal_DetectWoWMode(padapter);
+#endif //CONFIG_WOWLAN && CONFIG_SDIO_HCI
+	Hal_CustomizeByCustomerID_8188EU(padapter);
+
+	_ReadLEDSetting(padapter, pEEPROM->efuse_eeprom_data, pEEPROM->bautoload_fail_flag);
+
+#else
+
+#ifdef CONFIG_INTEL_PROXIM	
+		/* for intel proximity */
+	if (pHalData->rf_type== RF_1T1R) {
+		Adapter->proximity.proxim_support = _TRUE;
+	} else if (pHalData->rf_type== RF_2T2R) {
+		if ((pHalData->EEPROMPID == 0x8186) &&
+			(pHalData->EEPROMVID== 0x0bda))
+		Adapter->proximity.proxim_support = _TRUE;
+	} else {
+		Adapter->proximity.proxim_support = _FALSE;
+	}
+#endif //CONFIG_INTEL_PROXIM		
+#endif
+}
+
+static void _ReadPROMContent(
+	IN PADAPTER 		Adapter
+	)
+{	
+	EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);
+	u8			eeValue;
+
+	/* check system boot selection */
+	eeValue = rtw_read8(Adapter, REG_9346CR);
+	pEEPROM->EepromOrEfuse		= (eeValue & BOOT_FROM_EEPROM) ? _TRUE : _FALSE;
+	pEEPROM->bautoload_fail_flag	= (eeValue & EEPROM_EN) ? _FALSE : _TRUE;
+
+
+	DBG_8192C("Boot from %s, Autoload %s !\n", (pEEPROM->EepromOrEfuse ? "EEPROM" : "EFUSE"),
+				(pEEPROM->bautoload_fail_flag ? "Fail" : "OK") );
+
+	//pHalData->EEType = IS_BOOT_FROM_EEPROM(Adapter) ? EEPROM_93C46 : EEPROM_BOOT_EFUSE;
+#ifdef CONFIG_EFUSE_CONFIG_FILE
+	Hal_readPGDataFromConfigFile(Adapter);
+#else //CONFIG_EFUSE_CONFIG_FILE
+	Hal_InitPGData88E(Adapter);
+#endif	//CONFIG_EFUSE_CONFIG_FILE
+	readAdapterInfo_8188EU(Adapter);
+}
+
+
+
+static VOID
+_ReadRFType(
+	IN	PADAPTER	Adapter
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+
+#if DISABLE_BB_RF
+	pHalData->rf_chip = RF_PSEUDO_11N;
+#else
+	pHalData->rf_chip = RF_6052;
+#endif
+}
+
+static int _ReadAdapterInfo8188EU(PADAPTER	Adapter)
+{
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	u32 start=rtw_get_current_time();
+	
+	MSG_8192C("====> %s\n", __FUNCTION__);
+
+	//Efuse_InitSomeVar(Adapter);
+
+	//if(IS_HARDWARE_TYPE_8723A(Adapter))
+	//	_EfuseCellSel(Adapter);
+
+	_ReadRFType(Adapter);//rf_chip -> _InitRFType()
+	_ReadPROMContent(Adapter);
+
+	//MSG_8192C("%s()(done), rf_chip=0x%x, rf_type=0x%x\n",  __FUNCTION__, pHalData->rf_chip, pHalData->rf_type);
+
+	MSG_8192C("<==== %s in %d ms\n", __FUNCTION__, rtw_get_passing_time_ms(start));
+
+	return _SUCCESS;
+}
+
+
+static void ReadAdapterInfo8188EU(PADAPTER Adapter)
+{
+	// Read EEPROM size before call any EEPROM function	
+	Adapter->EepromAddressSize = GetEEPROMSize8188E(Adapter);
+	
+	_ReadAdapterInfo8188EU(Adapter);
+}
+
+
+#define GPIO_DEBUG_PORT_NUM 0
+static void rtl8192cu_trigger_gpio_0(_adapter *padapter)
+{
+#ifdef CONFIG_USB_SUPPORT_ASYNC_VDN_REQ	
+	u32 gpioctrl;
+	DBG_8192C("==> trigger_gpio_0...\n");
+	rtw_write16_async(padapter,REG_GPIO_PIN_CTRL,0);
+	rtw_write8_async(padapter,REG_GPIO_PIN_CTRL+2,0xFF);
+	gpioctrl = (BIT(GPIO_DEBUG_PORT_NUM)<<24 )|(BIT(GPIO_DEBUG_PORT_NUM)<<16);
+	rtw_write32_async(padapter,REG_GPIO_PIN_CTRL,gpioctrl);
+	gpioctrl |= (BIT(GPIO_DEBUG_PORT_NUM)<<8);
+	rtw_write32_async(padapter,REG_GPIO_PIN_CTRL,gpioctrl);
+	DBG_8192C("<=== trigger_gpio_0...\n");
+#endif
+}
+
+static void ResumeTxBeacon(_adapter *padapter)
+{
+	HAL_DATA_TYPE*	pHalData = GET_HAL_DATA(padapter);	
+
+	// 2010.03.01. Marked by tynli. No need to call workitem beacause we record the value
+	// which should be read from register to a global variable.
+
+	rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, (pHalData->RegFwHwTxQCtrl) | BIT6);
+	pHalData->RegFwHwTxQCtrl |= BIT6;
+	rtw_write8(padapter, REG_TBTT_PROHIBIT+1, 0xff);
+	pHalData->RegReg542 |= BIT0;
+	rtw_write8(padapter, REG_TBTT_PROHIBIT+2, pHalData->RegReg542);
+}
+void UpdateInterruptMask8188EU(PADAPTER padapter,u8 bHIMR0 ,u32 AddMSR, u32 RemoveMSR)
+{
+	HAL_DATA_TYPE *pHalData;
+
+	u32 *himr;
+	pHalData = GET_HAL_DATA(padapter);
+
+	if(bHIMR0)
+		himr = &(pHalData->IntrMask[0]);
+	else
+		himr = &(pHalData->IntrMask[1]);
+	
+	if (AddMSR)
+		*himr |= AddMSR;
+
+	if (RemoveMSR)
+		*himr &= (~RemoveMSR);
+
+	if(bHIMR0)	
+		rtw_write32(padapter, REG_HIMR_88E, *himr);
+	else
+		rtw_write32(padapter, REG_HIMRE_88E, *himr);	
+
+}
+
+static void StopTxBeacon(_adapter *padapter)
+{
+	HAL_DATA_TYPE*	pHalData = GET_HAL_DATA(padapter);
+
+	// 2010.03.01. Marked by tynli. No need to call workitem beacause we record the value
+	// which should be read from register to a global variable.
+
+	rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, (pHalData->RegFwHwTxQCtrl) & (~BIT6));
+	pHalData->RegFwHwTxQCtrl &= (~BIT6);
+	rtw_write8(padapter, REG_TBTT_PROHIBIT+1, 0x64);
+	pHalData->RegReg542 &= ~(BIT0);
+	rtw_write8(padapter, REG_TBTT_PROHIBIT+2, pHalData->RegReg542);
+
+	 //todo: CheckFwRsvdPageContent(Adapter);  // 2010.06.23. Added by tynli.
+
+}
+
+
+static void hw_var_set_opmode(PADAPTER Adapter, u8 variable, u8* val)
+{
+	u8	val8;
+	u8	mode = *((u8 *)val);
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+
+#ifdef CONFIG_CONCURRENT_MODE
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		// disable Port1 TSF update
+		rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(4));
+		
+		// set net_type
+		val8 = rtw_read8(Adapter, MSR)&0x03;
+		val8 |= (mode<<2);
+		rtw_write8(Adapter, MSR, val8);
+		
+		DBG_871X("%s()-%d mode = %d\n", __FUNCTION__, __LINE__, mode);
+
+		if((mode == _HW_STATE_STATION_) || (mode == _HW_STATE_NOLINK_))
+		{
+			if(!check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE))			
+			{
+				#ifdef CONFIG_INTERRUPT_BASED_TXBCN	
+
+				#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT	
+				rtw_write8(Adapter, REG_DRVERLYINT, 0x05);//restore early int time to 5ms
+				UpdateInterruptMask8188EU(Adapter,_TRUE, 0, IMR_BCNDMAINT0_88E);	
+				#endif // CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+				
+				#ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR		
+				UpdateInterruptMask8188EU(Adapter,_TRUE ,0, (IMR_TBDER_88E|IMR_TBDOK_88E));	
+				#endif// CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+					
+				#endif //CONFIG_INTERRUPT_BASED_TXBCN		
+			
+
+				StopTxBeacon(Adapter);
+			}
+			
+			rtw_write8(Adapter,REG_BCN_CTRL_1, 0x11);//disable atim wnd and disable beacon function
+			//rtw_write8(Adapter,REG_BCN_CTRL_1, 0x18);
+		}
+		else if((mode == _HW_STATE_ADHOC_) /*|| (mode == _HW_STATE_AP_)*/)
+		{
+			ResumeTxBeacon(Adapter);
+			rtw_write8(Adapter,REG_BCN_CTRL_1, 0x1a);
+			//BIT4 - If set 0, hw will clr bcnq when tx becon ok/fail or port 1
+			rtw_write8(Adapter, REG_MBID_NUM, rtw_read8(Adapter, REG_MBID_NUM)|BIT(3)|BIT(4));
+		}
+		else if(mode == _HW_STATE_AP_)
+		{
+#ifdef CONFIG_INTERRUPT_BASED_TXBCN			
+			#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+			UpdateInterruptMask8188EU(Adapter,_TRUE ,IMR_BCNDMAINT0_88E, 0);
+			#endif//CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+
+			#ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR	
+			UpdateInterruptMask8188EU(Adapter,_TRUE ,(IMR_TBDER_88E|IMR_TBDOK_88E), 0);
+			#endif//CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+					
+#endif //CONFIG_INTERRUPT_BASED_TXBCN
+
+			ResumeTxBeacon(Adapter);
+					
+			rtw_write8(Adapter, REG_BCN_CTRL_1, 0x12);
+
+			//Set RCR
+			//rtw_write32(padapter, REG_RCR, 0x70002a8e);//CBSSID_DATA must set to 0
+			//rtw_write32(Adapter, REG_RCR, 0x7000228e);//CBSSID_DATA must set to 0
+			rtw_write32(Adapter, REG_RCR, 0x7000208e);//CBSSID_DATA must set to 0,reject ICV_ERR packet
+			//enable to rx data frame				
+			rtw_write16(Adapter, REG_RXFLTMAP2, 0xFFFF);
+			//enable to rx ps-poll
+			rtw_write16(Adapter, REG_RXFLTMAP1, 0x0400);
+
+			//Beacon Control related register for first time 
+			rtw_write8(Adapter, REG_BCNDMATIM, 0x02); // 2ms		
+
+			//rtw_write8(Adapter, REG_BCN_MAX_ERR, 0xFF);
+			rtw_write8(Adapter, REG_ATIMWND_1, 0x0a); // 10ms for port1
+			rtw_write16(Adapter, REG_BCNTCFG, 0x00);
+			rtw_write16(Adapter, REG_TBTT_PROHIBIT, 0xff04);
+			rtw_write16(Adapter, REG_TSFTR_SYN_OFFSET, 0x7fff);// +32767 (~32ms)
+	
+			//reset TSF2	
+			rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(1));
+
+
+			//BIT4 - If set 0, hw will clr bcnq when tx becon ok/fail or port 1
+			rtw_write8(Adapter, REG_MBID_NUM, rtw_read8(Adapter, REG_MBID_NUM)|BIT(3)|BIT(4));
+		       	//enable BCN1 Function for if2
+			//don't enable update TSF1 for if2 (due to TSF update when beacon/probe rsp are received)
+			rtw_write8(Adapter, REG_BCN_CTRL_1, (DIS_TSF_UDT0_NORMAL_CHIP|EN_BCN_FUNCTION | EN_TXBCN_RPT|BIT(1)));
+
+#ifdef CONFIG_CONCURRENT_MODE
+			if(check_buddy_fwstate(Adapter, WIFI_FW_NULL_STATE))
+				rtw_write8(Adapter, REG_BCN_CTRL, 
+					rtw_read8(Adapter, REG_BCN_CTRL) & ~EN_BCN_FUNCTION);
+#endif
+                        //BCN1 TSF will sync to BCN0 TSF with offset(0x518) if if1_sta linked
+			//rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(5));
+			//rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(3));
+					
+			//dis BCN0 ATIM  WND if if1 is station
+			rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(0));
+
+#ifdef CONFIG_TSF_RESET_OFFLOAD
+			// Reset TSF for STA+AP concurrent mode
+			if ( check_buddy_fwstate(Adapter, (WIFI_STATION_STATE|WIFI_ASOC_STATE)) ) {
+				if (reset_tsf(Adapter, IFACE_PORT1) == _FALSE)
+					DBG_871X("ERROR! %s()-%d: Reset port1 TSF fail\n",
+						__FUNCTION__, __LINE__);
+			}
+#endif	// CONFIG_TSF_RESET_OFFLOAD	
+		}
+	}
+	else
+#endif //CONFIG_CONCURRENT_MODE
+	{
+		// disable Port0 TSF update
+		rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));
+		
+		// set net_type
+		val8 = rtw_read8(Adapter, MSR)&0x0c;
+		val8 |= mode;
+		rtw_write8(Adapter, MSR, val8);
+		
+		DBG_871X("%s()-%d mode = %d\n", __FUNCTION__, __LINE__, mode);
+		
+		if((mode == _HW_STATE_STATION_) || (mode == _HW_STATE_NOLINK_))
+		{
+#ifdef CONFIG_CONCURRENT_MODE
+			if(!check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE))		
+#endif //CONFIG_CONCURRENT_MODE
+			{
+			#ifdef CONFIG_INTERRUPT_BASED_TXBCN	
+				#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+				rtw_write8(Adapter, REG_DRVERLYINT, 0x05);//restore early int time to 5ms					
+				UpdateInterruptMask8188EU(Adapter,_TRUE, 0, IMR_BCNDMAINT0_88E);	
+				#endif//CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+				
+				#ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR		
+				UpdateInterruptMask8188EU(Adapter,_TRUE ,0, (IMR_TBDER_88E|IMR_TBDOK_88E));	
+				#endif //CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+					
+			#endif //CONFIG_INTERRUPT_BASED_TXBCN		
+				StopTxBeacon(Adapter);
+			}
+			
+			rtw_write8(Adapter,REG_BCN_CTRL, 0x19);//disable atim wnd
+			//rtw_write8(Adapter,REG_BCN_CTRL, 0x18);
+		}
+		else if((mode == _HW_STATE_ADHOC_) /*|| (mode == _HW_STATE_AP_)*/)
+		{
+			ResumeTxBeacon(Adapter);
+			rtw_write8(Adapter,REG_BCN_CTRL, 0x1a);
+			//BIT3 - If set 0, hw will clr bcnq when tx becon ok/fail or port 0
+			rtw_write8(Adapter, REG_MBID_NUM, rtw_read8(Adapter, REG_MBID_NUM)|BIT(3)|BIT(4));
+		}
+		else if(mode == _HW_STATE_AP_)
+		{
+
+#ifdef CONFIG_INTERRUPT_BASED_TXBCN			
+			#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+			UpdateInterruptMask8188EU(Adapter,_TRUE ,IMR_BCNDMAINT0_88E, 0);
+			#endif//CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+
+			#ifdef CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR	
+			UpdateInterruptMask8188EU(Adapter,_TRUE ,(IMR_TBDER_88E|IMR_TBDOK_88E), 0);
+			#endif//CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+					
+#endif //CONFIG_INTERRUPT_BASED_TXBCN
+
+
+			ResumeTxBeacon(Adapter);
+
+			rtw_write8(Adapter, REG_BCN_CTRL, 0x12);
+
+			//Set RCR
+			//rtw_write32(padapter, REG_RCR, 0x70002a8e);//CBSSID_DATA must set to 0
+			//rtw_write32(Adapter, REG_RCR, 0x7000228e);//CBSSID_DATA must set to 0
+			rtw_write32(Adapter, REG_RCR, 0x7000208e);//CBSSID_DATA must set to 0,reject ICV_ERR packet
+			//enable to rx data frame
+			rtw_write16(Adapter, REG_RXFLTMAP2, 0xFFFF);
+			//enable to rx ps-poll
+			rtw_write16(Adapter, REG_RXFLTMAP1, 0x0400);
+
+			//Beacon Control related register for first time
+			rtw_write8(Adapter, REG_BCNDMATIM, 0x02); // 2ms			
+			
+			//rtw_write8(Adapter, REG_BCN_MAX_ERR, 0xFF);
+			rtw_write8(Adapter, REG_ATIMWND, 0x0a); // 10ms
+			rtw_write16(Adapter, REG_BCNTCFG, 0x00);
+			rtw_write16(Adapter, REG_TBTT_PROHIBIT, 0xff04);
+			rtw_write16(Adapter, REG_TSFTR_SYN_OFFSET, 0x7fff);// +32767 (~32ms)
+
+			//reset TSF
+			rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(0));
+
+			//BIT3 - If set 0, hw will clr bcnq when tx becon ok/fail or port 0
+			rtw_write8(Adapter, REG_MBID_NUM, rtw_read8(Adapter, REG_MBID_NUM)|BIT(3)|BIT(4));
+	
+		        //enable BCN0 Function for if1
+			//don't enable update TSF0 for if1 (due to TSF update when beacon/probe rsp are received)
+			#if defined(CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR)
+			rtw_write8(Adapter, REG_BCN_CTRL, (DIS_TSF_UDT0_NORMAL_CHIP|EN_BCN_FUNCTION | EN_TXBCN_RPT|BIT(1)));
+			#else
+			rtw_write8(Adapter, REG_BCN_CTRL, (DIS_TSF_UDT0_NORMAL_CHIP|EN_BCN_FUNCTION |BIT(1)));
+			#endif
+
+#ifdef CONFIG_CONCURRENT_MODE
+			if(check_buddy_fwstate(Adapter, WIFI_FW_NULL_STATE))
+				rtw_write8(Adapter, REG_BCN_CTRL_1, 
+					rtw_read8(Adapter, REG_BCN_CTRL_1) & ~EN_BCN_FUNCTION);
+#endif
+
+			//dis BCN1 ATIM  WND if if2 is station
+			rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(0));	
+#ifdef CONFIG_TSF_RESET_OFFLOAD
+			// Reset TSF for STA+AP concurrent mode
+			if ( check_buddy_fwstate(Adapter, (WIFI_STATION_STATE|WIFI_ASOC_STATE)) ) {
+				if (reset_tsf(Adapter, IFACE_PORT0) == _FALSE)
+					DBG_871X("ERROR! %s()-%d: Reset port0 TSF fail\n",
+						__FUNCTION__, __LINE__);
+			}
+#endif	// CONFIG_TSF_RESET_OFFLOAD
+		}
+	}
+
+}
+
+static void hw_var_set_macaddr(PADAPTER Adapter, u8 variable, u8* val)
+{
+	u8 idx = 0;
+	u32 reg_macid;
+
+#ifdef CONFIG_CONCURRENT_MODE
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		reg_macid = REG_MACID1;
+	}
+	else
+#endif
+	{
+		reg_macid = REG_MACID;
+	}
+
+	for(idx = 0 ; idx < 6; idx++)
+	{
+		rtw_write8(Adapter, (reg_macid+idx), val[idx]);
+	}
+	
+}
+
+static void hw_var_set_bssid(PADAPTER Adapter, u8 variable, u8* val)
+{
+	u8	idx = 0;
+	u32 reg_bssid;
+
+#ifdef CONFIG_CONCURRENT_MODE
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		reg_bssid = REG_BSSID1;
+	}
+	else
+#endif
+	{
+		reg_bssid = REG_BSSID;
+	}
+
+	for(idx = 0 ; idx < 6; idx++)
+	{
+		rtw_write8(Adapter, (reg_bssid+idx), val[idx]);
+	}
+
+}
+
+static void hw_var_set_bcn_func(PADAPTER Adapter, u8 variable, u8* val)
+{
+	u32 bcn_ctrl_reg;
+
+#ifdef CONFIG_CONCURRENT_MODE
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		bcn_ctrl_reg = REG_BCN_CTRL_1;
+	}	
+	else
+#endif		
+	{		
+		bcn_ctrl_reg = REG_BCN_CTRL;
+	}
+
+	if(*((u8 *)val))
+	{
+		rtw_write8(Adapter, bcn_ctrl_reg, (EN_BCN_FUNCTION | EN_TXBCN_RPT));
+	}
+	else
+	{
+		rtw_write8(Adapter, bcn_ctrl_reg, rtw_read8(Adapter, bcn_ctrl_reg)&(~(EN_BCN_FUNCTION | EN_TXBCN_RPT)));
+	}
+	
+
+}
+
+static void hw_var_set_correct_tsf(PADAPTER Adapter, u8 variable, u8* val)
+{
+#ifdef CONFIG_CONCURRENT_MODE
+	u64	tsf;
+	struct mlme_ext_priv	*pmlmeext = &Adapter->mlmeextpriv;
+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+	PADAPTER pbuddy_adapter = Adapter->pbuddy_adapter;
+
+	//tsf = pmlmeext->TSFValue - ((u32)pmlmeext->TSFValue % (pmlmeinfo->bcn_interval*1024)) -1024; //us
+	tsf = pmlmeext->TSFValue - rtw_modular64(pmlmeext->TSFValue, (pmlmeinfo->bcn_interval*1024)) -1024; //us
+
+	if(((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE))
+	{				
+		//pHalData->RegTxPause |= STOP_BCNQ;BIT(6)
+		//rtw_write8(Adapter, REG_TXPAUSE, (rtw_read8(Adapter, REG_TXPAUSE)|BIT(6)));
+		StopTxBeacon(Adapter);
+	}
+
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		//disable related TSF function
+		rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)&(~BIT(3)));
+							
+		rtw_write32(Adapter, REG_TSFTR1, tsf);
+		rtw_write32(Adapter, REG_TSFTR1+4, tsf>>32);
+
+
+		//enable related TSF function
+		rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(3));	
+
+		// Update buddy port's TSF if it is SoftAP for beacon TX issue!
+		if ( (pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE
+			&& check_buddy_fwstate(Adapter, WIFI_AP_STATE)
+		) { 
+			//disable related TSF function
+			rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(3)));
+
+			rtw_write32(Adapter, REG_TSFTR, tsf);
+			rtw_write32(Adapter, REG_TSFTR+4, tsf>>32);
+
+			//enable related TSF function
+			rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(3));
+#ifdef CONFIG_TSF_RESET_OFFLOAD
+		// Update buddy port's TSF(TBTT) if it is SoftAP for beacon TX issue!
+			if (reset_tsf(Adapter, IFACE_PORT0) == _FALSE)
+				DBG_871X("ERROR! %s()-%d: Reset port0 TSF fail\n",
+					__FUNCTION__, __LINE__);
+
+#endif	// CONFIG_TSF_RESET_OFFLOAD	
+		}		
+
+		
+	}
+	else
+	{
+		//disable related TSF function
+		rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(3)));
+							
+		rtw_write32(Adapter, REG_TSFTR, tsf);
+		rtw_write32(Adapter, REG_TSFTR+4, tsf>>32);
+
+		//enable related TSF function
+		rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(3));
+		
+		// Update buddy port's TSF if it is SoftAP for beacon TX issue!
+		if ( (pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE
+			&& check_buddy_fwstate(Adapter, WIFI_AP_STATE)
+		) { 
+			//disable related TSF function
+			rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)&(~BIT(3)));
+
+			rtw_write32(Adapter, REG_TSFTR1, tsf);
+			rtw_write32(Adapter, REG_TSFTR1+4, tsf>>32);
+
+			//enable related TSF function
+			rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(3));
+#ifdef CONFIG_TSF_RESET_OFFLOAD
+		// Update buddy port's TSF if it is SoftAP for beacon TX issue!
+			if (reset_tsf(Adapter, IFACE_PORT1) == _FALSE)
+				DBG_871X("ERROR! %s()-%d: Reset port1 TSF fail\n",
+					__FUNCTION__, __LINE__);
+#endif	// CONFIG_TSF_RESET_OFFLOAD
+		}		
+
+	}
+				
+							
+	if(((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE))
+	{
+		//pHalData->RegTxPause  &= (~STOP_BCNQ);
+		//rtw_write8(Adapter, REG_TXPAUSE, (rtw_read8(Adapter, REG_TXPAUSE)&(~BIT(6))));
+		ResumeTxBeacon(Adapter);
+	}
+#endif
+}
+
+static void hw_var_set_mlme_disconnect(PADAPTER Adapter, u8 variable, u8* val)
+{
+#ifdef CONFIG_CONCURRENT_MODE
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	PADAPTER pbuddy_adapter = Adapter->pbuddy_adapter;
+			
+				
+	if(check_buddy_mlmeinfo_state(Adapter, _HW_STATE_NOLINK_))	
+		rtw_write16(Adapter, REG_RXFLTMAP2, 0x00);
+	
+
+	if(Adapter->iface_type == IFACE_PORT1)
+	{
+		//reset TSF1
+		rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(1));
+
+		//disable update TSF1
+		rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(4));
+
+		// disable Port1's beacon function
+		rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)&(~BIT(3)));
+	}
+	else
+	{
+		//reset TSF
+		rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(0));
+
+		//disable update TSF
+		rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));
+	}
+#endif
+}
+
+static void hw_var_set_mlme_sitesurvey(PADAPTER Adapter, u8 variable, u8* val)
+{	
+#ifdef CONFIG_CONCURRENT_MODE	
+
+	struct mlme_ext_priv *pmlmeext = &Adapter->mlmeextpriv;
+	struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
+
+	if(*((u8 *)val))//under sitesurvey
+	{
+		//config RCR to receive different BSSID & not to receive data frame
+		u32 v = rtw_read32(Adapter, REG_RCR);
+		v &= ~(RCR_CBSSID_BCN);
+		rtw_write32(Adapter, REG_RCR, v);
+
+		//disable update TSF
+		if((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE)
+		{
+			if(Adapter->iface_type == IFACE_PORT1)
+			{
+				rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)|BIT(4));
+			}
+			else
+			{
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));
+			}				
+		}
+				
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE) &&
+			check_buddy_fwstate(Adapter, _FW_LINKED))		
+		{
+			StopTxBeacon(Adapter);
+		}
+	}
+	else//sitesurvey done
+	{
+		//enable to rx data frame
+		//write32(Adapter, REG_RCR, read32(padapter, REG_RCR)|RCR_ADF);
+		rtw_write16(Adapter, REG_RXFLTMAP2,0xFFFF);
+
+		//enable update TSF
+		if(Adapter->iface_type == IFACE_PORT1)
+			rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)&(~BIT(4)));
+		else
+			rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(4)));
+
+		rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_BCN);
+					
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE) &&
+			check_buddy_fwstate(Adapter, _FW_LINKED))
+		{
+			ResumeTxBeacon(Adapter);			
+		}
+	}
+#endif			
+}
+
+static void hw_var_set_mlme_join(PADAPTER Adapter, u8 variable, u8* val)
+{
+#ifdef CONFIG_CONCURRENT_MODE
+	u8	RetryLimit = 0x30;
+	u8	type = *((u8 *)val);
+	HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
+	struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
+	EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);
+
+	if(type == 0) // prepare to join
+	{		
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE) &&
+			check_buddy_fwstate(Adapter, _FW_LINKED))		
+		{
+			StopTxBeacon(Adapter);
+		}
+	
+		//enable to rx data frame.Accept all data frame
+		//rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR)|RCR_ADF);
+		rtw_write16(Adapter, REG_RXFLTMAP2,0xFFFF);
+
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE))
+			rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_BCN);
+		else
+			rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_DATA|RCR_CBSSID_BCN);
+
+		if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
+		{
+			RetryLimit = (pEEPROM->CustomerID == RT_CID_CCX) ? 7 : 48;
+		}
+		else // Ad-hoc Mode
+		{
+			RetryLimit = 0x7;
+		}
+	}
+	else if(type == 1) //joinbss_event call back when join res < 0
+	{		
+		if(check_buddy_mlmeinfo_state(Adapter, _HW_STATE_NOLINK_))		
+			rtw_write16(Adapter, REG_RXFLTMAP2,0x00);
+
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE) &&
+			check_buddy_fwstate(Adapter, _FW_LINKED))
+		{
+			ResumeTxBeacon(Adapter);			
+			
+			//reset TSF 1/2 after ResumeTxBeacon
+			rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(1)|BIT(0));	
+			
+		}
+	}
+	else if(type == 2) //sta add event call back
+	{
+	 
+		//enable update TSF
+		if(Adapter->iface_type == IFACE_PORT1)
+			rtw_write8(Adapter, REG_BCN_CTRL_1, rtw_read8(Adapter, REG_BCN_CTRL_1)&(~BIT(4)));
+		else
+			rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(4)));
+		 
+	
+		if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE))
+		{
+			//fixed beacon issue for 8191su...........
+			rtw_write8(Adapter,0x542 ,0x02);
+			RetryLimit = 0x7;
+		}
+
+
+		if(check_buddy_mlmeinfo_state(Adapter, WIFI_FW_AP_STATE) &&
+			check_buddy_fwstate(Adapter, _FW_LINKED))
+		{
+			ResumeTxBeacon(Adapter);			
+			
+			//reset TSF 1/2 after ResumeTxBeacon
+			rtw_write8(Adapter, REG_DUAL_TSF_RST, BIT(1)|BIT(0));
+		}
+		
+	}
+
+	rtw_write16(Adapter, REG_RL, RetryLimit << RETRY_LIMIT_SHORT_SHIFT | RetryLimit << RETRY_LIMIT_LONG_SHIFT);
+	
+#endif
+}
+
+void SetHwReg8188EU(PADAPTER Adapter, u8 variable, u8* val)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	struct dm_priv	*pdmpriv = &pHalData->dmpriv;
+	DM_ODM_T 		*podmpriv = &pHalData->odmpriv;
+_func_enter_;
+
+	switch(variable)
+	{
+		case HW_VAR_MEDIA_STATUS:
+			{
+				u8 val8;
+
+				val8 = rtw_read8(Adapter, MSR)&0x0c;
+				val8 |= *((u8 *)val);
+				rtw_write8(Adapter, MSR, val8);
+			}
+			break;
+		case HW_VAR_MEDIA_STATUS1:
+			{
+				u8 val8;
+				
+				val8 = rtw_read8(Adapter, MSR)&0x03;
+				val8 |= *((u8 *)val) <<2;
+				rtw_write8(Adapter, MSR, val8);
+			}
+			break;
+		case HW_VAR_SET_OPMODE:
+			hw_var_set_opmode(Adapter, variable, val);
+			break;
+		case HW_VAR_MAC_ADDR:
+			hw_var_set_macaddr(Adapter, variable, val);			
+			break;
+		case HW_VAR_BSSID:
+			hw_var_set_bssid(Adapter, variable, val);
+			break;
+		case HW_VAR_TXPAUSE:
+			rtw_write8(Adapter, REG_TXPAUSE, *((u8 *)val));	
+			break;
+		case HW_VAR_BCN_FUNC:
+			hw_var_set_bcn_func(Adapter, variable, val);
+			break;
+		case HW_VAR_CORRECT_TSF:
+#ifdef CONFIG_CONCURRENT_MODE
+			hw_var_set_correct_tsf(Adapter, variable, val);
+#else			
+			{
+				u64	tsf;
+				struct mlme_ext_priv	*pmlmeext = &Adapter->mlmeextpriv;
+				struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+
+				//tsf = pmlmeext->TSFValue - ((u32)pmlmeext->TSFValue % (pmlmeinfo->bcn_interval*1024)) -1024; //us
+				tsf = pmlmeext->TSFValue - rtw_modular64(pmlmeext->TSFValue, (pmlmeinfo->bcn_interval*1024)) -1024; //us
+
+				if(((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE))
+				{				
+					//pHalData->RegTxPause |= STOP_BCNQ;BIT(6)
+					//rtw_write8(Adapter, REG_TXPAUSE, (rtw_read8(Adapter, REG_TXPAUSE)|BIT(6)));
+					StopTxBeacon(Adapter);
+				}
+
+				//disable related TSF function
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(3)));
+							
+				rtw_write32(Adapter, REG_TSFTR, tsf);
+				rtw_write32(Adapter, REG_TSFTR+4, tsf>>32);
+
+				//enable related TSF function
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(3));
+				
+							
+				if(((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) || ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE))
+				{
+					//pHalData->RegTxPause  &= (~STOP_BCNQ);
+					//rtw_write8(Adapter, REG_TXPAUSE, (rtw_read8(Adapter, REG_TXPAUSE)&(~BIT(6))));
+					ResumeTxBeacon(Adapter);
+				}
+			}
+#endif
+			break;
+		case HW_VAR_CHECK_BSSID:
+			if(*((u8 *)val))
+			{ 
+				rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_DATA|RCR_CBSSID_BCN); 
+			}
+			else
+			{
+				u32	val32;
+
+				val32 = rtw_read32(Adapter, REG_RCR);
+ 
+				val32 &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN);
+
+				rtw_write32(Adapter, REG_RCR, val32);
+			}
+			break;
+		case HW_VAR_MLME_DISCONNECT:
+#ifdef CONFIG_CONCURRENT_MODE
+			hw_var_set_mlme_disconnect(Adapter, variable, val);
+#else
+			{
+				//Set RCR to not to receive data frame when NO LINK state
+				//rtw_write32(Adapter, REG_RCR, rtw_read32(padapter, REG_RCR) & ~RCR_ADF);
+				//reject all data frames
+				rtw_write16(Adapter, REG_RXFLTMAP2,0x00);
+
+				//reset TSF
+				rtw_write8(Adapter, REG_DUAL_TSF_RST, (BIT(0)|BIT(1)));
+
+				//disable update TSF
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));	
+			}
+#endif
+			break;
+		case HW_VAR_MLME_SITESURVEY:
+#ifdef CONFIG_CONCURRENT_MODE
+			hw_var_set_mlme_sitesurvey(Adapter, variable,  val);
+#else
+			if(*((u8 *)val))//under sitesurvey
+			{
+				//config RCR to receive different BSSID & not to receive data frame
+				u32 v = rtw_read32(Adapter, REG_RCR);
+				v &= ~(RCR_CBSSID_BCN);
+				rtw_write32(Adapter, REG_RCR, v);
+				//reject all data frame
+				rtw_write16(Adapter, REG_RXFLTMAP2,0x00);
+
+				//disable update TSF
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));
+			}
+			else//sitesurvey done
+			{
+				struct mlme_ext_priv	*pmlmeext = &Adapter->mlmeextpriv;
+				struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+
+				if ((is_client_associated_to_ap(Adapter) == _TRUE) ||
+					((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) )
+				{
+					//enable to rx data frame
+					//rtw_write32(Adapter, REG_RCR, rtw_read32(padapter, REG_RCR)|RCR_ADF);
+					rtw_write16(Adapter, REG_RXFLTMAP2,0xFFFF);
+
+					//enable update TSF
+					rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(4)));
+				}
+				else if((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
+				{
+					//rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_ADF);
+					rtw_write16(Adapter, REG_RXFLTMAP2,0xFFFF);
+
+					//enable update TSF
+					rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(4)));
+				}
+
+				if((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
+					rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_BCN);
+				else
+				{
+					if(Adapter->in_cta_test)
+					{
+						u32 v = rtw_read32(Adapter, REG_RCR);
+						v &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN );//| RCR_ADF
+						rtw_write32(Adapter, REG_RCR, v);
+					}
+					else
+					{
+						rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_BCN);
+					}
+				}
+			}
+#endif			
+			break;
+		case HW_VAR_MLME_JOIN:
+#ifdef CONFIG_CONCURRENT_MODE
+			hw_var_set_mlme_join(Adapter, variable,  val);
+#else
+			{
+				u8	RetryLimit = 0x30;
+				u8	type = *((u8 *)val);
+				struct mlme_priv	*pmlmepriv = &Adapter->mlmepriv;
+				EEPROM_EFUSE_PRIV	*pEEPROM = GET_EEPROM_EFUSE_PRIV(Adapter);
+				
+				if(type == 0) // prepare to join
+				{
+					//enable to rx data frame.Accept all data frame
+					//rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR)|RCR_ADF);
+					rtw_write16(Adapter, REG_RXFLTMAP2,0xFFFF);
+
+					if(Adapter->in_cta_test)
+					{
+						u32 v = rtw_read32(Adapter, REG_RCR);
+						v &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN );//| RCR_ADF
+						rtw_write32(Adapter, REG_RCR, v);
+					}
+					else
+					{
+						rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_CBSSID_DATA|RCR_CBSSID_BCN);
+					}
+
+					if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
+					{
+						RetryLimit = (pEEPROM->CustomerID == RT_CID_CCX) ? 7 : 48;
+					}
+					else // Ad-hoc Mode
+					{
+						RetryLimit = 0x7;
+					}
+				}
+				else if(type == 1) //joinbss_event call back when join res < 0
+				{
+					rtw_write16(Adapter, REG_RXFLTMAP2,0x00);
+				}
+				else if(type == 2) //sta add event call back
+				{
+					//enable update TSF
+					rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~BIT(4)));
+
+					if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE))
+					{
+						RetryLimit = 0x7;
+					}
+				}
+
+				rtw_write16(Adapter, REG_RL, RetryLimit << RETRY_LIMIT_SHORT_SHIFT | RetryLimit << RETRY_LIMIT_LONG_SHIFT);
+			}
+#endif
+			break;
+		case HW_VAR_ON_RCR_AM:
+                        rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|RCR_AM);
+                        DBG_871X("%s, %d, RCR= %x \n", __FUNCTION__,__LINE__, rtw_read32(Adapter, REG_RCR));
+                        break;
+              case HW_VAR_OFF_RCR_AM:
+                        rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)& (~RCR_AM));
+                        DBG_871X("%s, %d, RCR= %x \n", __FUNCTION__,__LINE__, rtw_read32(Adapter, REG_RCR));
+                        break;
+		case HW_VAR_BEACON_INTERVAL:
+			rtw_write16(Adapter, REG_BCN_INTERVAL, *((u16 *)val));
+#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+			{
+				struct mlme_ext_priv	*pmlmeext = &Adapter->mlmeextpriv;
+				struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+				u16 bcn_interval = 	*((u16 *)val);
+				if((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE){
+					DBG_8192C("%s==> bcn_interval:%d, eraly_int:%d \n",__FUNCTION__,bcn_interval,bcn_interval>>1);
+					rtw_write8(Adapter, REG_DRVERLYINT, bcn_interval>>1);// 50ms for sdio 
+				}			
+			}
+#endif//CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+
+			break;
+		case HW_VAR_SLOT_TIME:
+			{
+				rtw_write8(Adapter, REG_SLOT, val[0]);
+			}
+			break;
+		case HW_VAR_ACK_PREAMBLE:
+			{
+				u8	regTmp;
+				u8	bShortPreamble = *( (PBOOLEAN)val );
+				// Joseph marked out for Netgear 3500 TKIP channel 7 issue.(Temporarily)
+				regTmp = (pHalData->nCur40MhzPrimeSC)<<5;
+				rtw_write8(Adapter, REG_RRSR+2, regTmp);
+
+				regTmp = rtw_read8(Adapter,REG_WMAC_TRXPTCL_CTL+2);
+				if(bShortPreamble)		
+					regTmp |= BIT1;
+				else
+					regTmp &= (~BIT1);
+				rtw_write8(Adapter,REG_WMAC_TRXPTCL_CTL+2,regTmp);				
+			}
+			break;
+		case HW_VAR_CAM_EMPTY_ENTRY:
+			{
+				u8	ucIndex = *((u8 *)val);
+				u8	i;
+				u32	ulCommand=0;
+				u32	ulContent=0;
+				u32	ulEncAlgo=CAM_AES;
+
+				for(i=0;i<CAM_CONTENT_COUNT;i++)
+				{
+					// filled id in CAM config 2 byte
+					if( i == 0)
+					{
+						ulContent |=(ucIndex & 0x03) | ((u16)(ulEncAlgo)<<2);
+						//ulContent |= CAM_VALID;
+					}
+					else
+					{
+						ulContent = 0;
+					}
+					// polling bit, and No Write enable, and address
+					ulCommand= CAM_CONTENT_COUNT*ucIndex+i;
+					ulCommand= ulCommand | CAM_POLLINIG|CAM_WRITE;
+					// write content 0 is equall to mark invalid
+					rtw_write32(Adapter, WCAMI, ulContent);  //delay_ms(40);
+					//RT_TRACE(COMP_SEC, DBG_LOUD, ("CAM_empty_entry(): WRITE A4: %lx \n",ulContent));
+					rtw_write32(Adapter, RWCAM, ulCommand);  //delay_ms(40);
+					//RT_TRACE(COMP_SEC, DBG_LOUD, ("CAM_empty_entry(): WRITE A0: %lx \n",ulCommand));
+				}
+			}
+			break;
+		case HW_VAR_CAM_INVALID_ALL:
+			rtw_write32(Adapter, RWCAM, BIT(31)|BIT(30));
+			break;
+		case HW_VAR_CAM_WRITE:
+			{
+				u32	cmd;
+				u32	*cam_val = (u32 *)val;
+				rtw_write32(Adapter, WCAMI, cam_val[0]);
+				
+				cmd = CAM_POLLINIG | CAM_WRITE | cam_val[1];
+				rtw_write32(Adapter, RWCAM, cmd);
+			}
+			break;
+		case HW_VAR_AC_PARAM_VO:
+			rtw_write32(Adapter, REG_EDCA_VO_PARAM, ((u32 *)(val))[0]);
+			break;
+		case HW_VAR_AC_PARAM_VI:
+			rtw_write32(Adapter, REG_EDCA_VI_PARAM, ((u32 *)(val))[0]);
+			break;
+		case HW_VAR_AC_PARAM_BE:
+			pHalData->AcParam_BE = ((u32 *)(val))[0];
+			rtw_write32(Adapter, REG_EDCA_BE_PARAM, ((u32 *)(val))[0]);
+			break;
+		case HW_VAR_AC_PARAM_BK:
+			rtw_write32(Adapter, REG_EDCA_BK_PARAM, ((u32 *)(val))[0]);
+			break;
+		case HW_VAR_ACM_CTRL:
+			{
+				u8	acm_ctrl = *((u8 *)val);
+				u8	AcmCtrl = rtw_read8( Adapter, REG_ACMHWCTRL);
+
+				if(acm_ctrl > 1)
+					AcmCtrl = AcmCtrl | 0x1;
+
+				if(acm_ctrl & BIT(3))
+					AcmCtrl |= AcmHw_VoqEn;
+				else
+					AcmCtrl &= (~AcmHw_VoqEn);
+
+				if(acm_ctrl & BIT(2))
+					AcmCtrl |= AcmHw_ViqEn;
+				else
+					AcmCtrl &= (~AcmHw_ViqEn);
+
+				if(acm_ctrl & BIT(1))
+					AcmCtrl |= AcmHw_BeqEn;
+				else
+					AcmCtrl &= (~AcmHw_BeqEn);
+
+				DBG_871X("[HW_VAR_ACM_CTRL] Write 0x%X\n", AcmCtrl );
+				rtw_write8(Adapter, REG_ACMHWCTRL, AcmCtrl );
+			}
+			break;
+		case HW_VAR_AMPDU_MIN_SPACE:
+			{
+				u8	MinSpacingToSet;
+				u8	SecMinSpace;
+
+				MinSpacingToSet = *((u8 *)val);
+				if(MinSpacingToSet <= 7)
+				{
+					switch(Adapter->securitypriv.dot11PrivacyAlgrthm)
+					{
+						case _NO_PRIVACY_:
+						case _AES_:
+							SecMinSpace = 0;
+							break;
+
+						case _WEP40_:
+						case _WEP104_:
+						case _TKIP_:
+						case _TKIP_WTMIC_:
+							SecMinSpace = 6;
+							break;
+						default:
+							SecMinSpace = 7;
+							break;
+					}
+
+					if(MinSpacingToSet < SecMinSpace){
+						MinSpacingToSet = SecMinSpace;
+					}
+
+					//RT_TRACE(COMP_MLME, DBG_LOUD, ("Set HW_VAR_AMPDU_MIN_SPACE: %#x\n", Adapter->MgntInfo.MinSpaceCfg));
+					rtw_write8(Adapter, REG_AMPDU_MIN_SPACE, (rtw_read8(Adapter, REG_AMPDU_MIN_SPACE) & 0xf8) | MinSpacingToSet);
+				}
+			}
+			break;
+		case HW_VAR_AMPDU_FACTOR:
+			{
+				u8	RegToSet_Normal[4]={0x41,0xa8,0x72, 0xb9};
+				u8	RegToSet_BT[4]={0x31,0x74,0x42, 0x97};
+				u8	FactorToSet;
+				u8	*pRegToSet;
+				u8	index = 0;
+
+#ifdef CONFIG_BT_COEXIST
+				if(	(pHalData->bt_coexist.BT_Coexist) &&
+					(pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4) )
+					pRegToSet = RegToSet_BT; // 0x97427431;
+				else
+#endif
+					pRegToSet = RegToSet_Normal; // 0xb972a841;
+
+				FactorToSet = *((u8 *)val);
+				if(FactorToSet <= 3)
+				{
+					FactorToSet = (1<<(FactorToSet + 2));
+					if(FactorToSet>0xf)
+						FactorToSet = 0xf;
+
+					for(index=0; index<4; index++)
+					{
+						if((pRegToSet[index] & 0xf0) > (FactorToSet<<4))
+							pRegToSet[index] = (pRegToSet[index] & 0x0f) | (FactorToSet<<4);
+					
+						if((pRegToSet[index] & 0x0f) > FactorToSet)
+							pRegToSet[index] = (pRegToSet[index] & 0xf0) | (FactorToSet);
+						
+						rtw_write8(Adapter, (REG_AGGLEN_LMT+index), pRegToSet[index]);
+					}
+
+					//RT_TRACE(COMP_MLME, DBG_LOUD, ("Set HW_VAR_AMPDU_FACTOR: %#x\n", FactorToSet));
+				}
+			}
+			break;
+		case HW_VAR_RXDMA_AGG_PG_TH:
+			#ifdef CONFIG_USB_RX_AGGREGATION
+			{
+				u8	threshold = *((u8 *)val);
+				if( threshold == 0)
+				{
+					threshold = pHalData->UsbRxAggPageCount;
+				}
+				rtw_write8(Adapter, REG_RXDMA_AGG_PG_TH, threshold);
+			}
+			#endif
+			break;
+		case HW_VAR_SET_RPWM:
+#ifdef CONFIG_LPS_LCLK
+			{
+				u8	ps_state = *((u8 *)val);
+				//rpwm value only use BIT0(clock bit) ,BIT6(Ack bit), and BIT7(Toggle bit) for 88e.
+				//BIT0 value - 1: 32k, 0:40MHz.
+				//BIT6 value - 1: report cpwm value after success set, 0:do not report.
+				//BIT7 value - Toggle bit change.
+				//modify by Thomas. 2012/4/2.
+				ps_state = ps_state & 0xC1;
+				//DBG_871X("##### Change RPWM value to = %x for switch clk #####\n",ps_state);
+				rtw_write8(Adapter, REG_USB_HRPWM, ps_state);
+			}
+#endif
+			break;
+		case HW_VAR_H2C_FW_PWRMODE:
+			{
+				u8	psmode = (*(u8 *)val);
+			
+				// Forece leave RF low power mode for 1T1R to prevent conficting setting in Fw power
+				// saving sequence. 2010.06.07. Added by tynli. Suggested by SD3 yschang.
+				if( (psmode != PS_MODE_ACTIVE) && (!IS_92C_SERIAL(pHalData->VersionID)))
+				{
+					ODM_RF_Saving(podmpriv, _TRUE);
+				}
+				rtl8188e_set_FwPwrMode_cmd(Adapter, psmode);
+			}
+			break;
+		case HW_VAR_H2C_FW_JOINBSSRPT:
+		    {
+				u8	mstatus = (*(u8 *)val);
+				rtl8188e_set_FwJoinBssReport_cmd(Adapter, mstatus);
+			}
+			break;
+#ifdef CONFIG_P2P_PS
+		case HW_VAR_H2C_FW_P2P_PS_OFFLOAD:
+			{
+				u8	p2p_ps_state = (*(u8 *)val);
+				rtl8188e_set_p2p_ps_offload_cmd(Adapter, p2p_ps_state);
+			}
+			break;
+#endif //CONFIG_P2P_PS
+#ifdef CONFIG_TDLS
+		case HW_VAR_TDLS_WRCR:
+			rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)&(~RCR_CBSSID_DATA ));
+			break;
+		case HW_VAR_TDLS_INIT_CH_SEN:
+			{
+				rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)&(~ RCR_CBSSID_DATA )&(~RCR_CBSSID_BCN ));
+				rtw_write16(Adapter, REG_RXFLTMAP2,0xffff);
+
+				//disable update TSF
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)|BIT(4));
+			}
+			break;
+		case HW_VAR_TDLS_DONE_CH_SEN:
+			{
+				//enable update TSF
+				rtw_write8(Adapter, REG_BCN_CTRL, rtw_read8(Adapter, REG_BCN_CTRL)&(~ BIT(4)));
+				rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|(RCR_CBSSID_BCN ));
+			}
+			break;
+		case HW_VAR_TDLS_RS_RCR:
+			rtw_write32(Adapter, REG_RCR, rtw_read32(Adapter, REG_RCR)|(RCR_CBSSID_DATA));
+			break;
+#endif //CONFIG_TDLS
+		case HW_VAR_INITIAL_GAIN:
+			{				
+				DIG_T	*pDigTable = &podmpriv->DM_DigTable;					
+				u32 		rx_gain = ((u32 *)(val))[0];
+		
+				if(rx_gain == 0xff){//restore rx gain					
+					ODM_Write_DIG(podmpriv,pDigTable->BackupIGValue);
+				}
+				else{
+					pDigTable->BackupIGValue = pDigTable->CurIGValue;
+					ODM_Write_DIG(podmpriv,rx_gain);
+				}
+			}
+			break;
+		case HW_VAR_TRIGGER_GPIO_0:
+			rtl8192cu_trigger_gpio_0(Adapter);
+			break;
+#ifdef CONFIG_BT_COEXIST
+		case HW_VAR_BT_SET_COEXIST:
+			{
+				u8	bStart = (*(u8 *)val);
+				rtl8192c_set_dm_bt_coexist(Adapter, bStart);
+			}
+			break;
+		case HW_VAR_BT_ISSUE_DELBA:
+			{
+				u8	dir = (*(u8 *)val);
+				rtl8192c_issue_delete_ba(Adapter, dir);
+			}
+			break;
+#endif
+#if (RATE_ADAPTIVE_SUPPORT==1)
+		case HW_VAR_RPT_TIMER_SETTING:
+			{
+				u16	min_rpt_time = (*(u16 *)val);
+				ODM_RA_Set_TxRPT_Time(podmpriv,min_rpt_time);	
+			}
+			break;
+#endif
+#ifdef CONFIG_SW_ANTENNA_DIVERSITY
+
+		case HW_VAR_ANTENNA_DIVERSITY_LINK:
+			//odm_SwAntDivRestAfterLink8192C(Adapter);
+			ODM_SwAntDivRestAfterLink(podmpriv);
+			break;
+#endif			
+#ifdef CONFIG_ANTENNA_DIVERSITY
+		case HW_VAR_ANTENNA_DIVERSITY_SELECT:
+			{
+				u8	Optimum_antenna = (*(u8 *)val);
+				u8 	Ant ; 
+				//switch antenna to Optimum_antenna
+				//DBG_8192C("==> HW_VAR_ANTENNA_DIVERSITY_SELECT , Ant_(%s)\n",(Optimum_antenna==2)?"A":"B");
+				if(pHalData->CurAntenna !=  Optimum_antenna)		
+				{					
+					Ant = (Optimum_antenna==2)?MAIN_ANT:AUX_ANT;
+					ODM_UpdateRxIdleAnt(&pHalData->odmpriv, Ant);
+					
+					pHalData->CurAntenna = Optimum_antenna ;
+					//DBG_8192C("==> HW_VAR_ANTENNA_DIVERSITY_SELECT , Ant_(%s)\n",(Optimum_antenna==2)?"A":"B");
+				}
+			}
+			break;
+#endif
+		case HW_VAR_EFUSE_BYTES: // To set EFUE total used bytes, added by Roger, 2008.12.22.
+			pHalData->EfuseUsedBytes = *((u16 *)val);			
+			break;
+		case HW_VAR_FIFO_CLEARN_UP:
+			{				
+				struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(Adapter);
+				u8 trycnt = 100;	
+				
+				//pause tx
+				rtw_write8(Adapter,REG_TXPAUSE,0xff);
+			
+				//keep sn
+				Adapter->xmitpriv.nqos_ssn = rtw_read16(Adapter,REG_NQOS_SEQ);
+
+				if(pwrpriv->bkeepfwalive != _TRUE)
+				{
+					//RX DMA stop
+					rtw_write32(Adapter,REG_RXPKT_NUM,(rtw_read32(Adapter,REG_RXPKT_NUM)|RW_RELEASE_EN));
+					do{
+						if(!(rtw_read32(Adapter,REG_RXPKT_NUM)&RXDMA_IDLE))
+							break;
+					}while(trycnt--);
+					if(trycnt ==0)
+						DBG_8192C("Stop RX DMA failed...... \n");
+
+					//RQPN Load 0
+					rtw_write16(Adapter,REG_RQPN_NPQ,0x0);
+					rtw_write32(Adapter,REG_RQPN,0x80000000);
+					rtw_mdelay_os(10);
+				}
+			}
+			break;
+	case HW_VAR_APFM_ON_MAC:
+			pHalData->bMacPwrCtrlOn = *val;
+			DBG_871X("%s: bMacPwrCtrlOn=%d\n", __func__, pHalData->bMacPwrCtrlOn);
+			break;
+
+#ifdef CONFIG_WOWLAN
+		case HW_VAR_WOWLAN:
+		{
+			struct wowlan_ioctl_param *poidparam;
+			struct recv_buf *precvbuf;
+			struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(Adapter);
+			struct security_priv *psecuritypriv = &Adapter->securitypriv;
+			int res, i;
+			u32 tmp;
+			u64 iv_low = 0, iv_high = 0;
+			u16 len = 0;
+			u8 mstatus = (*(u8 *)val);
+			u8 trycnt = 100;
+			u8 data[4], val8;
+
+			poidparam = (struct wowlan_ioctl_param *)val;
+			switch (poidparam->subcode){
+				case WOWLAN_ENABLE:
+					DBG_871X_LEVEL(_drv_always_, "WOWLAN_ENABLE\n");
+
+					#ifndef DYNAMIC_CAMID_ALLOC
+					val8 = (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)? 0xcc: 0xcf;
+					rtw_write8(Adapter, REG_SECCFG, val8);
+					DBG_871X_LEVEL(_drv_always_, "REG_SECCFG: %02x\n", rtw_read8(Adapter, REG_SECCFG));
+					#endif
+
+					SetFwRelatedForWoWLAN8188ES(Adapter, _TRUE);
+
+					rtl8188e_set_FwJoinBssReport_cmd(Adapter, 1);
+					rtw_msleep_os(2);
+
+					//Set Pattern
+					//if(pwrctl->wowlan_pattern==_TRUE)
+					//	rtw_wowlan_reload_pattern(Adapter);
+
+					//RX DMA stop
+					DBG_871X_LEVEL(_drv_always_, "Pause DMA\n");
+					rtw_write32(Adapter,REG_RXPKT_NUM,(rtw_read32(Adapter,REG_RXPKT_NUM)|RW_RELEASE_EN));
+					do{
+						if((rtw_read32(Adapter, REG_RXPKT_NUM)&RXDMA_IDLE)) {
+							DBG_871X_LEVEL(_drv_always_, "RX_DMA_IDLE is true\n");
+							if (Adapter->intf_stop)
+								Adapter->intf_stop(Adapter);
+							break;
+						} else {
+							// If RX_DMA is not idle, receive one pkt from DMA
+							DBG_871X_LEVEL(_drv_always_, "RX_DMA_IDLE is not true\n");
+						}
+					}while(trycnt--);
+
+					if(trycnt ==0)
+						DBG_871X_LEVEL(_drv_always_, "Stop RX DMA failed...... \n");
+
+					//Set WOWLAN H2C command.
+					DBG_871X_LEVEL(_drv_always_, "Set WOWLan cmd\n");
+					rtl8188es_set_wowlan_cmd(Adapter, 1);
+
+					mstatus = rtw_read8(Adapter, REG_WOW_CTRL);
+					trycnt = 10;
+
+					while(!(mstatus&BIT1) && trycnt>1) {
+						mstatus = rtw_read8(Adapter, REG_WOW_CTRL);
+						DBG_871X_LEVEL(_drv_always_, "Loop index: %d :0x%02x\n", trycnt, mstatus);
+						trycnt --;
+						rtw_msleep_os(2);
+					}
+
+					pwrctl->wowlan_wake_reason = rtw_read8(Adapter, REG_WOWLAN_WAKE_REASON);
+					DBG_871X_LEVEL(_drv_always_, "wowlan_wake_reason: 0x%02x\n",
+										pwrctl->wowlan_wake_reason);
+
+					/* Invoid SE0 reset signal during suspending*/
+					rtw_write8(Adapter, REG_RSV_CTRL, 0x20);
+					rtw_write8(Adapter, REG_RSV_CTRL, 0x60);
+
+					//rtw_msleep_os(10);
+					break;
+				case WOWLAN_DISABLE:
+					trycnt = 10;
+
+					DBG_871X_LEVEL(_drv_always_, "WOWLAN_DISABLE\n");
+
+					rtl8188e_set_FwJoinBssReport_cmd(Adapter, 0);
+
+					#ifndef DYNAMIC_CAMID_ALLOC
+					rtw_write8(Adapter, REG_SECCFG, 0x0c|BIT(5));// enable tx enc and rx dec engine, and no key search for MC/BC
+					DBG_871X_LEVEL(_drv_always_, "REG_SECCFG: %02x\n", rtw_read8(Adapter, REG_SECCFG));
+					#endif
+
+					pwrctl->wowlan_wake_reason =
+						rtw_read8(Adapter, REG_WOWLAN_WAKE_REASON);
+					DBG_871X_LEVEL(_drv_always_,
+							"wakeup_reason: 0x%02x\n", pwrctl->wowlan_wake_reason);
+
+					rtl8188es_set_wowlan_cmd(Adapter, 0);
+					mstatus = rtw_read8(Adapter, REG_WOW_CTRL);
+					DBG_871X_LEVEL(_drv_info_, "%s mstatus:0x%02x\n", __func__, mstatus);
+
+					while(mstatus&BIT1 && trycnt>1) {
+						mstatus = rtw_read8(Adapter, REG_WOW_CTRL);
+						DBG_871X_LEVEL(_drv_always_, "Loop index: %d :0x%02x\n", trycnt, mstatus);
+						trycnt --;
+						rtw_msleep_os(2);
+					}
+
+					if (mstatus & BIT1) {
+						DBG_871X_LEVEL(_drv_always_, "Disable WOW mode fail!!\n");
+						DBG_871X("Set 0x690=0x00\n");
+						rtw_write8(Adapter, REG_WOW_CTRL, (rtw_read8(Adapter, REG_WOW_CTRL)&0xf0));
+						DBG_871X_LEVEL(_drv_always_, "Release RXDMA\n");
+						rtw_write32(Adapter, REG_RXPKT_NUM,(rtw_read32(Adapter,REG_RXPKT_NUM)&(~RW_RELEASE_EN)));
+					}
+
+					// 3.1 read fw iv
+					iv_low = rtw_read32(Adapter, REG_TXPKTBUF_IV_LOW);
+					//only low two bytes is PN, check AES_IV macro for detail
+					iv_low &= 0xffff;
+					iv_high = rtw_read32(Adapter, REG_TXPKTBUF_IV_HIGH);
+					//get the real packet number
+					pwrctl->wowlan_fw_iv = iv_high << 16 | iv_low;
+					DBG_871X_LEVEL(_drv_always_, "fw_iv: 0x%016llx\n", pwrctl->wowlan_fw_iv);
+					//Update TX iv data.
+					rtw_set_sec_pn(Adapter);
+
+					SetFwRelatedForWoWLAN8188ES(Adapter, _FALSE);
+
+					if((pwrctl->wowlan_wake_reason != FWDecisionDisconnect) &&
+						(pwrctl->wowlan_wake_reason != Rx_Pairwisekey) &&
+						(pwrctl->wowlan_wake_reason != Rx_DisAssoc) &&
+						(pwrctl->wowlan_wake_reason != Rx_DeAuth))
+						rtl8188e_set_FwJoinBssReport_cmd(Adapter, 1);
+
+					rtw_msleep_os(5);
+					break;
+				default:
+					break;
+			}
+		}
+		break;
+#endif //CONFIG_WOWLAN
+
+
+	#if (RATE_ADAPTIVE_SUPPORT == 1)
+		case HW_VAR_TX_RPT_MAX_MACID:
+			{
+				u8 maxMacid = *val;
+				DBG_871X("### MacID(%d),Set Max Tx RPT MID(%d)\n",maxMacid,maxMacid+1);
+				rtw_write8(Adapter, REG_TX_RPT_CTRL+1, maxMacid+1);
+			}
+			break;
+	#endif		
+		case HW_VAR_H2C_MEDIA_STATUS_RPT:
+			{				
+				rtl8188e_set_FwMediaStatus_cmd(Adapter , (*(u16 *)val));
+			}
+			break;
+		case HW_VAR_BCN_VALID:
+			//BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2, write 1 to clear, Clear by sw
+			rtw_write8(Adapter, REG_TDECTRL+2, rtw_read8(Adapter, REG_TDECTRL+2) | BIT0); 
+			break;
+
+		default:
+			SetHwReg8188E(Adapter, variable, val);
+			break;
+	}
+
+_func_exit_;
+}
+
+void GetHwReg8188EU(PADAPTER Adapter, u8 variable, u8* val)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	DM_ODM_T 		*podmpriv = &pHalData->odmpriv;
+_func_enter_;
+
+	switch(variable)
+	{
+		case HW_VAR_TXPAUSE:
+			val[0] = rtw_read8(Adapter, REG_TXPAUSE);
+			break;
+		case HW_VAR_BCN_VALID:
+			//BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2
+			val[0] = (BIT0 & rtw_read8(Adapter, REG_TDECTRL+2))?_TRUE:_FALSE;
+			break;
+		case HW_VAR_FWLPS_RF_ON:
+			{
+				//When we halt NIC, we should check if FW LPS is leave.
+				if(adapter_to_pwrctl(Adapter)->rf_pwrstate == rf_off)
+				{
+					// If it is in HW/SW Radio OFF or IPS state, we do not check Fw LPS Leave,
+					// because Fw is unload.
+					val[0] = _TRUE;
+				}
+				else
+				{
+					u32 valRCR;
+					valRCR = rtw_read32(Adapter, REG_RCR);
+					valRCR &= 0x00070000;
+					if(valRCR)
+						val[0] = _FALSE;
+					else
+						val[0] = _TRUE;
+				}
+			}
+			break;
+#ifdef CONFIG_ANTENNA_DIVERSITY
+		case HW_VAR_CURRENT_ANTENNA:
+			val[0] = pHalData->CurAntenna;
+			break;
+#endif
+		case HW_VAR_EFUSE_BYTES: // To get EFUE total used bytes, added by Roger, 2008.12.22.
+			*((u16 *)(val)) = pHalData->EfuseUsedBytes;	
+			break;
+		case HW_VAR_APFM_ON_MAC:
+			*val = pHalData->bMacPwrCtrlOn;
+			break;
+		case HW_VAR_CHK_HI_QUEUE_EMPTY:
+			*val = ((rtw_read32(Adapter, REG_HGQ_INFO)&0x0000ff00)==0) ? _TRUE:_FALSE;
+			break;
+		default:
+			GetHwReg8188E(Adapter, variable, val);
+			break;
+	}
+
+_func_exit_;
+}
+
+//
+//	Description: 
+//		Query setting of specified variable.
+//
+u8
+GetHalDefVar8188EUsb(
+	IN	PADAPTER				Adapter,
+	IN	HAL_DEF_VARIABLE		eVariable,
+	IN	PVOID					pValue
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	u8			bResult = _SUCCESS;
+
+	switch(eVariable)
+	{
+		case HAL_DEF_UNDERCORATEDSMOOTHEDPWDB:
+#if 1 //trunk
+			{
+				struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
+				struct sta_priv * pstapriv = &Adapter->stapriv;
+				struct sta_info * psta;
+				psta = rtw_get_stainfo(pstapriv, pmlmepriv->cur_network.network.MacAddress);
+				if(psta)
+				{
+					*((int *)pValue) = psta->rssi_stat.UndecoratedSmoothedPWDB;     
+				}
+			}
+#else //V4 branch
+				if(check_fwstate(&Adapter->mlmepriv, WIFI_STATION_STATE) == _TRUE){
+						*((int *)pValue) = pHalData->dmpriv.UndecoratedSmoothedPWDB;
+				}
+				else{
+    
+				}
+#endif
+			break;
+		case HAL_DEF_IS_SUPPORT_ANT_DIV:
+#ifdef CONFIG_ANTENNA_DIVERSITY
+			*((u8 *)pValue) = (pHalData->AntDivCfg==0)?_FALSE:_TRUE;
+#endif
+			break;			
+		case HAL_DEF_CURRENT_ANTENNA:
+#ifdef CONFIG_ANTENNA_DIVERSITY
+			*(( u8*)pValue) = pHalData->CurAntenna;			
+#endif
+			break;
+		case HAL_DEF_DRVINFO_SZ:
+			*(( u32*)pValue) = DRVINFO_SZ;
+			break;
+		case HAL_DEF_MAX_RECVBUF_SZ:
+			*(( u32*)pValue) = MAX_RECVBUF_SZ;
+			break;
+		case HAL_DEF_RX_PACKET_OFFSET:
+			*(( u32*)pValue) = RXDESC_SIZE + DRVINFO_SZ;
+			break;
+#if (RATE_ADAPTIVE_SUPPORT == 1)
+		case HAL_DEF_RA_DECISION_RATE:
+			{
+				u8 MacID = *((u8*)pValue);
+				*((u8*)pValue) = ODM_RA_GetDecisionRate_8188E(&(pHalData->odmpriv), MacID);
+			}
+			break;
+
+		case HAL_DEF_RA_SGI:
+			{
+				u8 MacID = *((u8*)pValue);
+				*((u8*)pValue) = ODM_RA_GetShortGI_8188E(&(pHalData->odmpriv), MacID);
+			}
+			break;		
+#endif
+
+ 
+		case HAL_DEF_PT_PWR_STATUS:
+#if(POWER_TRAINING_ACTIVE==1)
+			{
+				u8 MacID = *((u8*)pValue);
+				*((u8*)pValue) = ODM_RA_GetHwPwrStatus_8188E(&(pHalData->odmpriv), MacID);
+			}
+#endif//(POWER_TRAINING_ACTIVE==1)
+			break;		
+
+		case HW_VAR_MAX_RX_AMPDU_FACTOR:
+			*(( u32*)pValue) = MAX_AMPDU_FACTOR_64K;
+			break;
+
+		case HAL_DEF_TX_LDPC:
+		case HAL_DEF_RX_LDPC:
+			*((u8 *)pValue) = _FALSE;
+			break;
+		case HAL_DEF_TX_STBC:
+			*((u8 *)pValue) = 0;
+			break;
+		case HAL_DEF_RX_STBC:
+			*((u8 *)pValue) = 1;
+			break;
+		case HAL_DEF_EXPLICIT_BEAMFORMEE:
+		case HAL_DEF_EXPLICIT_BEAMFORMER:
+			*((u8 *)pValue) = _FALSE;
+			break;
+
+                case HW_DEF_RA_INFO_DUMP:
+#if (RATE_ADAPTIVE_SUPPORT == 1)	
+			{
+				u8 mac_id = *((u8*)pValue);				
+				u8 			bLinked = _FALSE;
+#ifdef CONFIG_CONCURRENT_MODE
+				PADAPTER pbuddy_adapter = Adapter->pbuddy_adapter;
+#endif //CONFIG_CONCURRENT_MODE
+
+				if(rtw_linked_check(Adapter))
+					bLinked = _TRUE;
+		
+#ifdef CONFIG_CONCURRENT_MODE
+				if(pbuddy_adapter && rtw_linked_check(pbuddy_adapter))
+					bLinked = _TRUE;
+#endif			
+				
+				if(bLinked){					
+					DBG_871X("============ RA status - Mac_id:%d ===================\n",mac_id);
+									
+					DBG_8192C("Mac_id:%d ,RSSI:%d(%%),PTStage = %d\n",
+						mac_id,pHalData->odmpriv.RAInfo[mac_id].RssiStaRA,pHalData->odmpriv.RAInfo[mac_id].PTStage);							
+
+					DBG_8192C("RateID = %d,RAUseRate = 0x%08x,RateSGI = %d, DecisionRate = %s\n",
+						pHalData->odmpriv.RAInfo[mac_id].RateID,
+						pHalData->odmpriv.RAInfo[mac_id].RAUseRate,
+						pHalData->odmpriv.RAInfo[mac_id].RateSGI,
+						HDATA_RATE(pHalData->odmpriv.RAInfo[mac_id].DecisionRate));	
+					
+				}
+			}
+#endif	//(RATE_ADAPTIVE_SUPPORT == 1)
+			break;
+		default:
+			bResult = GetHalDefVar8188E(Adapter, eVariable, pValue);
+			break;
+	}
+
+	return bResult;
+}
+
+
+
+
+//
+//	Description:
+//		Change default setting of specified variable.
+//
+u8
+SetHalDefVar8188EUsb(
+	IN	PADAPTER				Adapter,
+	IN	HAL_DEF_VARIABLE		eVariable,
+	IN	PVOID					pValue
+	)
+{
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(Adapter);
+	u8			bResult = _SUCCESS;
+
+	switch(eVariable)
+	{
+		default:
+			bResult = SetHalDefVar(Adapter, eVariable, pValue);
+			break;
+	}
+
+	return bResult;
+}
+/*
+u32  _update_92cu_basic_rate(_adapter *padapter, unsigned int mask)
+{
+	HAL_DATA_TYPE		*pHalData = GET_HAL_DATA(padapter);
+#ifdef CONFIG_BT_COEXIST
+	struct btcoexist_priv	*pbtpriv = &(pHalData->bt_coexist);
+#endif
+	unsigned int BrateCfg = 0;
+
+#ifdef CONFIG_BT_COEXIST
+	if(	(pbtpriv->BT_Coexist) &&	(pbtpriv->BT_CoexistType == BT_CSR_BC4)	)
+	{
+		BrateCfg = mask  & 0x151;
+		//DBG_8192C("BT temp disable cck 2/5.5/11M, (0x%x = 0x%x)\n", REG_RRSR, BrateCfg & 0x151);
+	}
+	else
+#endif
+	{
+		//if(pHalData->VersionID != VERSION_TEST_CHIP_88C)
+			BrateCfg = mask  & 0x15F;
+		//else	//for 88CU 46PING setting, Disable CCK 2M, 5.5M, Others must tuning
+		//	BrateCfg = mask  & 0x159;
+	}
+
+	BrateCfg |= 0x01; // default enable 1M ACK rate					
+
+	return BrateCfg;
+}
+*/
+void _update_response_rate(_adapter *padapter,unsigned int mask)
+{
+	u8	RateIndex = 0;
+	// Set RRSR rate table.
+	rtw_write8(padapter, REG_RRSR, mask&0xff);
+	rtw_write8(padapter,REG_RRSR+1, (mask>>8)&0xff);
+
+	// Set RTS initial rate
+	while(mask > 0x1)
+	{
+		mask = (mask>> 1);
+		RateIndex++;
+	}
+	rtw_write8(padapter, REG_INIRTS_RATE_SEL, RateIndex);
+}
+
+void SetBeaconRelatedRegisters8188EUsb(PADAPTER padapter)
+{
+	u32	value32;
+	//HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	struct mlme_ext_priv	*pmlmeext = &(padapter->mlmeextpriv);
+	struct mlme_ext_info	*pmlmeinfo = &(pmlmeext->mlmext_info);
+	u32 bcn_ctrl_reg 			= REG_BCN_CTRL;
+	//reset TSF, enable update TSF, correcting TSF On Beacon 
+	
+	//REG_BCN_INTERVAL
+	//REG_BCNDMATIM
+	//REG_ATIMWND
+	//REG_TBTT_PROHIBIT
+	//REG_DRVERLYINT
+	//REG_BCN_MAX_ERR	
+	//REG_BCNTCFG //(0x510)
+	//REG_DUAL_TSF_RST
+	//REG_BCN_CTRL //(0x550) 
+
+	//BCN interval
+#ifdef CONFIG_CONCURRENT_MODE
+        	if (padapter->iface_type == IFACE_PORT1){
+		bcn_ctrl_reg = REG_BCN_CTRL_1;
+        	}
+#endif	
+	rtw_write16(padapter, REG_BCN_INTERVAL, pmlmeinfo->bcn_interval);
+	rtw_write8(padapter, REG_ATIMWND, 0x02);// 2ms
+
+	_InitBeaconParameters(padapter);
+
+	rtw_write8(padapter, REG_SLOT, 0x09);
+
+	value32 =rtw_read32(padapter, REG_TCR); 
+	value32 &= ~TSFRST;
+	rtw_write32(padapter,  REG_TCR, value32); 
+
+	value32 |= TSFRST;
+	rtw_write32(padapter, REG_TCR, value32); 
+
+	// NOTE: Fix test chip's bug (about contention windows's randomness)
+	rtw_write8(padapter,  REG_RXTSF_OFFSET_CCK, 0x50);
+	rtw_write8(padapter, REG_RXTSF_OFFSET_OFDM, 0x50);
+
+	_BeaconFunctionEnable(padapter, _TRUE, _TRUE);
+
+	ResumeTxBeacon(padapter);
+
+	//rtw_write8(padapter, 0x422, rtw_read8(padapter, 0x422)|BIT(6));
+	
+	//rtw_write8(padapter, 0x541, 0xff);
+
+	//rtw_write8(padapter, 0x542, rtw_read8(padapter, 0x541)|BIT(0));
+
+	rtw_write8(padapter, bcn_ctrl_reg, rtw_read8(padapter, bcn_ctrl_reg)|BIT(1));
+
+}
+
+static void rtl8188eu_init_default_value(_adapter * padapter)
+{
+	PHAL_DATA_TYPE pHalData;
+	struct pwrctrl_priv *pwrctrlpriv;
+	struct dm_priv *pdmpriv;
+	u8 i;
+
+	pHalData = GET_HAL_DATA(padapter);
+	pwrctrlpriv = adapter_to_pwrctl(padapter);
+	pdmpriv = &pHalData->dmpriv;
+	
+	padapter->registrypriv.wireless_mode = WIRELESS_11BG_24N;
+	//init default value
+	pHalData->fw_ractrl = _FALSE;		
+	if(!pwrctrlpriv->bkeepfwalive)
+		pHalData->LastHMEBoxNum = 0;	
+
+	//init dm default value
+	pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized = _FALSE;
+	pHalData->odmpriv.RFCalibrateInfo.TM_Trigger = 0;//for IQK
+	//pdmpriv->binitialized = _FALSE;
+//	pdmpriv->prv_traffic_idx = 3;
+//	pdmpriv->initialize = 0;
+	pHalData->pwrGroupCnt = 0;
+	pHalData->PGMaxGroup= 13;
+	pHalData->odmpriv.RFCalibrateInfo.ThermalValue_HP_index = 0;
+	for(i = 0; i < HP_THERMAL_NUM; i++)
+		pHalData->odmpriv.RFCalibrateInfo.ThermalValue_HP[i] = 0;
+
+	pHalData->EfuseHal.fakeEfuseBank = 0;
+	pHalData->EfuseHal.fakeEfuseUsedBytes = 0;
+	_rtw_memset(pHalData->EfuseHal.fakeEfuseContent, 0xFF, EFUSE_MAX_HW_SIZE);
+	_rtw_memset(pHalData->EfuseHal.fakeEfuseInitMap, 0xFF, EFUSE_MAX_MAP_LEN);
+	_rtw_memset(pHalData->EfuseHal.fakeEfuseModifiedMap, 0xFF, EFUSE_MAX_MAP_LEN);
+}
+
+static u8 rtl8188eu_ps_func(PADAPTER Adapter,HAL_INTF_PS_FUNC efunc_id, u8 *val)
+{	
+	u8 bResult = _TRUE;
+	switch(efunc_id){
+
+		#if defined(CONFIG_AUTOSUSPEND) && defined(SUPPORT_HW_RFOFF_DETECTED)
+		case HAL_USB_SELECT_SUSPEND:
+			{
+				u8 bfwpoll = *(( u8*)val);
+				//rtl8188e_set_FwSelectSuspend_cmd(Adapter,bfwpoll ,500);//note fw to support hw power down ping detect
+			}
+			break;
+		#endif //CONFIG_AUTOSUSPEND && SUPPORT_HW_RFOFF_DETECTED
+
+		default:
+			break;
+	}
+	return bResult;
+}
+
+void rtl8188eu_set_hal_ops(_adapter * padapter)
+{
+	struct hal_ops	*pHalFunc = &padapter->HalFunc;
+
+_func_enter_;
+
+#ifdef CONFIG_CONCURRENT_MODE
+	if(padapter->isprimary)
+#endif //CONFIG_CONCURRENT_MODE
+	{
+		padapter->HalData = rtw_zvmalloc(sizeof(HAL_DATA_TYPE));
+		if(padapter->HalData == NULL){
+			DBG_8192C("cant not alloc memory for HAL DATA \n");
+		}
+	}
+
+	//_rtw_memset(padapter->HalData, 0, sizeof(HAL_DATA_TYPE));
+	padapter->hal_data_sz = sizeof(HAL_DATA_TYPE);
+
+	pHalFunc->hal_power_on = _InitPowerOn_8188EU;
+	pHalFunc->hal_power_off = hal_poweroff_8188eu;
+	
+	pHalFunc->hal_init = &rtl8188eu_hal_init;
+	pHalFunc->hal_deinit = &rtl8188eu_hal_deinit;
+
+	//pHalFunc->free_hal_data = &rtl8192c_free_hal_data;
+
+	pHalFunc->inirp_init = &rtl8188eu_inirp_init;
+	pHalFunc->inirp_deinit = &rtl8188eu_inirp_deinit;
+
+	pHalFunc->init_xmit_priv = &rtl8188eu_init_xmit_priv;
+	pHalFunc->free_xmit_priv = &rtl8188eu_free_xmit_priv;
+
+	pHalFunc->init_recv_priv = &rtl8188eu_init_recv_priv;
+	pHalFunc->free_recv_priv = &rtl8188eu_free_recv_priv;
+#ifdef CONFIG_SW_LED
+	pHalFunc->InitSwLeds = &rtl8188eu_InitSwLeds;
+	pHalFunc->DeInitSwLeds = &rtl8188eu_DeInitSwLeds;
+#else //case of hw led or no led
+	pHalFunc->InitSwLeds = NULL;
+	pHalFunc->DeInitSwLeds = NULL;	
+#endif//CONFIG_SW_LED
+	
+	pHalFunc->init_default_value = &rtl8188eu_init_default_value;
+	pHalFunc->intf_chip_configure = &rtl8188eu_interface_configure;
+	pHalFunc->read_adapter_info = &ReadAdapterInfo8188EU;
+
+	//pHalFunc->set_bwmode_handler = &PHY_SetBWMode8192C;
+	//pHalFunc->set_channel_handler = &PHY_SwChnl8192C;
+
+	//pHalFunc->hal_dm_watchdog = &rtl8192c_HalDmWatchDog;
+
+
+	pHalFunc->SetHwRegHandler = &SetHwReg8188EU;
+	pHalFunc->GetHwRegHandler = &GetHwReg8188EU;
+  	pHalFunc->GetHalDefVarHandler = &GetHalDefVar8188EUsb;
+ 	pHalFunc->SetHalDefVarHandler = &SetHalDefVar8188EUsb;
+
+	pHalFunc->SetBeaconRelatedRegistersHandler = &SetBeaconRelatedRegisters8188EUsb;
+
+	//pHalFunc->Add_RateATid = &rtl8192c_Add_RateATid;
+
+	pHalFunc->hal_xmit = &rtl8188eu_hal_xmit;
+	pHalFunc->mgnt_xmit = &rtl8188eu_mgnt_xmit;
+	pHalFunc->hal_xmitframe_enqueue = &rtl8188eu_hal_xmitframe_enqueue;
+
+
+#ifdef CONFIG_HOSTAPD_MLME
+	pHalFunc->hostap_mgnt_xmit_entry = &rtl8188eu_hostap_mgnt_xmit_entry;
+#endif
+	pHalFunc->interface_ps_func = &rtl8188eu_ps_func;
+
+#ifdef CONFIG_XMIT_THREAD_MODE
+	pHalFunc->xmit_thread_handler = &rtl8188eu_xmit_buf_handler;
+#endif
+	rtl8188e_set_hal_ops(pHalFunc);
+_func_exit_;
+
+}
+
diff --git a/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_ops_linux.c b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_ops_linux.c
new file mode 100644
index 00000000..275dbe01
--- /dev/null
+++ b/drivers/net/wireless/rtl8188EUS_linux_v4.3.0.6_12167.20140828/hal/rtl8188e/usb/usb_ops_linux.c
@@ -0,0 +1,1273 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _HCI_OPS_OS_C_
+
+#include <drv_types.h>
+#include <rtl8188e_hal.h>
+
+static u8 usb_read8(struct intf_hdl *pintfhdl, u32 addr)
+{
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u8 data=0;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x01;//read_in
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 1;	
+	
+	usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+
+	_func_exit_;
+
+	return data;
+		
+}
+
+static u16 usb_read16(struct intf_hdl *pintfhdl, u32 addr)
+{       
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u16 data=0;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x01;//read_in
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 2;	
+	
+	usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+
+	_func_exit_;
+
+	return data;
+	
+}
+
+static u32 usb_read32(struct intf_hdl *pintfhdl, u32 addr)
+{
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u32 data=0;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x01;//read_in
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 4;	
+	
+	usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+
+	_func_exit_;
+
+	return data;
+	
+}
+
+static int usb_write8(struct intf_hdl *pintfhdl, u32 addr, u8 val)
+{
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u8 data;
+	int ret;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x00;//write_out
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 1;
+	
+	data = val;	
+	
+	 ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+	
+	_func_exit_;
+	
+	return ret;
+	
+}
+
+static int usb_write16(struct intf_hdl *pintfhdl, u32 addr, u16 val)
+{	
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u16 data;
+	int ret;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x00;//write_out
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 2;
+	
+	data = val;
+		
+	ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+	
+	_func_exit_;
+	
+	return ret;
+	
+}
+
+static int usb_write32(struct intf_hdl *pintfhdl, u32 addr, u32 val)
+{
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u32 data;
+	int ret;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x00;//write_out
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = 4;
+	data =val;		
+
+	ret =usbctrl_vendorreq(pintfhdl, request, wvalue, index, &data, len, requesttype);
+	
+	_func_exit_;
+	
+	return ret;
+	
+}
+
+static int usb_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 length, u8 *pdata)
+{
+	u8 request;
+	u8 requesttype;
+	u16 wvalue;
+	u16 index;
+	u16 len;
+	u8 buf[VENDOR_CMD_MAX_DATA_LEN]={0};
+	int ret;
+	
+	_func_enter_;
+
+	request = 0x05;
+	requesttype = 0x00;//write_out
+	index = 0;//n/a
+
+	wvalue = (u16)(addr&0x0000ffff);
+	len = length;
+	 _rtw_memcpy(buf, pdata, len );
+	
+	ret = usbctrl_vendorreq(pintfhdl, request, wvalue, index, buf, len, requesttype);
+	
+	_func_exit_;
+	
+	return ret;
+	
+}
+
+#ifdef CONFIG_SUPPORT_USB_INT
+void interrupt_handler_8188eu(_adapter *padapter,u16 pkt_len,u8 *pbuf)
+{	
+	HAL_DATA_TYPE	*pHalData=GET_HAL_DATA(padapter);
+	struct reportpwrstate_parm pwr_rpt;
+	
+	if ( pkt_len != INTERRUPT_MSG_FORMAT_LEN )
+	{
+		DBG_8192C("%s Invalid interrupt content length (%d)!\n", __FUNCTION__, pkt_len);
+		return ;
+	}
+
+	// HISR 
+	_rtw_memcpy(&(pHalData->IntArray[0]), &(pbuf[USB_INTR_CONTENT_HISR_OFFSET]), 4);
+	_rtw_memcpy(&(pHalData->IntArray[1]), &(pbuf[USB_INTR_CONTENT_HISRE_OFFSET]), 4);
+
+	#if 0 //DBG
+	{
+		u32 hisr=0 ,hisr_ex=0;
+		_rtw_memcpy(&hisr,&(pHalData->IntArray[0]),4);
+		hisr = le32_to_cpu(hisr);	
+		
+		_rtw_memcpy(&hisr_ex,&(pHalData->IntArray[1]),4);
+		hisr_ex = le32_to_cpu(hisr_ex);
+		
+		if((hisr != 0) || (hisr_ex!=0))
+			DBG_871X("===> %s hisr:0x%08x ,hisr_ex:0x%08x \n",__FUNCTION__,hisr,hisr_ex);
+	}
+	#endif
+
+
+#ifdef CONFIG_LPS_LCLK
+	if(  pHalData->IntArray[0]  & IMR_CPWM_88E )
+	{
+		_rtw_memcpy(&pwr_rpt.state, &(pbuf[USB_INTR_CONTENT_CPWM1_OFFSET]), 1);
+		//_rtw_memcpy(&pwr_rpt.state2, &(pbuf[USB_INTR_CONTENT_CPWM2_OFFSET]), 1);
+
+		//88e's cpwm value only change BIT0, so driver need to add PS_STATE_S2 for LPS flow.		
+		pwr_rpt.state |= PS_STATE_S2;		
+		_set_workitem(&(adapter_to_pwrctl(padapter)->cpwm_event));
+	}
+#endif//CONFIG_LPS_LCLK
+
+#ifdef CONFIG_INTERRUPT_BASED_TXBCN
+
+	#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+	if (pHalData->IntArray[0] & IMR_BCNDMAINT0_88E)
+	#endif
+	#ifdef  CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+	if (pHalData->IntArray[0] & (IMR_TBDER_88E|IMR_TBDOK_88E))
+	#endif	
+	{		
+		struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+		#if 0
+		if(pHalData->IntArray[0] & IMR_BCNDMAINT0_88E)
+			DBG_8192C("%s: HISR_BCNERLY_INT\n", __func__);
+		if(pHalData->IntArray[0] & IMR_TBDOK_88E)
+			DBG_8192C("%s: HISR_TXBCNOK\n", __func__);
+		if(pHalData->IntArray[0] & IMR_TBDER_88E)
+			DBG_8192C("%s: HISR_TXBCNERR\n", __func__);
+		#endif
+		
+
+		if(check_fwstate(pmlmepriv, WIFI_AP_STATE))
+		{
+			//send_beacon(padapter);
+			if(pmlmepriv->update_bcn == _TRUE)
+			{
+				//tx_beacon_hdl(padapter, NULL);
+				set_tx_beacon_cmd(padapter);
+			}
+		}
+#ifdef CONFIG_CONCURRENT_MODE
+		if(check_buddy_fwstate(padapter, WIFI_AP_STATE))
+		{
+			//send_beacon(padapter);
+			if(padapter->pbuddy_adapter->mlmepriv.update_bcn == _TRUE)
+			{
+				//tx_beacon_hdl(padapter, NULL);
+				set_tx_beacon_cmd(padapter->pbuddy_adapter);
+			}
+		}
+#endif
+		
+	}
+#endif //CONFIG_INTERRUPT_BASED_TXBCN
+
+
+
+
+#ifdef DBG_CONFIG_ERROR_DETECT_INT
+	if(  pHalData->IntArray[1]  & IMR_TXERR_88E )
+		DBG_871X("===> %s Tx Error Flag Interrupt Status \n",__FUNCTION__);
+	if(  pHalData->IntArray[1]  & IMR_RXERR_88E )
+		DBG_871X("===> %s Rx Error Flag INT Status \n",__FUNCTION__);
+	if(  pHalData->IntArray[1]  & IMR_TXFOVW_88E )
+		DBG_871X("===> %s Transmit FIFO Overflow \n",__FUNCTION__);
+	if(  pHalData->IntArray[1]  & IMR_RXFOVW_88E )
+		DBG_871X("===> %s Receive FIFO Overflow \n",__FUNCTION__);	
+#endif//DBG_CONFIG_ERROR_DETECT_INT
+
+
+	// C2H Event 
+	if(pbuf[0]!= 0){
+		_rtw_memcpy(&(pHalData->C2hArray[0]), &(pbuf[USB_INTR_CONTENT_C2H_OFFSET]), 16);		
+		//rtw_c2h_wk_cmd(padapter); to do..
+	}		
+		
+}
+#endif
+				
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+static void usb_read_interrupt_complete(struct urb *purb, struct pt_regs *regs)
+{
+	int	err;
+	_adapter		*padapter = (_adapter	 *)purb->context;
+
+	if(RTW_CANNOT_RX(padapter))
+	{
+		DBG_8192C("%s() RX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) \n", 
+		__FUNCTION__,padapter->bDriverStopped, padapter->bSurpriseRemoved);
+
+		return;
+	}
+		
+	if(purb->status==0)//SUCCESS
+	{
+		if (purb->actual_length > INTERRUPT_MSG_FORMAT_LEN)
+		{
+			DBG_8192C("usb_read_interrupt_complete: purb->actual_length > INTERRUPT_MSG_FORMAT_LEN(%d)\n",INTERRUPT_MSG_FORMAT_LEN);			
+		}
+
+		interrupt_handler_8188eu(padapter, purb->actual_length,purb->transfer_buffer );
+		
+		err = usb_submit_urb(purb, GFP_ATOMIC);
+		if((err) && (err != (-EPERM)))
+		{
+			DBG_8192C("cannot submit interrupt in-token(err = 0x%08x),urb_status = %d\n",err, purb->status);
+		}
+	}
+	else
+	{
+		DBG_8192C("###=> usb_read_interrupt_complete => urb status(%d)\n", purb->status);
+
+		switch(purb->status) {
+			case -EINVAL:
+			case -EPIPE:			
+			case -ENODEV:
+			case -ESHUTDOWN:
+				//padapter->bSurpriseRemoved=_TRUE;
+				//RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
+			case -ENOENT:
+				padapter->bDriverStopped=_TRUE;			
+				RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
+				break;
+			case -EPROTO:
+				break;
+			case -EINPROGRESS:
+				DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
+				break;
+			default:
+				break;				
+		}
+	}	
+
+}
+
+static u32 usb_read_interrupt(struct intf_hdl *pintfhdl, u32 addr)
+{
+	int	err;
+	unsigned int pipe;
+	u32	ret = _SUCCESS;
+	_adapter			*adapter = pintfhdl->padapter;
+	struct dvobj_priv	*pdvobj = adapter_to_dvobj(adapter);
+	struct recv_priv	*precvpriv = &adapter->recvpriv;
+	struct usb_device	*pusbd = pdvobj->pusbdev;
+
+_func_enter_;
+
+	if (RTW_CANNOT_RX(adapter))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_interrupt:( RTW_CANNOT_RX )!!!\n"));
+		return _FAIL;
+	}
+
+	//translate DMA FIFO addr to pipehandle
+	pipe = ffaddr2pipehdl(pdvobj, addr);
+
+	usb_fill_int_urb(precvpriv->int_in_urb, pusbd, pipe, 
+					precvpriv->int_in_buf,
+            				INTERRUPT_MSG_FORMAT_LEN,
+            				usb_read_interrupt_complete,
+            				adapter,
+            				1);
+
+	err = usb_submit_urb(precvpriv->int_in_urb, GFP_ATOMIC);
+	if((err) && (err != (-EPERM)))
+	{
+		DBG_8192C("cannot submit interrupt in-token(err = 0x%08x),urb_status = %d\n",err, precvpriv->int_in_urb->status);
+		ret = _FAIL;
+	}
+
+_func_exit_;
+
+	return ret;
+}
+#endif
+
+static s32 pre_recv_entry(union recv_frame *precvframe, struct recv_stat *prxstat, struct phy_stat *pphy_status)
+{	
+	s32 ret=_SUCCESS;
+#ifdef CONFIG_CONCURRENT_MODE	
+	u8 *primary_myid, *secondary_myid, *paddr1;
+	union recv_frame	*precvframe_if2 = NULL;
+	_adapter *primary_padapter = precvframe->u.hdr.adapter;
+	_adapter *secondary_padapter = primary_padapter->pbuddy_adapter;
+	struct recv_priv *precvpriv = &primary_padapter->recvpriv;
+	_queue *pfree_recv_queue = &precvpriv->free_recv_queue;
+	u8	*pbuf = precvframe->u.hdr.rx_data;
+	
+	if(!secondary_padapter)
+		return ret;
+	
+	paddr1 = GetAddr1Ptr(pbuf);
+
+	if(IS_MCAST(paddr1) == _FALSE)//unicast packets
+	{
+		//primary_myid = myid(&primary_padapter->eeprompriv);
+		secondary_myid = myid(&secondary_padapter->eeprompriv);
+
+		if(_rtw_memcmp(paddr1, secondary_myid, ETH_ALEN))
+		{			
+			//change to secondary interface
+			precvframe->u.hdr.adapter = secondary_padapter;
+		}	
+
+		//ret = recv_entry(precvframe);
+
+	}
+	else // Handle BC/MC Packets	
+	{
+		
+		u8 clone = _TRUE;
+#if 0		
+		u8 type, subtype, *paddr2, *paddr3;
+	
+		type =  GetFrameType(pbuf);
+		subtype = GetFrameSubType(pbuf); //bit(7)~bit(2)
+		
+		switch (type)
+		{
+			case WIFI_MGT_TYPE: //Handle BC/MC mgnt Packets
+				if(subtype == WIFI_BEACON)
+				{
+					paddr3 = GetAddr3Ptr(precvframe->u.hdr.rx_data);
+				
+					if (check_fwstate(&secondary_padapter->mlmepriv, _FW_LINKED) &&
+						_rtw_memcmp(paddr3, get_bssid(&secondary_padapter->mlmepriv), ETH_ALEN))
+					{
+						//change to secondary interface
+						precvframe->u.hdr.adapter = secondary_padapter;
+						clone = _FALSE;
+					}
+
+					if(check_fwstate(&primary_padapter->mlmepriv, _FW_LINKED) &&
+						_rtw_memcmp(paddr3, get_bssid(&primary_padapter->mlmepriv), ETH_ALEN))
+					{
+						if(clone==_FALSE)
+						{
+							clone = _TRUE;									
+						}	
+						else
+						{
+							clone = _FALSE;
+						}
+
+						precvframe->u.hdr.adapter = primary_padapter;	
+					}
+
+					if(check_fwstate(&primary_padapter->mlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) ||
+						check_fwstate(&secondary_padapter->mlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING))
+					{
+						clone = _TRUE;
+						precvframe->u.hdr.adapter = primary_padapter;	
+					}
+				
+				}
+				else if(subtype == WIFI_PROBEREQ)
+				{
+					//probe req frame is only for interface2
+					//change to secondary interface
+					precvframe->u.hdr.adapter = secondary_padapter;
+					clone = _FALSE;
+				}			
+				break;
+			case WIFI_CTRL_TYPE: // Handle BC/MC ctrl Packets
+			
+				break;
+			case WIFI_DATA_TYPE: //Handle BC/MC data Packets
+					//Notes: AP MODE never rx BC/MC data packets
+			
+				paddr2 = GetAddr2Ptr(precvframe->u.hdr.rx_data);
+
+				if(_rtw_memcmp(paddr2, get_bssid(&secondary_padapter->mlmepriv), ETH_ALEN))
+				{
+					//change to secondary interface
+					precvframe->u.hdr.adapter = secondary_padapter;
+					clone = _FALSE;
+				}
+
+				break;
+			default:
+			
+				break;			
+		}
+#endif
+
+		if(_TRUE == clone)
+		{
+			//clone/copy to if2		
+			struct rx_pkt_attrib *pattrib = NULL;
+		
+			precvframe_if2 = rtw_alloc_recvframe(pfree_recv_queue);
+			if(precvframe_if2)
+			{
+				precvframe_if2->u.hdr.adapter = secondary_padapter;
+		
+				_rtw_init_listhead(&precvframe_if2->u.hdr.list);	
+				precvframe_if2->u.hdr.precvbuf = NULL;	//can't access the precvbuf for new arch.
+				precvframe_if2->u.hdr.len=0;
+
+				_rtw_memcpy(&precvframe_if2->u.hdr.attrib, &precvframe->u.hdr.attrib, sizeof(struct rx_pkt_attrib));
+
+				pattrib = &precvframe_if2->u.hdr.attrib;
+
+				if(rtw_os_alloc_recvframe(secondary_padapter, precvframe_if2, pbuf, NULL) == _SUCCESS)				
+				{						
+					recvframe_put(precvframe_if2, pattrib->pkt_len);
+					//recvframe_pull(precvframe_if2, drvinfo_sz + RXDESC_SIZE);
+
+					if (pattrib->physt && pphy_status)
+						update_recvframe_phyinfo_88e(precvframe_if2, (struct phy_stat*)pphy_status);
+	
+					ret = rtw_recv_entry(precvframe_if2);				
+				}	
+				else
+				{
+					rtw_free_recvframe(precvframe_if2, pfree_recv_queue);
+					DBG_8192C("%s()-%d: alloc_skb() failed!\n", __FUNCTION__, __LINE__);	
+				}
+
+			}
+			
+		}
+		
+	}
+	//if (precvframe->u.hdr.attrib.physt)
+		//update_recvframe_phyinfo_88e(precvframe, (struct phy_stat*)pphy_status);
+	
+	//ret = rtw_recv_entry(precvframe);
+
+#endif
+
+	return ret;
+
+}
+
+
+
+static int recvbuf2recvframe(_adapter *padapter, 
+#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
+struct recv_buf *precvbuf
+#else
+_pkt *pskb
+#endif
+
+)
+{
+	u8	*pbuf;
+	u16	pkt_cnt;
+	u32	pkt_offset;
+	s32	transfer_len;
+	struct recv_stat	*prxstat;
+	struct phy_stat	*pphy_status = NULL;	
+	union recv_frame	*precvframe = NULL;
+	struct rx_pkt_attrib	*pattrib = NULL;
+	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+	_queue			*pfree_recv_queue = &precvpriv->free_recv_queue;
+
+#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
+	transfer_len = (s32)precvbuf->transfer_len;	
+	pbuf = precvbuf->pbuf;	
+#else
+       transfer_len = (s32)pskb->len;	
+	pbuf = pskb->data;
+#endif
+	prxstat = (struct recv_stat *)pbuf;	
+	pkt_cnt = (le32_to_cpu(prxstat->rxdw2)>>16) & 0xff;
+
+#if 0 //temp remove when disable usb rx aggregation
+	if((pkt_cnt > 10) || (pkt_cnt < 1) || (transfer_len<RXDESC_SIZE) ||(pkt_len<=0))
+	{		
+		return _FAIL;
+	}
+#endif
+	
+	do{		
+		RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
+			 ("recvbuf2recvframe: rxdesc=offsset 0:0x%08x, 4:0x%08x, 8:0x%08x, C:0x%08x\n",
+			  prxstat->rxdw0, prxstat->rxdw1, prxstat->rxdw2, prxstat->rxdw4));
+
+		prxstat = (struct recv_stat *)pbuf;
+
+		precvframe = rtw_alloc_recvframe(pfree_recv_queue);
+		if(precvframe==NULL)
+		{
+			RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,("recvbuf2recvframe: precvframe==NULL\n"));
+			DBG_8192C("%s()-%d: rtw_alloc_recvframe() failed! RX Drop!\n", __FUNCTION__, __LINE__);	
+			goto _exit_recvbuf2recvframe;
+		}
+
+		_rtw_init_listhead(&precvframe->u.hdr.list);	
+		precvframe->u.hdr.precvbuf = NULL;	//can't access the precvbuf for new arch.
+		precvframe->u.hdr.len=0;
+
+		//rtl8192c_query_rx_desc_status(precvframe, prxstat);
+		update_recvframe_attrib_88e(precvframe, prxstat);
+
+		pattrib = &precvframe->u.hdr.attrib;		
+				
+		if ( (padapter->registrypriv.mp_mode == 0) && ((pattrib->crc_err) || (pattrib->icv_err)))
+		{
+			DBG_8192C("%s: RX Warning! crc_err=%d icv_err=%d, skip!\n", __FUNCTION__, pattrib->crc_err, pattrib->icv_err);
+			rtw_free_recvframe(precvframe, pfree_recv_queue);
+			goto _exit_recvbuf2recvframe;
+		}
+
+
+		pkt_offset = RXDESC_SIZE + pattrib->drvinfo_sz + pattrib->shift_sz + pattrib->pkt_len;
+
+		if((pattrib->pkt_len<=0) || (pkt_offset>transfer_len))
+		{	
+			RT_TRACE(_module_rtl871x_recv_c_,_drv_info_,("recvbuf2recvframe: pkt_len<=0\n"));
+			DBG_8192C("%s()-%d: RX Warning!,pkt_len<=0 or pkt_offset> transfoer_len \n", __FUNCTION__, __LINE__);	
+			rtw_free_recvframe(precvframe, pfree_recv_queue);
+			goto _exit_recvbuf2recvframe;
+		}
+	
+		if(rtw_os_alloc_recvframe(padapter, precvframe, 
+			(pbuf+pattrib->shift_sz + pattrib->drvinfo_sz + RXDESC_SIZE),			
+#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
+			NULL
+#else
+			pskb
+#endif
+			) == _FAIL)
+		{
+			rtw_free_recvframe(precvframe, pfree_recv_queue);
+
+			goto _exit_recvbuf2recvframe;
+		}
+
+		recvframe_put(precvframe, pattrib->pkt_len);
+		//recvframe_pull(precvframe, drvinfo_sz + RXDESC_SIZE);	
+
+		if(pattrib->pkt_rpt_type == NORMAL_RX)//Normal rx packet
+		{
+			if(pattrib->physt)
+				pphy_status = (struct phy_stat *)(pbuf + RXDESC_OFFSET);
+
+#ifdef CONFIG_CONCURRENT_MODE
+			if(rtw_buddy_adapter_up(padapter))
+			{
+				if(pre_recv_entry(precvframe, prxstat, pphy_status) != _SUCCESS)
+				{
+					RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,
+						("recvbuf2recvframe: recv_entry(precvframe) != _SUCCESS\n"));
+				}
+			}
+#endif //CONFIG_CONCURRENT_MODE
+
+			if(pattrib->physt && pphy_status)
+				update_recvframe_phyinfo_88e(precvframe, (struct phy_stat*)pphy_status);
+
+			if(rtw_recv_entry(precvframe) != _SUCCESS)
+			{
+				RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,
+					("recvbuf2recvframe: rtw_recv_entry(precvframe) != _SUCCESS\n"));
+			}
+
+		}
+		else{ // pkt_rpt_type == TX_REPORT1-CCX, TX_REPORT2-TX RTP,HIS_REPORT-USB HISR RTP
+				
+			//enqueue recvframe to txrtp queue
+			if(pattrib->pkt_rpt_type == TX_REPORT1){
+				//DBG_8192C("rx CCX \n");
+				//CCX-TXRPT ack for xmit mgmt frames.
+				handle_txrpt_ccx_88e(padapter, precvframe->u.hdr.rx_data);
+			}
+			else if(pattrib->pkt_rpt_type == TX_REPORT2){
+				//DBG_8192C("rx TX RPT \n");
+				ODM_RA_TxRPT2Handle_8188E(
+							&pHalData->odmpriv,
+							precvframe->u.hdr.rx_data,
+							pattrib->pkt_len,
+							pattrib->MacIDValidEntry[0],
+							pattrib->MacIDValidEntry[1]
+							);
+				
+			}
+			else if(pattrib->pkt_rpt_type == HIS_REPORT)
+			{
+				//DBG_8192C("%s , rx USB HISR \n",__FUNCTION__);
+				#ifdef CONFIG_SUPPORT_USB_INT
+				interrupt_handler_8188eu(padapter,pattrib->pkt_len,precvframe->u.hdr.rx_data);
+				#endif
+			}				
+			rtw_free_recvframe(precvframe, pfree_recv_queue);			
+			
+		}
+	
+#ifdef CONFIG_USB_RX_AGGREGATION
+		switch(pHalData->UsbRxAggMode)
+		{
+			case USB_RX_AGG_DMA:
+			case USB_RX_AGG_MIX:
+				pkt_offset = (u16)_RND128(pkt_offset);
+				break;
+				case USB_RX_AGG_USB:
+				pkt_offset = (u16)_RND4(pkt_offset);
+				break;
+			case USB_RX_AGG_DISABLE:
+			default:
+				break;
+		}
+#endif
+		pkt_cnt--;
+		transfer_len -= pkt_offset;
+		pbuf += pkt_offset;	
+		precvframe = NULL;
+	
+		if(transfer_len>0 && pkt_cnt==0)
+			pkt_cnt = (le32_to_cpu(prxstat->rxdw2)>>16) & 0xff;
+
+	}while((transfer_len>0) && (pkt_cnt>0));
+
+_exit_recvbuf2recvframe:
+
+	return _SUCCESS;	
+}
+
+
+
+#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
+void rtl8188eu_recv_tasklet(void *priv)
+{	
+	struct recv_buf *precvbuf = NULL;
+	_adapter	*padapter = (_adapter*)priv;
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+
+	while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue)))
+	{
+		if ((padapter->bDriverStopped == _TRUE)||(padapter->bSurpriseRemoved== _TRUE))
+		{
+			DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved \n");
+			
+			break;
+		}
+		
+
+		recvbuf2recvframe(padapter, precvbuf);
+
+		rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
+	}	
+	
+}
+
+static void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
+{	
+	struct recv_buf	*precvbuf = (struct recv_buf *)purb->context;	
+	_adapter 			*padapter =(_adapter *)precvbuf->adapter;
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+
+	RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete!!!\n"));
+	
+	precvpriv->rx_pending_cnt --;
+		
+	if(RTW_CANNOT_RX(padapter))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n", padapter->bDriverStopped, padapter->bSurpriseRemoved));		
+		DBG_8192C("%s() RX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) \n", 
+		__FUNCTION__,padapter->bDriverStopped, padapter->bSurpriseRemoved);
+		goto exit;
+	}
+
+	if(purb->status==0)//SUCCESS
+	{
+		if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE))
+		{
+			RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete: (purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)\n"));
+
+			rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
+		}
+		else 
+		{			
+			rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
+			
+			precvbuf->transfer_len = purb->actual_length;	
+
+			//rtw_enqueue_rx_transfer_buffer(precvpriv, rx_transfer_buf);			
+			rtw_enqueue_recvbuf(precvbuf, &precvpriv->recv_buf_pending_queue);
+
+			tasklet_schedule(&precvpriv->recv_tasklet);			
+		}		
+	}
+	else
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
+	
+		DBG_8192C("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
+
+		if(rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE ){
+			padapter->bSurpriseRemoved = _TRUE;
+		}
+
+		switch(purb->status) {
+			case -EINVAL:
+			case -EPIPE:			
+			case -ENODEV:
+			case -ESHUTDOWN:
+				//padapter->bSurpriseRemoved=_TRUE;
+				//RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
+			case -ENOENT:
+				padapter->bDriverStopped=_TRUE;			
+				RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
+				break;
+			case -EPROTO:
+			case -EILSEQ:
+			case -ETIME:
+			case -ECOMM:
+			case -EOVERFLOW:
+				#ifdef DBG_CONFIG_ERROR_DETECT	
+				{	
+					HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+					pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;			
+				}
+				#endif
+				rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);			
+				break;
+			case -EINPROGRESS:
+				DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
+				break;
+			default:
+				break;				
+		}
+		
+	}	
+
+exit:	
+	
+_func_exit_;
+	
+}
+
+static u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
+{		
+	int err;
+	unsigned int pipe;
+	u32 ret = _SUCCESS;
+	PURB purb = NULL;	
+	struct recv_buf	*precvbuf = (struct recv_buf *)rmem;
+	_adapter		*adapter = pintfhdl->padapter;
+	struct dvobj_priv	*pdvobj = adapter_to_dvobj(adapter);
+	struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
+	struct recv_priv	*precvpriv = &adapter->recvpriv;
+	struct usb_device	*pusbd = pdvobj->pusbdev;
+
+_func_enter_;
+	
+	if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n"));
+		return _FAIL;
+	}
+	
+	rtl8188eu_init_recvbuf(adapter, precvbuf);
+
+	if(precvbuf->pbuf)
+	{			
+		precvpriv->rx_pending_cnt++;
+	
+		purb = precvbuf->purb;		
+
+		//translate DMA FIFO addr to pipehandle
+		pipe = ffaddr2pipehdl(pdvobj, addr);	
+
+		usb_fill_bulk_urb(purb, pusbd, pipe, 
+					precvbuf->pbuf,
+            				MAX_RECVBUF_SZ,
+            				usb_read_port_complete,
+            				precvbuf);//context is precvbuf
+
+		purb->transfer_dma = precvbuf->dma_transfer_addr;
+		purb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;								
+
+		err = usb_submit_urb(purb, GFP_ATOMIC);	
+		if((err) && (err != (-EPERM)))
+		{
+			RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x", err, purb->status));
+			DBG_8192C("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n",err,purb->status);
+			ret = _FAIL;
+		}
+		
+	}
+
+_func_exit_;
+
+	return ret;
+}
+#else	// CONFIG_USE_USB_BUFFER_ALLOC_RX
+void rtl8188eu_recv_tasklet(void *priv)
+{
+	_pkt			*pskb;
+	_adapter		*padapter = (_adapter*)priv;
+	struct recv_priv	*precvpriv = &padapter->recvpriv;
+	struct recv_buf	*precvbuf = NULL;
+
+	while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue)))
+	{
+		if ((padapter->bDriverStopped == _TRUE)||(padapter->bSurpriseRemoved== _TRUE))
+		{
+			DBG_8192C("recv_tasklet => bDriverStopped or bSurpriseRemoved \n");
+			rtw_skb_free(pskb);
+			break;
+		}
+	
+		recvbuf2recvframe(padapter, pskb);
+
+#ifdef CONFIG_PREALLOC_RECV_SKB
+
+		skb_reset_tail_pointer(pskb);
+
+		pskb->len = 0;
+		
+		skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
+		
+#else
+		rtw_skb_free(pskb);
+#endif
+				
+	}
+
+	while (NULL != (precvbuf = rtw_dequeue_recvbuf(&precvpriv->recv_buf_pending_queue)))
+	{
+		DBG_871X("dequeue_recvbuf %p\n", precvbuf);
+		precvbuf->pskb = NULL;
+		precvbuf->reuse = _FALSE;
+		rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
+	}
+	
+}
+
+
+static void usb_read_port_complete(struct urb *purb, struct pt_regs *regs)
+{
+	_irqL irqL;
+	uint isevt, *pbuf;
+	struct recv_buf	*precvbuf = (struct recv_buf *)purb->context;	
+	_adapter 			*padapter =(_adapter *)precvbuf->adapter;
+	struct recv_priv	*precvpriv = &padapter->recvpriv;	
+	
+	RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete!!!\n"));
+	
+	//_enter_critical(&precvpriv->lock, &irqL);
+	//precvbuf->irp_pending=_FALSE;
+	//precvpriv->rx_pending_cnt --;
+	//_exit_critical(&precvpriv->lock, &irqL);
+		
+	precvpriv->rx_pending_cnt --;
+		
+	//if(precvpriv->rx_pending_cnt== 0)
+	//{		
+	//	RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete: rx_pending_cnt== 0, set allrxreturnevt!\n"));
+	//	_rtw_up_sema(&precvpriv->allrxreturnevt);	
+	//}
+
+	if (RTW_CANNOT_RX(padapter))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n", padapter->bDriverStopped, padapter->bSurpriseRemoved));		
+		
+	#ifdef CONFIG_PREALLOC_RECV_SKB
+		precvbuf->reuse = _TRUE;
+	#else
+		if(precvbuf->pskb){
+			DBG_8192C("==> free skb(%p)\n",precvbuf->pskb);
+			rtw_skb_free(precvbuf->pskb);
+		}	
+	#endif
+		DBG_8192C("%s() RX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) \n", 
+		__FUNCTION__,padapter->bDriverStopped, padapter->bSurpriseRemoved);
+		goto exit;
+	}
+
+	if(purb->status==0)//SUCCESS
+	{
+		if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE))
+		{
+			RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete: (purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)\n"));
+			precvbuf->reuse = _TRUE;
+			rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);
+			DBG_8192C("%s()-%d: RX Warning!\n", __FUNCTION__, __LINE__);	
+		}
+		else 
+		{	
+			rtw_reset_continual_io_error(adapter_to_dvobj(padapter));
+			
+			precvbuf->transfer_len = purb->actual_length;			
+			skb_put(precvbuf->pskb, purb->actual_length);	
+			skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
+
+			if (skb_queue_len(&precvpriv->rx_skb_queue)<=1)
+				tasklet_schedule(&precvpriv->recv_tasklet);
+
+			precvbuf->pskb = NULL;
+			precvbuf->reuse = _FALSE;
+			rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);			
+		}		
+	}
+	else
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete : purb->status(%d) != 0 \n", purb->status));
+	
+		DBG_8192C("###=> usb_read_port_complete => urb status(%d)\n", purb->status);
+
+		if(rtw_inc_and_chk_continual_io_error(adapter_to_dvobj(padapter)) == _TRUE ){
+			padapter->bSurpriseRemoved = _TRUE;
+		}
+
+		switch(purb->status) {
+			case -EINVAL:
+			case -EPIPE:			
+			case -ENODEV:
+			case -ESHUTDOWN:
+				//padapter->bSurpriseRemoved=_TRUE;
+				//RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bSurpriseRemoved=TRUE\n"));
+			case -ENOENT:
+				padapter->bDriverStopped=_TRUE;			
+				RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port_complete:bDriverStopped=TRUE\n"));
+				break;
+			case -EPROTO:
+			case -EILSEQ:
+			case -ETIME:
+			case -ECOMM:
+			case -EOVERFLOW:
+				#ifdef DBG_CONFIG_ERROR_DETECT	
+				{	
+					HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);
+					pHalData->srestpriv.Wifi_Error_Status = USB_READ_PORT_FAIL;			
+				}
+				#endif
+				precvbuf->reuse = _TRUE;
+				rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, (unsigned char *)precvbuf);			
+				break;
+			case -EINPROGRESS:
+				DBG_8192C("ERROR: URB IS IN PROGRESS!/n");
+				break;
+			default:
+				break;				
+		}
+		
+	}	
+
+exit:	
+	
+_func_exit_;
+	
+}
+
+static u32 usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
+{	
+	_irqL irqL;
+	int err;
+	unsigned int pipe;
+	SIZE_PTR tmpaddr=0;
+	SIZE_PTR alignment=0;
+	u32 ret = _SUCCESS;
+	PURB purb = NULL;
+	struct recv_buf	*precvbuf = (struct recv_buf *)rmem;
+	_adapter		*adapter = pintfhdl->padapter;
+	struct dvobj_priv	*pdvobj = adapter_to_dvobj(adapter);
+	struct pwrctrl_priv *pwrctl = dvobj_to_pwrctl(pdvobj);
+	struct recv_priv	*precvpriv = &adapter->recvpriv;
+	struct usb_device	*pusbd = pdvobj->pusbdev;
+	
+
+_func_enter_;
+	
+	if (RTW_CANNOT_RX(adapter) || (precvbuf == NULL))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("usb_read_port:( RTW_CANNOT_RX ) || precvbuf == NULL!!!\n"));
+		return _FAIL;
+	}
+
+#ifdef CONFIG_PREALLOC_RECV_SKB
+	if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL))
+	{
+		if (NULL != (precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue)))
+		{
+			precvbuf->reuse = _TRUE;
+		}
+	}
+#endif
+
+	rtl8188eu_init_recvbuf(adapter, precvbuf);		
+
+	//re-assign for linux based on skb
+	if((precvbuf->reuse == _FALSE) || (precvbuf->pskb == NULL))
+	{
+		precvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
+
+		if(precvbuf->pskb == NULL)		
+		{
+			RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("init_recvbuf(): alloc_skb fail!\n"));
+			DBG_8192C("#### usb_read_port() alloc_skb fail!  precvbuf=%p #####\n", precvbuf);
+			//enqueue precvbuf and wait for free skb
+			rtw_enqueue_recvbuf(precvbuf, &precvpriv->recv_buf_pending_queue);
+			return _FAIL;
+		}
+
+		tmpaddr = (SIZE_PTR)precvbuf->pskb->data;
+        	alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
+		skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
+
+		precvbuf->phead = precvbuf->pskb->head;
+	   	precvbuf->pdata = precvbuf->pskb->data;
+		precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
+		precvbuf->pend = skb_end_pointer(precvbuf->pskb);
+		precvbuf->pbuf = precvbuf->pskb->data;
+	}	
+	else//reuse skb
+	{
+		precvbuf->phead = precvbuf->pskb->head;
+		precvbuf->pdata = precvbuf->pskb->data;
+		precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
+		precvbuf->pend = skb_end_pointer(precvbuf->pskb);
+   		precvbuf->pbuf = precvbuf->pskb->data;
+
+		precvbuf->reuse = _FALSE;
+	}
+
+	//_enter_critical(&precvpriv->lock, &irqL);
+	//precvpriv->rx_pending_cnt++;
+	//precvbuf->irp_pending = _TRUE;
+	//_exit_critical(&precvpriv->lock, &irqL);
+
+	precvpriv->rx_pending_cnt++;
+
+	purb = precvbuf->purb;
+
+	//translate DMA FIFO addr to pipehandle
+	pipe = ffaddr2pipehdl(pdvobj, addr);
+
+	usb_fill_bulk_urb(purb, pusbd, pipe, 
+					precvbuf->pbuf,
+            				MAX_RECVBUF_SZ,
+            				usb_read_port_complete,
+            				precvbuf);//context is precvbuf
+
+	err = usb_submit_urb(purb, GFP_ATOMIC);
+	if((err) && (err != (-EPERM)))
+	{
+		RT_TRACE(_module_hci_ops_os_c_,_drv_err_,("cannot submit rx in-token(err=0x%.8x), URB_STATUS =0x%.8x", err, purb->status));
+		DBG_8192C("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n",err,purb->status);
+		ret = _FAIL;
+	}
+
+_func_exit_;
+
+	return ret;
+}
+#endif	// CONFIG_USE_USB_BUFFER_ALLOC_RX
+
+void rtl8188eu_xmit_tasklet(void *priv)
+{	
+	int ret = _FALSE;
+	_adapter *padapter = (_adapter*)priv;
+	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
+
+	if(check_fwstate(&padapter->mlmepriv, _FW_UNDER_SURVEY) == _TRUE
+	#ifdef CONFIG_CONCURRENT_MODE
+		|| check_buddy_fwstate(padapter, _FW_UNDER_SURVEY) == _TRUE
+	#endif
+	) {
+		return;
+	}
+
+
+	while(1)
+	{
+		if (RTW_CANNOT_TX(padapter))
+		{
+			DBG_8192C("xmit_tasklet => bDriverStopped or bSurpriseRemoved or bWritePortCancel\n");
+			break;
+		}
+
+		ret = rtl8188eu_xmitframe_complete(padapter, pxmitpriv, NULL);
+
+		if(ret==_FALSE)
+			break;
+		
+	}
+	
+}
+
+void rtl8188eu_set_intf_ops(struct _io_ops	*pops)
+{		
+	_func_enter_;		
+
+	_rtw_memset((u8 *)pops, 0, sizeof(struct _io_ops));	
+
+	pops->_read8 = &usb_read8;
+	pops->_read16 = &usb_read16;
+	pops->_read32 = &usb_read32;
+	pops->_read_mem = &usb_read_mem;
+	pops->_read_port = &usb_read_port;	
+	
+	pops->_write8 = &usb_write8;
+	pops->_write16 = &usb_write16;
+	pops->_write32 = &usb_write32;
+	pops->_writeN = &usb_writeN;
+	
+#ifdef CONFIG_USB_SUPPORT_ASYNC_VDN_REQ	
+	pops->_write8_async= &usb_async_write8;
+	pops->_write16_async = &usb_async_write16;
+	pops->_write32_async = &usb_async_write32;
+#endif	
+	pops->_write_mem = &usb_write_mem;
+	pops->_write_port = &usb_write_port;
+
+	pops->_read_port_cancel = &usb_read_port_cancel;
+	pops->_write_port_cancel = &usb_write_port_cancel;
+
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+	pops->_read_interrupt = &usb_read_interrupt;
+#endif
+
+	_func_exit_;
+
+}
+
+void rtl8188eu_set_hw_type(_adapter *padapter)
+{
+	padapter->HardwareType = HARDWARE_TYPE_RTL8188EU;
+	DBG_871X("CHIP TYPE: RTL8188E\n");
+}
+