void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = _TRUE;
// syn ips_mode with request
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_8192C("==>ips_enter cnts:%d\n",pwrpriv->ips_enter_cnts);
if(rf_off == pwrpriv->change_rfpwrstate )
{
DBG_8192C("==>power_saving_ctrl_wk_hdl change rf to OFF...LED(0x%08x).... \n\n",rtw_read32(padapter,0x4c));
if(pwrpriv->ips_mode == IPS_LEVEL_2) {
u8 rf_type;
padapter->HalFunc.GetHwRegHandler(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
pwrpriv->bkeepfwalive = ( rf_type == RF_1T1R )? _TRUE : _FALSE;//rtl8192cu cannot support IPS_Level2 ,must debug
}
rtw_ips_pwr_down(padapter);
pwrpriv->current_rfpwrstate = rf_off;
}
pwrpriv->bips_processing = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
}
void rtw_unregister_cmd_alive(_adapter *padapter)
{
#ifdef CONFIG_PWRCTRL
struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
_func_enter_;
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, CMD_ALIVE);
if((pwrctrl->cpwm > PS_STATE_S2) && (pwrctrl->pwr_mode > PS_MODE_ACTIVE)){
if((pwrctrl->alives == 0)&&(check_fwstate(&padapter->mlmepriv, _FW_UNDER_LINKING)!=_TRUE)){
rtw_set_rpwm(padapter, PS_STATE_S0);
}
}
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("rtw_unregister_cmd_alive: cpwm:%d alives:%x\n", pwrctrl->cpwm, pwrctrl->alives));
_exit_pwrlock(&pwrctrl->lock);
_func_exit_;
#endif /*CONFIG_PWRCTRL*/
}
void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = _TRUE;
// syn ips_mode with request
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_8192C("==>ips_enter cnts:%d\n",pwrpriv->ips_enter_cnts);
if(rf_off == pwrpriv->change_rfpwrstate )
{
DBG_8192C("==>power_saving_ctrl_wk_hdl change rf to OFF...LED(0x%08x).... \n\n",rtw_read32(padapter,0x4c));
if(pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = _TRUE;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
}
/*
* Caller: rtw_cmd_thread
*
* Check if the fw_pwrstate is okay for issuing cmd.
* If not (cpwm should be is less than S2), then the sub-routine
* will raise the cpwm to be greater than or equal to S2.
*
* Calling Context: Passive
*
* Return Value:
* _SUCCESS rtw_cmd_thread can issue cmds to firmware afterwards.
* _FAIL rtw_cmd_thread can not do anything.
*/
s32 rtw_register_cmd_alive(struct rtw_adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
res = _SUCCESS;
pwrctrl = &padapter->pwrctrlpriv;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, CMD_ALIVE);
if (pwrctrl->bFwCurrentInPSMode == true) {
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("rtw_register_cmd_alive: cpwm=0x%02x alives=0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm < PS_STATE_S2) {
if (pwrctrl->rpwm < PS_STATE_S2)
rtw_set_rpwm(padapter, PS_STATE_S2);
res = _FAIL;
}
}
_exit_pwrlock(&pwrctrl->lock);
return res;
}
void ips_enter(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = true;
/* syn ips_mode with request */
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_8192D("==>ips_enter cnts:%d\n", pwrpriv->ips_enter_cnts);
if (rf_off == pwrpriv->change_rfpwrstate) {
if (pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = true;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = false;
_exit_pwrlock(&pwrpriv->lock);
}
/*
Caller:ISR handler...
This will be called when CPWM interrupt is up.
using to update cpwn of drv; and drv willl make a decision to up or down pwr level
*/
void cpwm_int_hdl(_adapter *padapter, struct reportpwrstate_parm *preportpwrstate)
{
struct pwrctrl_priv *pwrpriv = &(padapter->pwrctrlpriv);
struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
_func_enter_;
if(pwrpriv->cpwm_tog == ((preportpwrstate->state)&0x80)){
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("cpwm_int_hdl : cpwm_tog = %x this time cpwm=0x%x toggle bit didn't change !!!\n",pwrpriv->cpwm_tog ,preportpwrstate->state));
goto exit;
}
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->cpwm = (preportpwrstate->state)&0xf;
if(pwrpriv->cpwm >= PS_STATE_S2){
if(pwrpriv->alives & CMD_ALIVE)
_rtw_up_sema(&(pcmdpriv->cmd_queue_sema));
if(pwrpriv->alives & XMIT_ALIVE)
_rtw_up_sema(&(pxmitpriv->xmit_sema));
}
pwrpriv->cpwm_tog= (preportpwrstate->state)&0x80;
_exit_pwrlock(&pwrpriv->lock);
exit:
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("cpwm_int_hdl : cpwm = %x !!!\n",pwrpriv->cpwm));
_func_exit_;
}
/*
Caller: rtw_cmd_thread
Check if the fw_pwrstate is okay for issuing cmd.
If not (cpwm should be is less than P2 state), then the sub-routine
will raise the cpwm to be greater than or equal to P2.
Calling Context: Passive
Return Value:
_SUCCESS: rtw_cmd_thread can issue cmds to firmware afterwards.
_FAIL: rtw_cmd_thread can not do anything.
*/
sint rtw_register_cmd_alive(_adapter *padapter)
{
uint res = _SUCCESS;
#ifdef CONFIG_PWRCTRL
struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
_func_enter_;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, CMD_ALIVE);
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("rtw_register_cmd_alive: cpwm:%d alives:%x\n", pwrctrl->cpwm, pwrctrl->alives));
if(pwrctrl->cpwm < PS_STATE_S2){
rtw_set_rpwm(padapter, PS_STATE_S3);
res = _FAIL;
}
_exit_pwrlock(&pwrctrl->lock);
_func_exit_;
#endif
return res;
}
void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
_enter_pwrlock(&pwrpriv->lock);
_ips_enter(padapter);
_exit_pwrlock(&pwrpriv->lock);
}
void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
_enter_pwrlock(&pwrpriv->lock);
_ips_enter(padapter);
_exit_pwrlock(&pwrpriv->lock);
}
int ips_leave(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
int ret;
_enter_pwrlock(&pwrpriv->lock);
ret = _ips_leave(padapter);
_exit_pwrlock(&pwrpriv->lock);
return ret;
}
int ips_leave(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;
_enter_pwrlock(&pwrpriv->lock);
if ((pwrpriv->rf_pwrstate == rf_off) && (!pwrpriv->bips_processing)) {
pwrpriv->bips_processing = true;
pwrpriv->change_rfpwrstate = rf_on;
pwrpriv->ips_leave_cnts++;
DBG_8192D("==>ips_leave cnts:%d\n", pwrpriv->ips_leave_cnts);
result = rtw_ips_pwr_up(padapter);
if (result == _SUCCESS)
pwrpriv->rf_pwrstate = rf_on;
if ((_WEP40_ == psecuritypriv->dot11PrivacyAlgrthm) ||
(_WEP104_ == psecuritypriv->dot11PrivacyAlgrthm)) {
DBG_8192D("==>%s,channel(%d),processing(%x)\n",
__func__, padapter->mlmeextpriv.cur_channel,
pwrpriv->bips_processing);
set_channel_bwmode(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_key(padapter,
psecuritypriv,
keyid, 1);
else
result =
rtw_set_key(padapter,
psecuritypriv,
keyid, 0);
}
}
}
DBG_8192D("==> ips_leave.....LED(0x%08x)...\n",
rtw_read32(padapter, 0x4c));
pwrpriv->bips_processing = false;
pwrpriv->bkeepfwalive = false;
}
_exit_pwrlock(&pwrpriv->lock);
return result;
}
int netdev_open(struct net_device *pnetdev)
{
int ret;
_adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
_enter_pwrlock(&pwrctrlpriv->lock);
ret = _netdev_open(pnetdev);
_exit_pwrlock(&pwrctrlpriv->lock);
return ret;
}
static int rtw_hw_resume(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct net_device *pnetdev = padapter->pnetdev;
/* system resume */
DBG_88E("==> rtw_hw_resume\n");
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = true;
rtw_reset_drv_sw(padapter);
if (pm_netdev_open(pnetdev, false) != 0) {
_exit_pwrlock(&pwrpriv->lock);
goto error_exit;
}
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
if (!netif_queue_stopped(pnetdev))
netif_start_queue(pnetdev);
else
netif_wake_queue(pnetdev);
pwrpriv->bkeepfwalive = false;
pwrpriv->brfoffbyhw = false;
pwrpriv->rf_pwrstate = rf_on;
pwrpriv->bips_processing = false;
_exit_pwrlock(&pwrpriv->lock);
return 0;
error_exit:
DBG_88E("%s, Open net dev failed\n", __func__);
return -1;
}
void sreset_reset(_adapter *padapter)
{
#ifdef DBG_CONFIG_ERROR_RESET
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_irqL irqL;
unsigned long start = jiffies;
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
DBG_871X("%s\n", __FUNCTION__);
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
#ifdef CONFIG_LPS
rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "SRESET");
#endif//#ifdef CONFIG_LPS
_enter_pwrlock(&pwrpriv->lock);
psrtpriv->silent_reset_inprogress = _TRUE;
pwrpriv->change_rfpwrstate = rf_off;
sreset_stop_adapter(padapter);
#ifdef CONFIG_CONCURRENT_MODE
sreset_stop_adapter(padapter->pbuddy_adapter);
#endif
#ifdef CONFIG_IPS
_ips_enter(padapter);
_ips_leave(padapter);
#endif
sreset_start_adapter(padapter);
#ifdef CONFIG_CONCURRENT_MODE
sreset_start_adapter(padapter->pbuddy_adapter);
#endif
psrtpriv->silent_reset_inprogress = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
DBG_871X("%s done in %d ms\n", __FUNCTION__, jiffies_to_msecs(jiffies - start));
pdbgpriv->dbg_sreset_cnt++;
#endif
}
void pnp_sleep_wk(void *context)
{
_irqL irqL;
_adapter *padapter = (_adapter *)context;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("pnp_sleep_wk ===>\n"));
_enter_critical(&pmlmepriv->lock, &irqL );
if(check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE)
{
indicate_disconnect(padapter); //will clr Linked_state; before this function, we must have chked whether issue dis-assoc_cmd or not
free_assoc_resources(padapter);
#ifndef CONFIG_POWER_DOWN_MODE
disassoc_cmd(padapter);
#endif
}
_exit_critical(&pmlmepriv->lock, &irqL );
RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("pnp_sleep_wk:fwstate:%d\n", pmlmepriv->fw_state));
#ifdef CONFIG_POWER_DOWN_MODE
//before enter powerdown mode, we must ensure FW in S4 state.
if (padapter->pwrctrlpriv.pwr_mode > PS_MODE_ACTIVE) {
padapter->pwrctrlpriv.pwr_mode = PS_MODE_ACTIVE;
_enter_pwrlock(&(padapter->pwrctrlpriv.lock));
set_rpwm(padapter, PS_STATE_S4);
_exit_pwrlock(&(padapter->pwrctrlpriv.lock));
}
while (pwrctrl->cpwm != PS_STATE_S4) {
//waiting FW to become ACTIVE.
msleep_os(10);
}
#endif
write16(padapter, SDIO_HIMR, 0);
pwrctrl->pnp_bstop_trx = _TRUE;
padapter->hw_init_completed = _FALSE;
NdisMSetInformationComplete(padapter->hndis_adapter, NDIS_STATUS_SUCCESS);
RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("pnp_sleep_wk <===\n"));
}
void rtw_unregister_evt_alive(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
pwrctrl = &padapter->pwrctrlpriv;
unregister_task_alive(pwrctrl, EVT_ALIVE);
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("rtw_unregister_evt_alive: cpwm=0x%02x alives=0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
_exit_pwrlock(&pwrctrl->lock);
}
void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmit_priv = &padapter->xmitpriv;
#if (MP_DRIVER == 1)
if (padapter->registrypriv.mp_mode == 1)
return;
#endif
if (pxmit_priv->free_xmitbuf_cnt != NR_XMITBUFF ||
pxmit_priv->free_xmit_extbuf_cnt != NR_XMIT_EXTBUFF) {
DBG_871X_LEVEL(_drv_always_, "There are some pkts to transmit\n");
DBG_871X_LEVEL(_drv_info_, "free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
pxmit_priv->free_xmitbuf_cnt, pxmit_priv->free_xmit_extbuf_cnt);
return;
}
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = _TRUE;
// syn ips_mode with request
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_871X("==>ips_enter cnts:%d\n",pwrpriv->ips_enter_cnts);
#ifdef CONFIG_BT_COEXIST
BTDM_TurnOffBtCoexistBeforeEnterIPS(padapter);
#endif
if(rf_off == pwrpriv->change_rfpwrstate )
{
pwrpriv->bpower_saving = _TRUE;
DBG_871X_LEVEL(_drv_always_, "nolinked power save enter\n");
if(pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = _TRUE;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
}
static int rtw_resume_process(struct adapter *padapter)
{
struct net_device *pnetdev;
struct pwrctrl_priv *pwrpriv = NULL;
int ret = -1;
u32 start_time = jiffies;
DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
if (padapter) {
pnetdev = padapter->pnetdev;
pwrpriv = &padapter->pwrctrlpriv;
} else {
goto exit;
}
_enter_pwrlock(&pwrpriv->lock);
rtw_reset_drv_sw(padapter);
pwrpriv->bkeepfwalive = false;
DBG_88E("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive);
if (pm_netdev_open(pnetdev, true) != 0)
goto exit;
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
_exit_pwrlock(&pwrpriv->lock);
if (padapter->pid[1] != 0) {
DBG_88E("pid[1]:%d\n", padapter->pid[1]);
rtw_signal_process(padapter->pid[1], SIGUSR2);
}
rtw_roaming(padapter, NULL);
ret = 0;
exit:
if (pwrpriv)
pwrpriv->bInSuspend = false;
DBG_88E("<=== %s return %d.............. in %dms\n", __func__,
ret, rtw_get_passing_time_ms(start_time));
return ret;
}
/*
* Caller: rx_isr
*
* Calling Context: Dispatch/ISR
*
* Return Value:
* _SUCCESS
* _FAIL
*/
s32 rtw_register_rx_alive(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
pwrctrl = &padapter->pwrctrlpriv;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, RECV_ALIVE);
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("rtw_register_rx_alive: cpwm=0x%02x alives=0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
_exit_pwrlock(&pwrctrl->lock);
return _SUCCESS;
}
void sreset_reset(_adapter *padapter)
{
#ifdef DBG_CONFIG_ERROR_RESET
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
struct sreset_priv *psrtpriv = &pHalData->srestpriv;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
_irqL irqL;
u32 start = rtw_get_current_time();
DBG_871X("%s\n", __FUNCTION__);
psrtpriv->Wifi_Error_Status = WIFI_STATUS_SUCCESS;
_enter_pwrlock(&pwrpriv->lock);
psrtpriv->silent_reset_inprogress = _TRUE;
pwrpriv->change_rfpwrstate = rf_off;
sreset_stop_adapter(padapter);
#ifdef CONFIG_CONCURRENT_MODE
sreset_stop_adapter(padapter->pbuddy_adapter);
#endif
#ifdef CONFIG_IPS
_ips_enter(padapter);
_ips_leave(padapter);
#endif
sreset_start_adapter(padapter);
#ifdef CONFIG_CONCURRENT_MODE
sreset_start_adapter(padapter->pbuddy_adapter);
#endif
psrtpriv->silent_reset_inprogress = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
DBG_871X("%s done in %d ms\n", __FUNCTION__, rtw_get_passing_time_ms(start));
#endif
}
void rtw_unregister_evt_alive(_adapter *padapter)
{
#ifdef CONFIG_PWRCTRL
struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
_func_enter_;
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, EVT_ALIVE);
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("rtw_unregister_evt_alive: cpwm:%d alives:%x\n", pwrctrl->cpwm, pwrctrl->alives));
_exit_pwrlock(&pwrctrl->lock);
_func_exit_;
#endif /*CONFIG_PWRCTRL*/
}
int ips_leave(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct security_priv* psecuritypriv=&(padapter->securitypriv);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
int result = _SUCCESS;
sint keyid;
_enter_pwrlock(&pwrpriv->lock);
if((pwrpriv->current_rfpwrstate == rf_off) &&(!pwrpriv->bips_processing))
{
pwrpriv->change_rfpwrstate = rf_on;
pwrpriv->ips_leave_cnts++;
DBG_8192C("==>ips_leave cnts:%d\n",pwrpriv->ips_leave_cnts);
#ifdef CONFIG_IPS_LEVEL_2
pwrpriv->bkeepfwalive = _TRUE;
#endif
result = rtw_ips_pwr_up(padapter);
pwrpriv->bips_processing = _TRUE;
pwrpriv->current_rfpwrstate = rf_on;
if((_WEP40_ == psecuritypriv->dot11PrivacyAlgrthm) ||(_WEP104_ == psecuritypriv->dot11PrivacyAlgrthm))
{
DBG_8192C("==>%s,channel(%d),processing(%x)\n",__FUNCTION__,padapter->mlmeextpriv.cur_channel,pwrpriv->bips_processing);
set_channel_bwmode(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)){
result=rtw_set_key(padapter,psecuritypriv, keyid);
}
}
}
DBG_8192C("==> ips_leave.....LED(0x%08x)...\n",rtw_read32(padapter,0x4c));
pwrpriv->bips_processing = _FALSE;
#ifdef CONFIG_IPS_LEVEL_2
pwrpriv->bkeepfwalive = _FALSE;
#endif
}
_exit_pwrlock(&pwrpriv->lock);
return result;
}
void ips_enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct xmit_priv *pxmit_priv = &padapter->xmitpriv;
if (padapter->registrypriv.mp_mode == 1)
return;
if (pxmit_priv->free_xmitbuf_cnt != NR_XMITBUFF ||
pxmit_priv->free_xmit_extbuf_cnt != NR_XMIT_EXTBUFF) {
DBG_88E_LEVEL(_drv_info_, "There are some pkts to transmit\n");
DBG_88E_LEVEL(_drv_info_, "free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
pxmit_priv->free_xmitbuf_cnt, pxmit_priv->free_xmit_extbuf_cnt);
return;
}
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = true;
/* syn ips_mode with request */
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_88E("==>ips_enter cnts:%d\n", pwrpriv->ips_enter_cnts);
if (rf_off == pwrpriv->change_rfpwrstate) {
pwrpriv->bpower_saving = true;
DBG_88E_LEVEL(_drv_info_, "nolinked power save enter\n");
if (pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = true;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = false;
_exit_pwrlock(&pwrpriv->lock);
}
void ips_enter(_adapter * padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
if (padapter->hw_init_completed == _FALSE) {
DBG_871X("%s: hw_init_completed: %d\n",
__func__, padapter->hw_init_completed);
return;
}
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = _TRUE;
// syn ips_mode with request
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
DBG_871X("==>ips_enter cnts:%d\n",pwrpriv->ips_enter_cnts);
#ifdef CONFIG_BT_COEXIST
BTDM_TurnOffBtCoexistBeforeEnterIPS(padapter);
#endif
if(rf_off == pwrpriv->change_rfpwrstate )
{
pwrpriv->bpower_saving = _TRUE;
DBG_871X_LEVEL(_drv_always_, "nolinked power save enter\n");
if(pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = _TRUE;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = _FALSE;
_exit_pwrlock(&pwrpriv->lock);
}
/*
* Caller: ISR
*
* If all commands have been done,
* and no more command to do,
* then driver shall call this fun. to power down firmware again.
*/
void rtw_unregister_cmd_alive(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
pwrctrl = &padapter->pwrctrlpriv;
_enter_pwrlock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, CMD_ALIVE);
if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE) &&
(pwrctrl->bFwCurrentInPSMode == true)) {
if ((pwrctrl->alives == 0) && (pwrctrl->cpwm > PS_STATE_S0))
rtw_set_rpwm(padapter, PS_STATE_S0);
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("rtw_unregister_cmd_alive: cpwm=0x%02x alives=0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
}
_exit_pwrlock(&pwrctrl->lock);
}
/*
Caller: rx_isr
Calling Context: Dispatch/ISR
Return Value:
*/
sint rtw_register_rx_alive(_adapter *padapter)
{
#ifdef CONFIG_PWRCTRL
struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
_func_enter_;
_enter_pwrlock(&pwrctrl->lock);
register_task_alive(pwrctrl, RECV_ALIVE);
RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,("rtw_register_rx_alive: cpwm:%d alives:%x\n", pwrctrl->cpwm, pwrctrl->alives));
_exit_pwrlock(&pwrctrl->lock);
_func_exit_;
#endif /*CONFIG_PWRCTRL*/
return _SUCCESS;
}
void rtw_set_ps_mode(PADAPTER padapter, u8 ps_mode, u8 smart_ps)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &( padapter->wdinfo );
#endif //CONFIG_P2P
#ifdef CONFIG_TDLS
struct sta_priv *pstapriv = &padapter->stapriv;
_irqL irqL;
int i, j;
_list *plist, *phead;
struct sta_info *ptdls_sta;
#endif //CONFIG_TDLS
_func_enter_;
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("%s: PowerMode=%d Smart_PS=%d\n",
__FUNCTION__, 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) &&
(pwrpriv->smart_ps == smart_ps)){
return;
}
//if(pwrpriv->pwr_mode == PS_MODE_ACTIVE)
if(ps_mode == PS_MODE_ACTIVE)
{
#ifdef CONFIG_P2P_PS
if(pwdinfo->opp_ps == 0)
#endif // CONFIG_P2P_PS
{
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#endif
DBG_871X("rtw_set_ps_mode(): Busy Traffic , Leave 802.11 power save..\n");
#ifdef CONFIG_TDLS
_enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
for(i=0; i< NUM_STA; i++)
{
phead = &(pstapriv->sta_hash[i]);
plist = get_next(phead);
while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
{
ptdls_sta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
if( ptdls_sta->tdls_sta_state & TDLS_LINKED_STATE )
issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta, 0);
plist = get_next(plist);
}
}
_exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
#endif //CONFIG_TDLS
pwrpriv->smart_ps = smart_ps;
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm(padapter, PS_STATE_S4);
#ifdef CONFIG_LPS_LCLK
{
u32 n = 0;
while (pwrpriv->cpwm != PS_STATE_S4) {
n++;
if (n == 10000) break;
if (padapter->bSurpriseRemoved == _TRUE) break;
rtw_msleep_os(1);
}
if (n == 10000)
printk(KERN_ERR "%s: wait CPWM to S4 too long! cpwm=0x%02x\n", __func__, pwrpriv->cpwm);
}
#endif
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
pwrpriv->bFwCurrentInPSMode = _FALSE;
#ifdef CONFIG_LPS_LCLK
_exit_pwrlock(&pwrpriv->lock);
#endif
}
}
void rtw_set_ps_mode(struct rtw_adapter *padapter, u8 ps_mode, u8 smart_ps)
{
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) && (pwrpriv->smart_ps == smart_ps)) {
return;
}
/* if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) */
if (ps_mode == PS_MODE_ACTIVE) {
{
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#endif
DBG_8192D
("rtw_set_ps_mode(): Busy Traffic , Leave 802.11 power save..\n");
pwrpriv->smart_ps = smart_ps;
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm(padapter, PS_STATE_S4);
#ifdef CONFIG_LPS_LCLK
{
u32 n = 0;
while (pwrpriv->cpwm != PS_STATE_S4) {
n++;
if (n == 10000)
break;
if (padapter->bSurpriseRemoved == true)
break;
rtw_msleep_os(1);
}
if (n == 10000)
printk(KERN_ERR
"%s: wait CPWM to S4 too long! cpwm=0x%02x\n",
__func__, pwrpriv->cpwm);
}
#endif
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE,
(u8 *)(&ps_mode));
pwrpriv->bFwCurrentInPSMode = false;
#ifdef CONFIG_LPS_LCLK
_exit_pwrlock(&pwrpriv->lock);
#endif
}
} else {
if (ps_rdy_check(padapter)) {
#ifdef CONFIG_LPS_LCLK
_enter_pwrlock(&pwrpriv->lock);
#endif
DBG_8192D
("rtw_set_ps_mode(): Enter 802.11 power save mode...\n");
pwrpriv->smart_ps = smart_ps;
pwrpriv->pwr_mode = ps_mode;
pwrpriv->bFwCurrentInPSMode = true;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
#ifdef CONFIG_LPS_LCLK
if (pwrpriv->alives == 0)
rtw_set_rpwm(padapter, PS_STATE_S0);
#else
rtw_set_rpwm(padapter, PS_STATE_S2);
#endif
#ifdef CONFIG_LPS_LCLK
_exit_pwrlock(&pwrpriv->lock);
#endif
}
/* else */
/* */
/* pwrpriv->pwr_mode = PS_MODE_ACTIVE; */
/* */
}
}
static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
{
struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
struct adapter *padapter = dvobj->if1;
struct net_device *pnetdev = padapter->pnetdev;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
int ret = 0;
u32 start_time = jiffies;
DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
if ((!padapter->bup) || (padapter->bDriverStopped) ||
(padapter->bSurpriseRemoved)) {
DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
padapter->bup, padapter->bDriverStopped,
padapter->bSurpriseRemoved);
goto exit;
}
pwrpriv->bInSuspend = true;
rtw_cancel_all_timer(padapter);
LeaveAllPowerSaveMode(padapter);
_enter_pwrlock(&pwrpriv->lock);
/* s1. */
if (pnetdev) {
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
}
/* s2. */
rtw_disassoc_cmd(padapter, 0, false);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
check_fwstate(pmlmepriv, _FW_LINKED)) {
DBG_88E("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n",
__func__, __LINE__,
pmlmepriv->cur_network.network.Ssid.Ssid,
pmlmepriv->cur_network.network.MacAddress,
pmlmepriv->cur_network.network.Ssid.SsidLength,
pmlmepriv->assoc_ssid.SsidLength);
pmlmepriv->to_roaming = 1;
}
/* s2-2. indicate disconnect to os */
rtw_indicate_disconnect(padapter);
/* s2-3. */
rtw_free_assoc_resources(padapter, 1);
/* s2-4. */
rtw_free_network_queue(padapter, true);
rtw_dev_unload(padapter);
_exit_pwrlock(&pwrpriv->lock);
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
rtw_indicate_scan_done(padapter, 1);
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
rtw_indicate_disconnect(padapter);
exit:
DBG_88E("<=== %s return %d.............. in %dms\n", __func__
, ret, rtw_get_passing_time_ms(start_time));
return ret;
}
static int rtw_hw_suspend(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct net_device *pnetdev = padapter->pnetdev;
if ((!padapter->bup) || (padapter->bDriverStopped) ||
(padapter->bSurpriseRemoved)) {
DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
padapter->bup, padapter->bDriverStopped,
padapter->bSurpriseRemoved);
goto error_exit;
}
/* system suspend */
LeaveAllPowerSaveMode(padapter);
DBG_88E("==> rtw_hw_suspend\n");
_enter_pwrlock(&pwrpriv->lock);
pwrpriv->bips_processing = true;
/* s1. */
if (pnetdev) {
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
}
/* s2. */
rtw_disassoc_cmd(padapter, 500, false);
/* s2-2. indicate disconnect to os */
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
_clr_fwstate_(pmlmepriv, _FW_LINKED);
rtw_led_control(padapter, LED_CTL_NO_LINK);
rtw_os_indicate_disconnect(padapter);
/* donnot enqueue cmd */
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
}
}
/* s2-3. */
rtw_free_assoc_resources(padapter);
/* s2-4. */
rtw_free_network_queue(padapter, true);
rtw_ips_dev_unload(padapter);
pwrpriv->rf_pwrstate = rf_off;
pwrpriv->bips_processing = false;
_exit_pwrlock(&pwrpriv->lock);
return 0;
error_exit:
DBG_88E("%s, failed\n", __func__);
return -1;
}
