自学教程：C++ DBG_8723A函数代码示例

static int ips_netdrv_open(struct rtw_adapter *padapter){	int status = _SUCCESS;	padapter->net_closed = false;	DBG_8723A("===> %s........./n", __func__);	padapter->bDriverStopped = false;	padapter->bSurpriseRemoved = false;	padapter->bCardDisableWOHSM = false;	status = rtw_hal_init23a(padapter);	if (status == _FAIL) {		RT_TRACE(_module_os_intfs_c_, _drv_err_,			 ("ips_netdrv_open(): Can't init h/w!/n"));		goto netdev_open23a_error;	}	rtl8723au_inirp_init(padapter);	rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);	mod_timer(&padapter->mlmepriv.dynamic_chk_timer,		  jiffies + msecs_to_jiffies(5000));	return _SUCCESS;netdev_open23a_error:	/* padapter->bup = false; */	DBG_8723A("-ips_netdrv_open - drv_open failure, bup =%d/n",		  padapter->bup);	return _FAIL;}

void rtl8723au_free_recv_priv(struct rtw_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_free23a(padapter, precvbuf);		precvbuf++;	}	kfree(precvpriv->precv_buf);	usb_free_urb(precvpriv->int_in_urb);	kfree(precvpriv->int_in_buf);	if (skb_queue_len(&precvpriv->rx_skb_queue))		DBG_8723A(KERN_WARNING "rx_skb_queue not empty/n");	skb_queue_purge(&precvpriv->rx_skb_queue);	if (skb_queue_len(&precvpriv->free_recv_skb_queue)) {		DBG_8723A(KERN_WARNING "free_recv_skb_queue not empty, %d/n",			  skb_queue_len(&precvpriv->free_recv_skb_queue));	}	skb_queue_purge(&precvpriv->free_recv_skb_queue);}

static int _rtw_drv_register_netdev(struct rtw_adapter *padapter, char *name){	struct net_device *pnetdev = padapter->pnetdev;	int ret = _SUCCESS;	/* alloc netdev name */	rtw_init_netdev23a_name23a(pnetdev, name);	ether_addr_copy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr);	/* Tell the network stack we exist */	if (register_netdev(pnetdev)) {		DBG_8723A("%s(%s): Failed!/n", __func__, pnetdev->name);		ret = _FAIL;		goto error_register_netdev;	}	DBG_8723A("%s, MAC Address (if%d) = " MAC_FMT "/n", __func__,		  (padapter->iface_id + 1), MAC_ARG(pnetdev->dev_addr));	return ret;error_register_netdev:	if (padapter->iface_id > IFACE_ID0) {		rtw_free_drv_sw23a(padapter);		free_netdev(pnetdev);	}	return ret;}

int rtw_hw_suspend23a(struct rtw_adapter *padapter){	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	struct net_device *pnetdev = padapter->pnetdev;	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	if ((!padapter->bup) || (padapter->bDriverStopped) ||	    (padapter->bSurpriseRemoved)) {		DBG_8723A("padapter->bup =%d bDriverStopped =%d bSurpriseRemoved = %d/n",			  padapter->bup, padapter->bDriverStopped,			  padapter->bSurpriseRemoved);		goto error_exit;	}	if (padapter) { /* system suspend */		LeaveAllPowerSaveMode23a(padapter);		DBG_8723A("==> rtw_hw_suspend23a/n");		down(&pwrpriv->lock);		pwrpriv->bips_processing = true;		/* padapter->net_closed = true; */		/* s1. */		if (pnetdev) {			netif_carrier_off(pnetdev);			netif_tx_stop_all_queues(pnetdev);		}		/* s2. */		rtw_disassoc_cmd23a(padapter, 500, false);		/* s2-2.  indicate disconnect to os */		/* rtw_indicate_disconnect23a(padapter); */		if (check_fwstate(pmlmepriv, _FW_LINKED)) {			_clr_fwstate_(pmlmepriv, _FW_LINKED);			rtw_led_control(padapter, LED_CTL_NO_LINK);			rtw_os_indicate_disconnect23a(padapter);			/* donnot enqueue cmd */			rtw_lps_ctrl_wk_cmd23a(padapter,					       LPS_CTRL_DISCONNECT, 0);		}		/* s2-3. */		rtw_free_assoc_resources23a(padapter, 1);		/* s2-4. */		rtw_free_network_queue23a(padapter);		rtw_ips_dev_unload23a(padapter);		pwrpriv->rf_pwrstate = rf_off;		pwrpriv->bips_processing = false;		up(&pwrpriv->lock);	} else {		goto error_exit;	}	return 0;error_exit:	DBG_8723A("%s, failed/n", __func__);	return -1;}

static void rtw_dev_unload(struct rtw_adapter *padapter){	struct submit_ctx *pack_tx_ops = &padapter->xmitpriv.ack_tx_ops;	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_dev_unload/n"));	if (padapter->bup) {		DBG_8723A("===> rtw_dev_unload/n");		padapter->bDriverStopped = true;		if (padapter->xmitpriv.ack_tx)			rtw23a_sctx_done_err(&pack_tx_ops,					     RTW_SCTX_DONE_DRV_STOP);		/* s3. */		rtl8723a_usb_intf_stop(padapter);		/* s4. */		flush_workqueue(padapter->cmdpriv.wq);		/* s5. */		if (!padapter->bSurpriseRemoved) {			rtl8723au_hal_deinit(padapter);			padapter->bSurpriseRemoved = true;		}		padapter->bup = false;	} else {		RT_TRACE(_module_hci_intfs_c_, _drv_err_,			 ("r871x_dev_unload():padapter->bup == false/n"));	}	DBG_8723A("<=== rtw_dev_unload/n");	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-rtw_dev_unload/n"));}

static void sreset_restore_network_status(struct rtw_adapter *padapter){	struct mlme_priv *mlmepriv = &padapter->mlmepriv;	if (check_fwstate(mlmepriv, WIFI_STATION_STATE)) {		DBG_8723A("%s(%s): fwstate:0x%08x - WIFI_STATION_STATE/n",			  __func__, padapter->pnetdev->name,			  get_fwstate(mlmepriv));		sreset_restore_network_station(padapter);#ifdef CONFIG_8723AU_AP_MODE	} else if (check_fwstate(mlmepriv, WIFI_AP_STATE)) {		DBG_8723A("%s(%s): fwstate:0x%08x - WIFI_AP_STATE/n",			  __func__, padapter->pnetdev->name,			  get_fwstate(mlmepriv));		rtw_ap_restore_network(padapter);#endif	} else if (check_fwstate(mlmepriv, WIFI_ADHOC_STATE)) {		DBG_8723A("%s(%s): fwstate:0x%08x - WIFI_ADHOC_STATE/n",			  __func__, padapter->pnetdev->name,			  get_fwstate(mlmepriv));	} else {		DBG_8723A("%s(%s): fwstate:0x%08x - ???/n", __func__,			  padapter->pnetdev->name, get_fwstate(mlmepriv));	}}

/* * Return: *	0:	Leave OK *	-1:	Timeout *	-2:	Other error */s32 LPS_RF_ON_check23a(struct rtw_adapter *padapter, u32 delay_ms){	unsigned long start_time, end_time;	u8 bAwake = false;	s32 err = 0;	start_time = jiffies;	end_time = start_time + msecs_to_jiffies(delay_ms);	while (1)	{		bAwake = rtl8723a_get_fwlps_rf_on(padapter);		if (bAwake == true)			break;		if (padapter->bSurpriseRemoved == true) {			err = -2;			DBG_8723A("%s: device surprise removed!!/n", __func__);			break;		}		if (time_after(jiffies, end_time)) {			err = -1;			DBG_8723A("%s: Wait for FW LPS leave more than %u "				  "ms!/n", __func__, delay_ms);			break;		}		udelay(100);	}	return err;}

void rtw_sreset_reset(struct rtw_adapter *active_adapter){	struct rtw_adapter *padapter = GET_PRIMARY_ADAPTER(active_adapter);	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);	struct sreset_priv *psrtpriv = &pHalData->srestpriv;	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	unsigned long start = jiffies;	DBG_8723A("%s/n", __func__);	mutex_lock(&psrtpriv->silentreset_mutex);	psrtpriv->silent_reset_inprogress = true;	pwrpriv->change_rfpwrstate = rf_off;	sreset_stop_adapter(padapter);	ips_enter23a(padapter);	ips_leave23a(padapter);	sreset_start_adapter(padapter);	psrtpriv->silent_reset_inprogress = false;	mutex_unlock(&psrtpriv->silentreset_mutex);	DBG_8723A("%s done in %d ms/n", __func__,		  jiffies_to_msecs(jiffies - start));}

int ips_leave23a(struct rtw_adapter *padapter){	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	struct security_priv *psecuritypriv = &padapter->securitypriv;	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	int result = _SUCCESS;	int keyid;	down(&pwrpriv->lock);	if (pwrpriv->rf_pwrstate == rf_off && !pwrpriv->bips_processing) {		pwrpriv->bips_processing = true;		pwrpriv->change_rfpwrstate = rf_on;		pwrpriv->ips_leave23a_cnts++;		DBG_8723A("==>ips_leave23a cnts:%d/n",			  pwrpriv->ips_leave23a_cnts);		result = rtw_ips_pwr_up23a(padapter);		if (result == _SUCCESS)			pwrpriv->rf_pwrstate = rf_on;		DBG_8723A_LEVEL(_drv_always_, "nolinked power save leave/n");		if (psecuritypriv->dot11PrivacyAlgrthm ==		    WLAN_CIPHER_SUITE_WEP40 ||		    psecuritypriv->dot11PrivacyAlgrthm ==		    WLAN_CIPHER_SUITE_WEP104) {			DBG_8723A("==>%s, channel(%d), processing(%x)/n",				  __func__, padapter->mlmeextpriv.cur_channel,				  pwrpriv->bips_processing);			set_channel_bwmode23a(padapter,					      padapter->mlmeextpriv.cur_channel,					      HAL_PRIME_CHNL_OFFSET_DONT_CARE,					      HT_CHANNEL_WIDTH_20);			for (keyid = 0; keyid < 4; keyid++) {				if (pmlmepriv->key_mask & BIT(keyid)) {					if (keyid ==					    psecuritypriv->dot11PrivacyKeyIndex)						result = rtw_set_key23a(padapter, psecuritypriv, keyid, 1);					else						result = rtw_set_key23a(padapter, psecuritypriv, keyid, 0);				}			}		}		DBG_8723A("==> ips_leave23a.....LED(0x%08x).../n",			  rtl8723au_read32(padapter, 0x4c));		pwrpriv->bips_processing = false;		pwrpriv->bkeepfwalive = false;		pwrpriv->bpower_saving = false;	}	up(&pwrpriv->lock);	return result;}

static void __exit rtw_drv_halt(void){	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_drv_halt/n"));	DBG_8723A("+rtw_drv_halt/n");	usb_deregister(usb_drv);	DBG_8723A("-rtw_drv_halt/n");}

void rtw_ips_pwr_down23a(struct rtw_adapter *padapter){	unsigned long start_time = jiffies;	DBG_8723A("===> rtw_ips_pwr_down23a.................../n");	padapter->bCardDisableWOHSM = true;	padapter->net_closed = true;	rtw_ips_dev_unload23a(padapter);	padapter->bCardDisableWOHSM = false;	DBG_8723A("<=== rtw_ips_pwr_down23a..................... in %dms/n",		  jiffies_to_msecs(jiffies - start_time));}

int rtw_ips_pwr_up23a(struct rtw_adapter *padapter){	int result;	unsigned long start_time = jiffies;	DBG_8723A("===>  rtw_ips_pwr_up23a............../n");	rtw_reset_drv_sw23a(padapter);	result = ips_netdrv_open(padapter);	DBG_8723A("<===  rtw_ips_pwr_up23a.............. in %dms/n",		  jiffies_to_msecs(jiffies - start_time));	return result;}

struct xmit_frame	*rtw_IOL_accquire_xmit_frame(ADAPTER *adapter){	struct xmit_frame	*xmit_frame;	struct xmit_buf	*xmitbuf;	struct pkt_attrib	*pattrib;	struct xmit_priv	*pxmitpriv = &(adapter->xmitpriv);#if 1	if ((xmit_frame = rtw_alloc_xmitframe(pxmitpriv)) == NULL)	{		DBG_8723A("%s rtw_alloc_xmitframe return null/n", __FUNCTION__);		goto exit;	}	if ((xmitbuf = rtw_alloc_xmitbuf(pxmitpriv)) == NULL)	{		DBG_8723A("%s rtw_alloc_xmitbuf return null/n", __FUNCTION__);		rtw_free_xmitframe(pxmitpriv, xmit_frame);		xmit_frame=NULL;		goto exit;	}	xmit_frame->frame_tag = MGNT_FRAMETAG;	xmit_frame->pxmitbuf = xmitbuf;	xmit_frame->buf_addr = xmitbuf->pbuf;	xmitbuf->priv_data = xmit_frame;	pattrib = &xmit_frame->attrib;	update_mgntframe_attrib(adapter, pattrib);	pattrib->qsel = 0x10;/* Beacon */	pattrib->subtype = WIFI_BEACON;	pattrib->pktlen = pattrib->last_txcmdsz = 0;#else	if ((xmit_frame = alloc_mgtxmitframe(pxmitpriv)) == NULL)	{		DBG_8723A("%s alloc_mgtxmitframe return null/n", __FUNCTION__);	}	else {		pattrib = &xmit_frame->attrib;		update_mgntframe_attrib(adapter, pattrib);		pattrib->qsel = 0x10;		pattrib->pktlen = pattrib->last_txcmdsz = 0;	}#endifexit:	return xmit_frame;}

void rtl8723a_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_8723A("%s REG_TXDMA_STATUS:0x%08x/n", __FUNCTION__, txdma_status);		rtw_hal_sreset_reset(padapter);	}#ifdef CONFIG_USB_HCI	//total xmit irp = 4	//DBG_8723A("==>%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) {					//padapter->Wifi_Error_Status = WIFI_TX_HANG;					DBG_8723A("%s tx hang/n", __FUNCTION__);					rtw_hal_sreset_reset(padapter);				}			}		}	}#endif // #ifdef 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 rtw_ps_processor23a(struct rtw_adapter *padapter){	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	pwrpriv->ps_processing = true;	if (pwrpriv->bips_processing == true)		goto exit;	if (pwrpriv->ips_mode_req == IPS_NONE)		goto exit;	if (rtw_pwr_unassociated_idle(padapter) == false)		goto exit;	if (pwrpriv->rf_pwrstate == rf_on &&	    (pwrpriv->pwr_state_check_cnts % 4) == 0) {		DBG_8723A("==>%s .fw_state(%x)/n", __func__,			  get_fwstate(pmlmepriv));		pwrpriv->change_rfpwrstate = rf_off;		ips_enter23a(padapter);	}exit:	rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);	pwrpriv->ps_processing = false;	return;}

void rtl8723a_set_BTCoex_AP_mode_FwRsvdPkt_cmd(struct rtw_adapter *padapter){	struct hal_data_8723a *pHalData;	u8 bRecover = false;	DBG_8723A("+%s/n", __func__);	pHalData = GET_HAL_DATA(padapter);	/*  Set FWHW_TXQ_CTRL 0x422[6]= 0 to tell Hw the packet is not a real beacon frame. */	if (pHalData->RegFwHwTxQCtrl & BIT(6))		bRecover = true;	/*  To tell Hw the packet is not a real beacon frame. */	pHalData->RegFwHwTxQCtrl &= ~BIT(6);	rtl8723au_write8(padapter, REG_FWHW_TXQ_CTRL + 2,			 pHalData->RegFwHwTxQCtrl);	SetFwRsvdPagePkt_BTCoex(padapter);	/*  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 (bRecover) {		pHalData->RegFwHwTxQCtrl |= BIT(6);		rtl8723au_write8(padapter, REG_FWHW_TXQ_CTRL + 2,				 pHalData->RegFwHwTxQCtrl);	}}

void rtl8723a_off_rcr_am(struct rtw_adapter *padapter){	rtl8723au_write32(padapter, REG_RCR,		    rtl8723au_read32(padapter, REG_RCR) & (~RCR_AM));	DBG_8723A("%s, %d, RCR = %x/n", __func__, __LINE__,		  rtl8723au_read32(padapter, REG_RCR));}

int dbg_rtw_write32(_adapter *adapter, u32 addr, u32 val, const char *caller, const int line){    if (match_write_sniff_ranges(addr, 4))        DBG_8723A("DBG_IO %s:%d rtw_write32(0x%04x, 0x%08x)/n", caller, line, addr, val);    return _rtw_write32(adapter, addr, val);}

void ips_enter23a(struct rtw_adapter *padapter){	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	down(&pwrpriv->lock);	pwrpriv->bips_processing = true;	/*  syn ips_mode with request */	pwrpriv->ips_mode = pwrpriv->ips_mode_req;	pwrpriv->ips_enter23a_cnts++;	DBG_8723A("==>ips_enter23a cnts:%d/n", pwrpriv->ips_enter23a_cnts);	rtl8723a_BT_disable_coexist(padapter);	if (pwrpriv->change_rfpwrstate == rf_off) {		pwrpriv->bpower_saving = true;		DBG_8723A_LEVEL(_drv_always_, "nolinked power save enter/n");		if (pwrpriv->ips_mode == IPS_LEVEL_2)			pwrpriv->bkeepfwalive = true;		rtw_ips_pwr_down23a(padapter);		pwrpriv->rf_pwrstate = rf_off;	}	pwrpriv->bips_processing = false;	up(&pwrpriv->lock);}

static bool PS_RDY_CHECK(struct rtw_adapter *padapter){	unsigned long delta_time;	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;	delta_time = jiffies - pwrpriv->DelayLPSLastTimeStamp;	if (delta_time < LPS_DELAY_TIME)		return false;	if (!check_fwstate(pmlmepriv, _FW_LINKED) ||	    check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) ||	    check_fwstate(pmlmepriv, WIFI_AP_STATE) ||	    check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||	    check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))		return false;	if (pwrpriv->bInSuspend)		return false;	if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X &&	    !padapter->securitypriv.binstallGrpkey) {		DBG_8723A("Group handshake still in progress !!!/n");		return false;	}	if (!rtw_cfg80211_pwr_mgmt(padapter))		return false;	return true;}

void rtl8723a_sreset_linked_status_check(_adapter *padapter){	HAL_DATA_TYPE	*pHalData = GET_HAL_DATA(padapter);	struct sreset_priv *psrtpriv = &pHalData->srestpriv;#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_8723A("%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;	}}

/* dev_remove() - our device is being removed */static void rtw_disconnect(struct usb_interface *pusb_intf){	struct dvobj_priv *dvobj;	struct rtw_adapter *padapter;	struct net_device *pnetdev;	struct mlme_priv *pmlmepriv;	dvobj = usb_get_intfdata(pusb_intf);	if (!dvobj)		return;	padapter = dvobj->if1;	pnetdev = padapter->pnetdev;	pmlmepriv = &padapter->mlmepriv;	usb_set_intfdata(pusb_intf, NULL);	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+dev_remove()/n"));	rtw_pm_set_ips23a(padapter, IPS_NONE);	rtw_pm_set_lps23a(padapter, PS_MODE_ACTIVE);	LeaveAllPowerSaveMode23a(padapter);	rtw_usb_if1_deinit(padapter);	usb_dvobj_deinit(pusb_intf);	RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-dev_remove()/n"));	DBG_8723A("-r871xu_dev_remove, done/n");	return;}

int dbg_rtw_writeN(_adapter *adapter, u32 addr, u32 length, u8 *data, const char *caller, const int line){    if (match_write_sniff_ranges(addr, length))        DBG_8723A("DBG_IO %s:%d rtw_writeN(0x%04x, %u)/n", caller, line, addr, length);    return _rtw_writeN(adapter, addr, length, data);}

int dbg_rtw_IOL_append_WD_cmd(struct xmit_frame *xmit_frame, u16 addr, u32 value, const char *caller, const int line){	if (match_write_sniff_ranges(addr, 4))		DBG_8723A("DBG_IO %s:%d IOL_WD(0x%04x, 0x%08x)/n", caller, line, addr, value);	return _rtw_IOL_append_WD_cmd(xmit_frame, addr, value);}

static void usb_dvobj_deinit(struct usb_interface *usb_intf){	struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf);	usb_set_intfdata(usb_intf, NULL);	if (dvobj) {		/* Modify condition for 92DU DMDP 2010.11.18, by Thomas */		if ((dvobj->NumInterfaces != 2 && dvobj->NumInterfaces != 3) ||		    (dvobj->InterfaceNumber == 1)) {			if (interface_to_usbdev(usb_intf)->state !=			    USB_STATE_NOTATTACHED) {				/* If we didn't unplug usb dongle and				 * remove/insert module, driver fails on				 * sitesurvey for the first time when				 * device is up .				 * Reset usb port for sitesurvey fail issue.				 */				DBG_8723A("usb attached..., try to reset usb device/n");				usb_reset_device(interface_to_usbdev(usb_intf));			}		}		rtw_deinit_intf_priv(dvobj);		mutex_destroy(&dvobj->hw_init_mutex);		mutex_destroy(&dvobj->h2c_fwcmd_mutex);		mutex_destroy(&dvobj->setch_mutex);		mutex_destroy(&dvobj->setbw_mutex);		kfree(dvobj);	}	usb_put_dev(interface_to_usbdev(usb_intf));}

void rtl8723a_set_FwPwrMode_cmd(struct rtw_adapter *padapter, u8 Mode){	struct setpwrmode_parm H2CSetPwrMode;	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);	DBG_8723A("%s: Mode =%d SmartPS =%d UAPSD =%d BcnMode = 0x%02x/n", __func__,			Mode, pwrpriv->smart_ps, padapter->registrypriv.uapsd_enable, pwrpriv->bcn_ant_mode);	/*  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 (Mode != PS_MODE_ACTIVE && pHalData->rf_type != RF_2T2R)		ODM_RF_Saving23a(&pHalData->odmpriv, true);	H2CSetPwrMode.Mode = Mode;	H2CSetPwrMode.SmartPS = pwrpriv->smart_ps;	H2CSetPwrMode.AwakeInterval = 1;	H2CSetPwrMode.bAllQueueUAPSD = padapter->registrypriv.uapsd_enable;	H2CSetPwrMode.BcnAntMode = pwrpriv->bcn_ant_mode;	FillH2CCmd(padapter, SET_PWRMODE_EID, sizeof(H2CSetPwrMode), (u8 *)&H2CSetPwrMode);}

static int rtw_resume(struct usb_interface *pusb_intf){	struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);	struct rtw_adapter *padapter = dvobj->if1;	struct net_device *pnetdev;	struct pwrctrl_priv *pwrpriv = NULL;	int ret = -1;	unsigned long start_time = jiffies;	DBG_8723A("==> %s (%s:%d)/n", __func__, current->comm, current->pid);	if (!padapter)		goto exit;	pnetdev = padapter->pnetdev;	pwrpriv = &padapter->pwrctrlpriv;	down(&pwrpriv->lock);	rtw_reset_drv_sw23a(padapter);	pwrpriv->bkeepfwalive = false;	DBG_8723A("bkeepfwalive(%x)/n", pwrpriv->bkeepfwalive);	if (pm_netdev_open23a(pnetdev, true) != 0) {		up(&pwrpriv->lock);		goto exit;	}	netif_device_attach(pnetdev);	netif_carrier_on(pnetdev);	up(&pwrpriv->lock);	if (padapter->pid[1] != 0) {		DBG_8723A("pid[1]:%d/n", padapter->pid[1]);		kill_pid(find_vpid(padapter->pid[1]), SIGUSR2, 1);	}	rtw23a_roaming(padapter, NULL);	ret = 0;exit:	if (pwrpriv)		pwrpriv->bInSuspend = false;	DBG_8723A("<===  %s return %d.............. in %dms/n", __func__,		  ret, jiffies_to_msecs(jiffies - start_time));	return ret;}

void rtw_set_ps_mode23a(struct rtw_adapter *padapter, u8 ps_mode,			u8 smart_ps, u8 bcn_ant_mode){	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;	RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,			 ("%s: PowerMode =%d Smart_PS =%d/n",			  __func__, ps_mode, smart_ps));	if (ps_mode > PM_Card_Disable) {		RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,			 ("ps_mode:%d error/n", ps_mode));		return;	}	if (pwrpriv->pwr_mode == ps_mode) {		if (PS_MODE_ACTIVE == ps_mode)			return;		if (pwrpriv->smart_ps == smart_ps &&		    pwrpriv->bcn_ant_mode == bcn_ant_mode)			return;	}	if (ps_mode == PS_MODE_ACTIVE) {		DBG_8723A("rtw_set_ps_mode23a: Leave 802.11 power save/n");		pwrpriv->pwr_mode = ps_mode;		rtw_set_rpwm23a(padapter, PS_STATE_S4);		rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);		pwrpriv->bFwCurrentInPSMode = false;	} else {		if (PS_RDY_CHECK(padapter) ||		    rtl8723a_BT_using_antenna_1(padapter)) {			DBG_8723A("%s: Enter 802.11 power save/n", __func__);			pwrpriv->bFwCurrentInPSMode = true;			pwrpriv->pwr_mode = ps_mode;			pwrpriv->smart_ps = smart_ps;			pwrpriv->bcn_ant_mode = bcn_ant_mode;			rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);			rtw_set_rpwm23a(padapter, PS_STATE_S2);		}	}}

void rtw_hal_disable_interrupt23a(struct rtw_adapter *padapter){	if (padapter->HalFunc.disable_interrupt)		padapter->HalFunc.disable_interrupt(padapter);	else		DBG_8723A("%s: HalFunc.disable_interrupt is NULL!/n", __FUNCTION__);}

u32	rtw_hal_inirp_init23a(struct rtw_adapter *padapter){	u32 rst = _FAIL;	if (padapter->HalFunc.inirp_init)		rst = padapter->HalFunc.inirp_init(padapter);	else		DBG_8723A(" %s HalFunc.inirp_init is NULL!!!/n", __FUNCTION__);	return rst;}