* 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 _RTW_PWRCTRL_C_
#include <drv_types.h>
+#include <rtw_debug.h>
#include <hal_data.h>
#include <linux/jiffies.h>
-void _ips_enter(_adapter * padapter)
+void _ips_enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->bips_processing = true;
- // syn ips_mode with request
+ /* 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);
+ DBG_871X("==>ips_enter cnts:%d\n", pwrpriv->ips_enter_cnts);
- if(rf_off == pwrpriv->change_rfpwrstate )
+ 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)
+ if (pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = true;
rtw_ips_pwr_down(padapter);
}
-void ips_enter(_adapter * padapter)
+void ips_enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
up(&pwrpriv->lock);
}
-int _ips_leave(_adapter * padapter)
+int _ips_leave(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
int result = _SUCCESS;
- if((pwrpriv->rf_pwrstate == rf_off) &&(!pwrpriv->bips_processing))
+ if ((pwrpriv->rf_pwrstate == rf_off) && (!pwrpriv->bips_processing))
{
pwrpriv->bips_processing = true;
pwrpriv->change_rfpwrstate = rf_on;
pwrpriv->ips_leave_cnts++;
- DBG_871X("==>ips_leave cnts:%d\n",pwrpriv->ips_leave_cnts);
+ DBG_871X("==>ips_leave cnts:%d\n", pwrpriv->ips_leave_cnts);
if ((result = rtw_ips_pwr_up(padapter)) == _SUCCESS) {
pwrpriv->rf_pwrstate = rf_on;
}
DBG_871X_LEVEL(_drv_always_, "nolinked power save leave\n");
- DBG_871X("==> ips_leave.....LED(0x%08x)...\n",rtw_read32(padapter,0x4c));
+ DBG_871X("==> ips_leave.....LED(0x%08x)...\n", rtw_read32(padapter, 0x4c));
pwrpriv->bips_processing = false;
pwrpriv->bkeepfwalive = false;
return result;
}
-int ips_leave(_adapter * padapter)
+int ips_leave(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
- struct dvobj_priv *psdpriv = padapter->dvobj;
- struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
int ret;
- if(!is_primary_adapter(padapter))
+ if (!is_primary_adapter(padapter))
return _SUCCESS;
down(&pwrpriv->lock);
return ret;
}
-static bool rtw_pwr_unassociated_idle(_adapter *adapter)
+static bool rtw_pwr_unassociated_idle(struct adapter *adapter)
{
- _adapter *buddy = adapter->pbuddy_adapter;
+ struct adapter *buddy = adapter->pbuddy_adapter;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
bool ret = false;
- if (adapter_to_pwrctl(adapter)->bpower_saving ==true ) {
- //DBG_871X("%s: already in LPS or IPS mode\n", __func__);
+ if (adapter_to_pwrctl(adapter)->bpower_saving ==true) {
+ /* DBG_871X("%s: already in LPS or IPS mode\n", __func__); */
goto exit;
}
if (time_before(jiffies, adapter_to_pwrctl(adapter)->ips_deny_time)) {
- //DBG_871X("%s ips_deny_time\n", __func__);
+ /* DBG_871X("%s ips_deny_time\n", __func__); */
goto exit;
}
/*
* ATTENTION:
- * rtw_ps_processor() doesn't handle LPS.
+ *rtw_ps_processor() doesn't handle LPS.
*/
-void rtw_ps_processor(_adapter*padapter)
+void rtw_ps_processor(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
- struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
u32 ps_deny = 0;
up(&adapter_to_pwrctl(padapter)->lock);
if (ps_deny != 0)
{
- DBG_871X(FUNC_ADPT_FMT ": ps_deny=0x%08X, skip power save!\n",
+ DBG_871X(FUNC_ADPT_FMT ": ps_deny = 0x%08X, skip power save!\n",
FUNC_ADPT_ARG(padapter), ps_deny);
goto exit;
}
- if(pwrpriv->bInSuspend == true){//system suspend or autosuspend
+ if (pwrpriv->bInSuspend == true) {/* system suspend or autosuspend */
pdbgpriv->dbg_ps_insuspend_cnt++;
- DBG_871X("%s, pwrpriv->bInSuspend == true ignore this process\n",__FUNCTION__);
+ DBG_871X("%s, pwrpriv->bInSuspend == true ignore this process\n", __func__);
return;
}
if (rtw_pwr_unassociated_idle(padapter) == false)
goto exit;
- if((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts%4)==0))
+ if ((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts%4) == 0))
{
- DBG_871X("==>%s .fw_state(%x)\n",__FUNCTION__,get_fwstate(pmlmepriv));
+ DBG_871X("==>%s\n", __func__);
pwrpriv->change_rfpwrstate = rf_off;
{
ips_enter(padapter);
void pwr_state_check_handler(RTW_TIMER_HDL_ARGS);
void pwr_state_check_handler(RTW_TIMER_HDL_ARGS)
{
- _adapter *padapter = (_adapter *)FunctionContext;
+ struct adapter *padapter = (struct adapter *)FunctionContext;
rtw_ps_cmd(padapter);
}
-void traffic_check_for_leave_lps(PADAPTER padapter, u8 tx, u32 tx_packets)
+void traffic_check_for_leave_lps(struct adapter *padapter, u8 tx, u32 tx_packets)
{
static unsigned long start_time = 0;
static u32 xmit_cnt = 0;
- u8 bLeaveLPS = false;
- struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+ u8 bLeaveLPS = false;
+ struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
- if(tx) //from tx
+ if (tx) /* from tx */
{
xmit_cnt += tx_packets;
- if (start_time== 0)
- start_time= jiffies;
+ if (start_time == 0)
+ start_time = jiffies;
- if (jiffies_to_msecs(jiffies - start_time) > 2000) // 2 sec == watch dog timer
+ if (jiffies_to_msecs(jiffies - start_time) > 2000) /* 2 sec == watch dog timer */
{
- if(xmit_cnt > 8)
+ if (xmit_cnt > 8)
{
if ((adapter_to_pwrctl(padapter)->bLeisurePs)
&& (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
}
}
- start_time= jiffies;
+ start_time = jiffies;
xmit_cnt = 0;
}
}
- else // from rx path
+ else /* from rx path */
{
- if(pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4/*2*/)
+ if (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4/*2*/)
{
if ((adapter_to_pwrctl(padapter)->bLeisurePs)
&& (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
}
}
- if(bLeaveLPS)
+ if (bLeaveLPS)
{
- //DBG_871X("leave lps via %s, Tx = %d, Rx = %d \n", tx?"Tx":"Rx", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod,pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod);
- //rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1);
+ /* DBG_871X("leave lps via %s, Tx = %d, Rx = %d\n", tx?"Tx":"Rx", pmlmepriv->LinkDetectInfo.NumTxOkInPeriod, pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod); */
+ /* rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1); */
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, tx?0:1);
}
}
/*
* Description:
- * This function MUST be called under power lock protect
+ *This function MUST be called under power lock protect
*
* Parameters
- * padapter
- * pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
+ *padapter
+ *pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
*
*/
-void rtw_set_rpwm(PADAPTER padapter, u8 pslv)
+void rtw_set_rpwm(struct adapter *padapter, u8 pslv)
{
- u8 rpwm;
+ u8 rpwm;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 cpwm_orig;
- struct dvobj_priv *psdpriv = padapter->dvobj;
- struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
-_func_enter_;
pslv = PS_STATE(pslv);
if (pwrpriv->brpwmtimeout == true)
{
- DBG_871X("%s: RPWM timeout, force to set RPWM(0x%02X) again!\n", __FUNCTION__, pslv);
+ DBG_871X("%s: RPWM timeout, force to set RPWM(0x%02X) again!\n", __func__, pslv);
}
else
{
- if ( (pwrpriv->rpwm == pslv)
- || ((pwrpriv->rpwm >= PS_STATE_S2)&&(pslv >= PS_STATE_S2)))
+ if ((pwrpriv->rpwm == pslv)
+ || ((pwrpriv->rpwm >= PS_STATE_S2) && (pslv >= PS_STATE_S2)))
{
- RT_TRACE(_module_rtl871x_pwrctrl_c_,_drv_err_,
- ("%s: Already set rpwm[0x%02X], new=0x%02X!\n", __FUNCTION__, pwrpriv->rpwm, pslv));
+ RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
+ ("%s: Already set rpwm[0x%02X], new = 0x%02X!\n", __func__, pwrpriv->rpwm, pslv));
return;
}
}
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
("%s: SurpriseRemoved(%d) hw_init_completed(%d)\n",
- __FUNCTION__, padapter->bSurpriseRemoved, padapter->hw_init_completed));
+ __func__, padapter->bSurpriseRemoved, padapter->hw_init_completed));
pwrpriv->cpwm = PS_STATE_S4;
if (padapter->bDriverStopped == true)
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
- ("%s: change power state(0x%02X) when DriverStopped\n", __FUNCTION__, pslv));
+ ("%s: change power state(0x%02X) when DriverStopped\n", __func__, pslv));
if (pslv < PS_STATE_S2) {
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_,
- ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __FUNCTION__, pslv));
+ ("%s: Reject to enter PS_STATE(0x%02X) lower than S2 when DriverStopped!!\n", __func__, pslv));
return;
}
}
rpwm = pslv | pwrpriv->tog;
- // only when from PS_STATE S0/S1 to S2 and higher needs ACK
+ /* only when from PS_STATE S0/S1 to S2 and higher needs ACK */
if ((pwrpriv->cpwm < PS_STATE_S2) && (pslv >= PS_STATE_S2))
rpwm |= PS_ACK;
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("rtw_set_rpwm: rpwm=0x%02x cpwm=0x%02x\n", rpwm, pwrpriv->cpwm));
+ ("rtw_set_rpwm: rpwm = 0x%02x cpwm = 0x%02x\n", rpwm, pwrpriv->cpwm));
pwrpriv->rpwm = pslv;
pwrpriv->tog += 0x80;
- // No LPS 32K, No Ack
+ /* No LPS 32K, No Ack */
if (rpwm & PS_ACK)
{
unsigned long start_time;
u8 cpwm_now;
- u8 poll_cnt=0;
+ u8 poll_cnt = 0;
start_time = jiffies;
- // polling cpwm
+ /* polling cpwm */
do {
mdelay(1);
poll_cnt++;
if (jiffies_to_msecs(jiffies - start_time) > LPS_RPWM_WAIT_MS)
{
- DBG_871X("%s: polling cpwm timeout! poll_cnt=%d, cpwm_orig=%02x, cpwm_now=%02x \n", __FUNCTION__,poll_cnt, cpwm_orig, cpwm_now);
+ DBG_871X("%s: polling cpwm timeout! poll_cnt =%d, cpwm_orig =%02x, cpwm_now =%02x\n", __func__, poll_cnt, cpwm_orig, cpwm_now);
_set_timer(&pwrpriv->pwr_rpwm_timer, 1);
break;
}
{
pwrpriv->cpwm = pslv;
}
-
-_func_exit_;
}
-static u8 PS_RDY_CHECK(_adapter * padapter)
+static u8 PS_RDY_CHECK(struct adapter *padapter)
{
unsigned long curr_time, delta_time;
- struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
- struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
+ struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
+ struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
- if(true == pwrpriv->bInSuspend && pwrpriv->wowlan_mode)
+ if (true == pwrpriv->bInSuspend && pwrpriv->wowlan_mode)
return true;
- else if(true == pwrpriv->bInSuspend && pwrpriv->wowlan_ap_mode)
+ else if (true == pwrpriv->bInSuspend && pwrpriv->wowlan_ap_mode)
return true;
else if (true == pwrpriv->bInSuspend)
return false;
#else
- if(true == pwrpriv->bInSuspend )
+ if (true == pwrpriv->bInSuspend)
return false;
#endif
delta_time = curr_time -pwrpriv->DelayLPSLastTimeStamp;
- if(delta_time < LPS_DELAY_TIME)
+ if (delta_time < LPS_DELAY_TIME)
{
return false;
}
)
return false;
- if( (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) && (padapter->securitypriv.binstallGrpkey == false) )
+ if ((padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) && (padapter->securitypriv.binstallGrpkey == false))
{
DBG_871X("Group handshake still in progress !!!\n");
return false;
return true;
}
-void rtw_set_ps_mode(PADAPTER padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode, const char *msg)
+void rtw_set_ps_mode(struct adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode, const char *msg)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
- struct dvobj_priv *psdpriv = padapter->dvobj;
- struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
-
-_func_enter_;
+#if defined(CONFIG_WOWLAN) || defined(CONFIG_AP_WOWLAN)
+ struct debug_priv *pdbgpriv = &padapter->dvobj->drv_dbg;
+#endif
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("%s: PowerMode=%d Smart_PS=%d\n",
- __FUNCTION__, ps_mode, smart_ps));
+ ("%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));
+ if (ps_mode > PM_Card_Disable) {
+ RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_err_, ("ps_mode:%d error\n", ps_mode));
return;
}
down(&pwrpriv->lock);
- //if(pwrpriv->pwr_mode == PS_MODE_ACTIVE)
- if(ps_mode == PS_MODE_ACTIVE)
+ /* if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) */
+ if (ps_mode == PS_MODE_ACTIVE)
{
if (1
&& (((rtw_btcoex_IsBtControlLps(padapter) == false)
start_time = jiffies;
do {
rtw_hal_get_hwreg(padapter, HW_VAR_SYS_CLKR, &val8);
- if (!(val8 & BIT(4))){ //0x08 bit4 =1 --> in 32k, bit4 = 0 --> leave 32k
+ if (!(val8 & BIT(4))) { /* 0x08 bit4 = 1 --> in 32k, bit4 = 0 --> leave 32k */
pwrpriv->cpwm = PS_STATE_S4;
break;
}
if (jiffies_to_msecs(jiffies - start_time) > delay_ms)
{
DBG_871X("%s: Wait for FW 32K leave more than %u ms!!!\n",
- __FUNCTION__, delay_ms);
+ __func__, delay_ms);
pdbgpriv->dbg_wow_leave_ps_fail_cnt++;
break;
}
}
up(&pwrpriv->lock);
-
-_func_exit_;
}
/*
* Return:
- * 0: Leave OK
- * -1: Timeout
- * -2: Other error
+ *0: Leave OK
+ *-1: Timeout
+ *-2: Other error
*/
-s32 LPS_RF_ON_check(PADAPTER padapter, u32 delay_ms)
+s32 LPS_RF_ON_check(struct adapter *padapter, u32 delay_ms)
{
unsigned long start_time;
u8 bAwake = false;
if (true == padapter->bSurpriseRemoved)
{
err = -2;
- DBG_871X("%s: device surprise removed!!\n", __FUNCTION__);
+ DBG_871X("%s: device surprise removed!!\n", __func__);
break;
}
if (jiffies_to_msecs(jiffies - start_time) > delay_ms)
{
err = -1;
- DBG_871X("%s: Wait for FW LPS leave more than %u ms!!!\n", __FUNCTION__, delay_ms);
+ DBG_871X("%s: Wait for FW LPS leave more than %u ms!!!\n", __func__, delay_ms);
break;
}
msleep(1);
return err;
}
-//
-// Description:
-// Enter the leisure power save mode.
-//
-void LPS_Enter(PADAPTER padapter, const char *msg)
+/* */
+/* Description: */
+/* Enter the leisure power save mode. */
+/* */
+void LPS_Enter(struct adapter *padapter, const char *msg)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
- struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
- struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
- _adapter *buddy = padapter->pbuddy_adapter;
+ struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
int n_assoc_iface = 0;
- int i;
char buf[32] = {0};
-_func_enter_;
-
-// DBG_871X("+LeisurePSEnter\n");
-
if (rtw_btcoex_IsBtControlLps(padapter) == true)
return;
/* Skip lps enter request if number of assocated adapters is not 1 */
- for (i = 0; i < dvobj->iface_nums; i++) {
- if (check_fwstate(&(dvobj->padapters[i]->mlmepriv), WIFI_ASOC_STATE))
- n_assoc_iface++;
- }
+ if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
+ n_assoc_iface++;
if (n_assoc_iface != 1)
return;
if (get_iface_type(padapter) != IFACE_PORT0)
return;
- for (i = 0; i < dvobj->iface_nums; i++) {
- if (PS_RDY_CHECK(dvobj->padapters[i]) == false)
+ if (PS_RDY_CHECK(dvobj->padapters) == false)
return;
- }
- if (pwrpriv->bLeisurePs)
- {
- // Idle for a while if we connect to AP a while ago.
- if (pwrpriv->LpsIdleCount >= 2) // 4 Sec
+ if (pwrpriv->bLeisurePs) {
+ /* Idle for a while if we connect to AP a while ago. */
+ if (pwrpriv->LpsIdleCount >= 2) /* 4 Sec */
{
- if(pwrpriv->pwr_mode == PS_MODE_ACTIVE)
+ if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
{
sprintf(buf, "WIFI-%s", msg);
pwrpriv->bpower_saving = true;
pwrpriv->LpsIdleCount++;
}
-// DBG_871X("-LeisurePSEnter\n");
-
-_func_exit_;
+/* DBG_871X("-LeisurePSEnter\n"); */
}
-//
-// Description:
-// Leave the leisure power save mode.
-//
-void LPS_Leave(PADAPTER padapter, const char *msg)
+/* */
+/* Description: */
+/* Leave the leisure power save mode. */
+/* */
+void LPS_Leave(struct adapter *padapter, const char *msg)
{
#define LPS_LEAVE_TIMEOUT_MS 100
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
- struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
- u32 start_time;
- u8 bAwake = false;
+ struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
char buf[32] = {0};
- struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
-
-_func_enter_;
-// DBG_871X("+LeisurePSLeave\n");
+/* DBG_871X("+LeisurePSLeave\n"); */
if (rtw_btcoex_IsBtControlLps(padapter) == true)
return;
if (pwrpriv->bLeisurePs)
{
- if(pwrpriv->pwr_mode != PS_MODE_ACTIVE)
+ if (pwrpriv->pwr_mode != PS_MODE_ACTIVE)
{
sprintf(buf, "WIFI-%s", msg);
rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, buf);
- if(pwrpriv->pwr_mode == PS_MODE_ACTIVE)
+ if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
LPS_RF_ON_check(padapter, LPS_LEAVE_TIMEOUT_MS);
}
}
pwrpriv->bpower_saving = false;
-// DBG_871X("-LeisurePSLeave\n");
+/* DBG_871X("-LeisurePSLeave\n"); */
-_func_exit_;
}
-void LeaveAllPowerSaveModeDirect(PADAPTER Adapter)
+void LeaveAllPowerSaveModeDirect(struct adapter * Adapter)
{
- PADAPTER pri_padapter = GET_PRIMARY_ADAPTER(Adapter);
- struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
+ struct adapter * pri_padapter = GET_PRIMARY_ADAPTER(Adapter);
+ struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(Adapter);
- struct dvobj_priv *psdpriv = Adapter->dvobj;
- struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
- u8 cpwm_orig, cpwm_now;
- unsigned long start_time;
-
-_func_enter_;
- DBG_871X("%s.....\n",__FUNCTION__);
+ DBG_871X("%s.....\n", __func__);
if (true == Adapter->bSurpriseRemoved)
{
- DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved=%d Skip!\n",
+ DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved =%d Skip!\n",
FUNC_ADPT_ARG(Adapter), Adapter->bSurpriseRemoved);
return;
}
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true))
- { //connect
+ { /* connect */
- if(pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
- DBG_871X("%s: Driver Already Leave LPS\n",__FUNCTION__);
+ if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
+ DBG_871X("%s: Driver Already Leave LPS\n", __func__);
return;
}
}
else
{
- if(pwrpriv->rf_pwrstate== rf_off)
+ if (pwrpriv->rf_pwrstate == rf_off)
{
- if(false == ips_leave(pri_padapter))
+ if (false == ips_leave(pri_padapter))
{
DBG_871X("======> ips_leave fail.............\n");
}
}
}
-
-_func_exit_;
}
-//
-// Description: Leave all power save mode: LPS, FwLPS, IPS if needed.
-// Move code to function by tynli. 2010.03.26.
-//
-void LeaveAllPowerSaveMode(IN PADAPTER Adapter)
+/* */
+/* Description: Leave all power save mode: LPS, FwLPS, IPS if needed. */
+/* Move code to function by tynli. 2010.03.26. */
+/* */
+void LeaveAllPowerSaveMode(struct adapter * Adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(Adapter);
- struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
- u8 enqueue = 0;
+ u8 enqueue = 0;
int n_assoc_iface = 0;
- int i;
-
-_func_enter_;
- //DBG_871X("%s.....\n",__FUNCTION__);
-
- if (false == Adapter->bup)
- {
- DBG_871X(FUNC_ADPT_FMT ": bup=%d Skip!\n",
+ if (!Adapter->bup) {
+ DBG_871X(FUNC_ADPT_FMT ": bup =%d Skip!\n",
FUNC_ADPT_ARG(Adapter), Adapter->bup);
return;
}
- if (true == Adapter->bSurpriseRemoved)
- {
- DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved=%d Skip!\n",
+ if (Adapter->bSurpriseRemoved) {
+ DBG_871X(FUNC_ADPT_FMT ": bSurpriseRemoved =%d Skip!\n",
FUNC_ADPT_ARG(Adapter), Adapter->bSurpriseRemoved);
return;
}
- for (i = 0; i < dvobj->iface_nums; i++) {
- if (check_fwstate(&(dvobj->padapters[i]->mlmepriv), WIFI_ASOC_STATE))
- n_assoc_iface++;
- }
+ if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
+ n_assoc_iface++;
- if (n_assoc_iface)
- { //connect
+ if (n_assoc_iface) { /* connect */
enqueue = 1;
rtw_lps_ctrl_wk_cmd(Adapter, LPS_CTRL_LEAVE, enqueue);
LPS_Leave_check(Adapter);
- }
- else
- {
- if(adapter_to_pwrctl(Adapter)->rf_pwrstate== rf_off)
- {
- if(false == ips_leave(Adapter))
- {
+ } else {
+ if (adapter_to_pwrctl(Adapter)->rf_pwrstate == rf_off) {
+ if (false == ips_leave(Adapter))
DBG_871X("======> ips_leave fail.............\n");
- }
}
}
-
-_func_exit_;
}
void LPS_Leave_check(
- PADAPTER padapter)
+ struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv;
unsigned long start_time;
- u8 bReady;
-
-_func_enter_;
+ u8 bReady;
pwrpriv = adapter_to_pwrctl(padapter);
yield();
- while(1)
+ while (1)
{
down(&pwrpriv->lock);
up(&pwrpriv->lock);
- if(true == bReady)
+ if (true == bReady)
break;
- if(jiffies_to_msecs(jiffies - start_time)>100)
+ if (jiffies_to_msecs(jiffies - start_time)>100)
{
DBG_871X("Wait for cpwm event than 100 ms!!!\n");
break;
}
msleep(1);
}
-
-_func_exit_;
}
/*
* using to update cpwn of drv; and drv willl make a decision to up or down pwr level
*/
void cpwm_int_hdl(
- PADAPTER padapter,
+ struct adapter *padapter,
struct reportpwrstate_parm *preportpwrstate)
{
struct pwrctrl_priv *pwrpriv;
-_func_enter_;
-
pwrpriv = adapter_to_pwrctl(padapter);
down(&pwrpriv->lock);
if (pwrpriv->rpwm < PS_STATE_S2)
{
- DBG_871X("%s: Redundant CPWM Int. RPWM=0x%02X CPWM=0x%02x\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
+ DBG_871X("%s: Redundant CPWM Int. RPWM = 0x%02X CPWM = 0x%02x\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
up(&pwrpriv->lock);
goto exit;
}
exit:
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("cpwm_int_hdl: cpwm=0x%02x\n", pwrpriv->cpwm));
-
-_func_exit_;
+ ("cpwm_int_hdl: cpwm = 0x%02x\n", pwrpriv->cpwm));
}
static void cpwm_event_callback(struct work_struct *work)
{
struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, cpwm_event);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
- _adapter *adapter = dvobj->if1;
+ struct adapter *adapter = dvobj->if1;
struct reportpwrstate_parm report;
- //DBG_871X("%s\n",__FUNCTION__);
+ /* DBG_871X("%s\n", __func__); */
report.state = PS_STATE_S2;
cpwm_int_hdl(adapter, &report);
static void rpwmtimeout_workitem_callback(struct work_struct *work)
{
- PADAPTER padapter;
+ struct adapter *padapter;
struct dvobj_priv *dvobj;
struct pwrctrl_priv *pwrpriv;
pwrpriv = container_of(work, struct pwrctrl_priv, rpwmtimeoutwi);
dvobj = pwrctl_to_dvobj(pwrpriv);
padapter = dvobj->if1;
-// DBG_871X("+%s: rpwm=0x%02X cpwm=0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
+/* DBG_871X("+%s: rpwm = 0x%02X cpwm = 0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm); */
down(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
{
- DBG_871X("%s: rpwm=0x%02X cpwm=0x%02X CPWM done!\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
+ DBG_871X("%s: rpwm = 0x%02X cpwm = 0x%02X CPWM done!\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
goto exit;
}
up(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
{
- DBG_871X("%s: cpwm=%d, nothing to do!\n", __func__, pwrpriv->cpwm);
+ DBG_871X("%s: cpwm =%d, nothing to do!\n", __func__, pwrpriv->cpwm);
goto exit;
}
pwrpriv->brpwmtimeout = true;
*/
static void pwr_rpwm_timeout_handler(void *FunctionContext)
{
- PADAPTER padapter;
+ struct adapter *padapter;
struct pwrctrl_priv *pwrpriv;
- padapter = (PADAPTER)FunctionContext;
+ padapter = (struct adapter *)FunctionContext;
pwrpriv = adapter_to_pwrctl(padapter);
- DBG_871X("+%s: rpwm=0x%02X cpwm=0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
+ DBG_871X("+%s: rpwm = 0x%02X cpwm = 0x%02X\n", __func__, pwrpriv->rpwm, pwrpriv->cpwm);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
{
- DBG_871X("+%s: cpwm=%d, nothing to do!\n", __func__, pwrpriv->cpwm);
+ DBG_871X("+%s: cpwm =%d, nothing to do!\n", __func__, pwrpriv->cpwm);
return;
}
/*
* Description:
- * Check if the fw_pwrstate is okay for I/O.
- * If not (cpwm is less than S2), then the sub-routine
- * will raise the cpwm to be greater than or equal to S2.
+ *Check if the fw_pwrstate is okay for I/O.
+ *If not (cpwm is less than S2), then the sub-routine
+ *will raise the cpwm to be greater than or equal to S2.
*
- * Calling Context: Passive
+ *Calling Context: Passive
*
- * Constraint:
- * 1. this function will request pwrctrl->lock
+ *Constraint:
+ * 1. this function will request pwrctrl->lock
*
* Return Value:
- * _SUCCESS hardware is ready for I/O
- * _FAIL can't I/O right now
+ *_SUCCESS hardware is ready for I/O
+ *_FAIL can't I/O right now
*/
-s32 rtw_register_task_alive(PADAPTER padapter, u32 task)
+s32 rtw_register_task_alive(struct adapter *padapter, u32 task)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
if (pwrctrl->bFwCurrentInPSMode == true)
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("%s: task=0x%x cpwm=0x%02x alives=0x%08x\n",
- __FUNCTION__, task, pwrctrl->cpwm, pwrctrl->alives));
+ ("%s: task = 0x%x cpwm = 0x%02x alives = 0x%08x\n",
+ __func__, task, pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm < pslv)
{
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
-
-_func_exit_;
-
return res;
}
/*
* Description:
- * If task is done, call this func. to power down firmware again.
+ *If task is done, call this func. to power down firmware again.
*
- * Constraint:
- * 1. this function will request pwrctrl->lock
+ *Constraint:
+ * 1. this function will request pwrctrl->lock
*
* Return Value:
- * none
+ *none
*/
-void rtw_unregister_task_alive(PADAPTER padapter, u32 task)
+void rtw_unregister_task_alive(struct adapter *padapter, u32 task)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
&& (pwrctrl->bFwCurrentInPSMode == true))
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("%s: cpwm=0x%02x alives=0x%08x\n",
- __FUNCTION__, pwrctrl->cpwm, pwrctrl->alives));
+ ("%s: cpwm = 0x%02x alives = 0x%08x\n",
+ __func__, pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm > pslv)
{
}
up(&pwrctrl->lock);
-
-_func_exit_;
}
/*
* Calling Context: Passive
*
* Return Value:
- * _SUCCESS rtw_xmit_thread can write fifo/txcmd afterwards.
- * _FAIL rtw_xmit_thread can not do anything.
+ * _SUCCESS rtw_xmit_thread can write fifo/txcmd afterwards.
+ * _FAIL rtw_xmit_thread can not do anything.
*/
-s32 rtw_register_tx_alive(PADAPTER padapter)
+s32 rtw_register_tx_alive(struct adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
if (pwrctrl->bFwCurrentInPSMode == true)
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("rtw_register_tx_alive: cpwm=0x%02x alives=0x%08x\n",
+ ("rtw_register_tx_alive: cpwm = 0x%02x alives = 0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm < pslv)
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
-
-_func_exit_;
-
return res;
}
* Calling Context: Passive
*
* Return Value:
- * _SUCCESS rtw_cmd_thread can issue cmds to firmware afterwards.
- * _FAIL rtw_cmd_thread can not do anything.
+ *_SUCCESS rtw_cmd_thread can issue cmds to firmware afterwards.
+ *_FAIL rtw_cmd_thread can not do anything.
*/
-s32 rtw_register_cmd_alive(PADAPTER padapter)
+s32 rtw_register_cmd_alive(struct adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
if (pwrctrl->bFwCurrentInPSMode == true)
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_info_,
- ("rtw_register_cmd_alive: cpwm=0x%02x alives=0x%08x\n",
+ ("rtw_register_cmd_alive: cpwm = 0x%02x alives = 0x%08x\n",
pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm < pslv)
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
}
-
-_func_exit_;
-
return res;
}
* No more pkts for TX,
* Then driver shall call this fun. to power down firmware again.
*/
-void rtw_unregister_tx_alive(PADAPTER padapter)
+void rtw_unregister_tx_alive(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
&& (pwrctrl->bFwCurrentInPSMode == true))
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
- ("%s: cpwm=0x%02x alives=0x%08x\n",
- __FUNCTION__, pwrctrl->cpwm, pwrctrl->alives));
+ ("%s: cpwm = 0x%02x alives = 0x%08x\n",
+ __func__, pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm > pslv)
{
}
up(&pwrctrl->lock);
-
-_func_exit_;
}
/*
* and no more command to do,
* then driver shall call this fun. to power down firmware again.
*/
-void rtw_unregister_cmd_alive(PADAPTER padapter)
+void rtw_unregister_cmd_alive(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
-_func_enter_;
-
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
&& (pwrctrl->bFwCurrentInPSMode == true))
{
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_info_,
- ("%s: cpwm=0x%02x alives=0x%08x\n",
- __FUNCTION__, pwrctrl->cpwm, pwrctrl->alives));
+ ("%s: cpwm = 0x%02x alives = 0x%08x\n",
+ __func__, pwrctrl->cpwm, pwrctrl->alives));
if (pwrctrl->cpwm > pslv)
{
}
up(&pwrctrl->lock);
-
-_func_exit_;
}
-void rtw_init_pwrctrl_priv(PADAPTER padapter)
+void rtw_init_pwrctrl_priv(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
-_func_enter_;
-
sema_init(&pwrctrlpriv->lock, 1);
sema_init(&pwrctrlpriv->check_32k_lock, 1);
pwrctrlpriv->rf_pwrstate = rf_on;
- pwrctrlpriv->ips_enter_cnts=0;
- pwrctrlpriv->ips_leave_cnts=0;
+ pwrctrlpriv->ips_enter_cnts = 0;
+ pwrctrlpriv->ips_leave_cnts = 0;
pwrctrlpriv->bips_processing = false;
pwrctrlpriv->ips_mode = padapter->registrypriv.ips_mode;
pwrctrlpriv->bkeepfwalive = false;
pwrctrlpriv->LpsIdleCount = 0;
- //pwrctrlpriv->FWCtrlPSMode =padapter->registrypriv.power_mgnt;// PS_MODE_MIN;
- if (padapter->registrypriv.mp_mode == 1)
- pwrctrlpriv->power_mgnt =PS_MODE_ACTIVE ;
- else
- pwrctrlpriv->power_mgnt =padapter->registrypriv.power_mgnt;// PS_MODE_MIN;
+ pwrctrlpriv->power_mgnt =padapter->registrypriv.power_mgnt;/* PS_MODE_MIN; */
pwrctrlpriv->bLeisurePs = (PS_MODE_ACTIVE != pwrctrlpriv->power_mgnt)?true:false;
pwrctrlpriv->bFwCurrentInPSMode = false;
pwrctrlpriv->pno_ssid_list = NULL;
pwrctrlpriv->pno_in_resume = true;
#endif
-
-_func_exit_;
-
}
-void rtw_free_pwrctrl_priv(PADAPTER adapter)
+void rtw_free_pwrctrl_priv(struct adapter * adapter)
{
- struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(adapter);
-
-_func_enter_;
-
- //memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv));
+ /* memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv)); */
#ifdef CONFIG_PNO_SUPPORT
if (pwrctrlpriv->pnlo_info != NULL)
if (pwrctrlpriv->pno_ssid_list != NULL)
printk("****** pno_ssid_list memory leak********\n");
#endif
-
-_func_exit_;
}
-inline void rtw_set_ips_deny(_adapter *padapter, u32 ms)
+inline void rtw_set_ips_deny(struct adapter *padapter, u32 ms)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ms);
/*
* rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
-* @adapter: pointer to _adapter structure
+* @adapter: pointer to struct adapter structure
* @ips_deffer_ms: the ms wiil prevent from falling into IPS after wakeup
* Return _SUCCESS or _FAIL
*/
-int _rtw_pwr_wakeup(_adapter *padapter, u32 ips_deffer_ms, const char *caller)
+int _rtw_pwr_wakeup(struct adapter *padapter, u32 ips_deffer_ms, const char *caller)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
struct mlme_priv *pmlmepriv;
int ret = _SUCCESS;
- int i;
unsigned long start = jiffies;
unsigned long deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
DBG_871X("%s wait bInSuspend done\n", __func__);
}
- //System suspend is not allowed to wakeup
- if((pwrpriv->bInternalAutoSuspend == false) && (true == pwrpriv->bInSuspend )){
+ /* System suspend is not allowed to wakeup */
+ if ((pwrpriv->bInternalAutoSuspend == false) && (true == pwrpriv->bInSuspend)) {
ret = _FAIL;
goto exit;
}
- //block???
- if((pwrpriv->bInternalAutoSuspend == true) && (padapter->net_closed == true)) {
+ /* block??? */
+ if ((pwrpriv->bInternalAutoSuspend == true) && (padapter->net_closed == true)) {
ret = _FAIL;
goto exit;
}
- //I think this should be check in IPS, LPS, autosuspend functions...
+ /* I think this should be check in IPS, LPS, autosuspend functions... */
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
{
ret = _SUCCESS;
goto exit;
}
- if(rf_off == pwrpriv->rf_pwrstate )
+ if (rf_off == pwrpriv->rf_pwrstate)
{
{
- DBG_8192C("%s call ips_leave....\n",__FUNCTION__);
- if(_FAIL == ips_leave(padapter))
+ DBG_8192C("%s call ips_leave....\n", __func__);
+ if (_FAIL == ips_leave(padapter))
{
DBG_8192C("======> ips_leave fail.............\n");
ret = _FAIL;
}
}
- //TODO: the following checking need to be merged...
- if(padapter->bDriverStopped
+ /* TODO: the following checking need to be merged... */
+ if (padapter->bDriverStopped
|| !padapter->bup
|| !padapter->hw_init_completed
- ){
- DBG_8192C("%s: bDriverStopped=%d, bup=%d, hw_init_completed=%u\n"
+ ) {
+ DBG_8192C("%s: bDriverStopped =%d, bup =%d, hw_init_completed =%u\n"
, caller
, padapter->bDriverStopped
, padapter->bup
, padapter->hw_init_completed);
- ret= false;
+ ret = false;
goto exit;
}
}
-int rtw_pm_set_lps(_adapter *padapter, u8 mode)
+int rtw_pm_set_lps(struct adapter *padapter, u8 mode)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
- if ( mode < PS_MODE_NUM )
+ if (mode < PS_MODE_NUM)
{
- if(pwrctrlpriv->power_mgnt !=mode)
+ if (pwrctrlpriv->power_mgnt !=mode)
{
- if(PS_MODE_ACTIVE == mode)
+ if (PS_MODE_ACTIVE == mode)
{
LeaveAllPowerSaveMode(padapter);
}
return ret;
}
-int rtw_pm_set_ips(_adapter *padapter, u8 mode)
+int rtw_pm_set_ips(struct adapter *padapter, u8 mode)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
- if( mode == IPS_NORMAL || mode == IPS_LEVEL_2 ) {
+ if (mode == IPS_NORMAL || mode == IPS_LEVEL_2) {
rtw_ips_mode_req(pwrctrlpriv, mode);
- DBG_871X("%s %s\n", __FUNCTION__, mode == IPS_NORMAL?"IPS_NORMAL":"IPS_LEVEL_2");
+ DBG_871X("%s %s\n", __func__, mode == IPS_NORMAL?"IPS_NORMAL":"IPS_LEVEL_2");
return 0;
}
- else if(mode ==IPS_NONE){
+ else if (mode ==IPS_NONE) {
rtw_ips_mode_req(pwrctrlpriv, mode);
- DBG_871X("%s %s\n", __FUNCTION__, "IPS_NONE");
- if((padapter->bSurpriseRemoved ==0)&&(_FAIL == rtw_pwr_wakeup(padapter)) )
+ DBG_871X("%s %s\n", __func__, "IPS_NONE");
+ if ((padapter->bSurpriseRemoved == 0) && (_FAIL == rtw_pwr_wakeup(padapter)))
return -EFAULT;
}
else {
/*
* ATTENTION:
- * This function will request pwrctrl LOCK!
+ *This function will request pwrctrl LOCK!
*/
-void rtw_ps_deny(PADAPTER padapter, PS_DENY_REASON reason)
+void rtw_ps_deny(struct adapter *padapter, enum PS_DENY_REASON reason)
{
struct pwrctrl_priv *pwrpriv;
- s32 ret;
-
-// DBG_871X("+" FUNC_ADPT_FMT ": Request PS deny for %d (0x%08X)\n",
-// FUNC_ADPT_ARG(padapter), reason, BIT(reason));
+/* DBG_871X("+" FUNC_ADPT_FMT ": Request PS deny for %d (0x%08X)\n", */
+/* FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->ps_deny |= BIT(reason);
up(&pwrpriv->lock);
-// DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n",
-// FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny);
+/* DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n", */
+/* FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
}
/*
* ATTENTION:
- * This function will request pwrctrl LOCK!
+ *This function will request pwrctrl LOCK!
*/
-void rtw_ps_deny_cancel(PADAPTER padapter, PS_DENY_REASON reason)
+void rtw_ps_deny_cancel(struct adapter *padapter, enum PS_DENY_REASON reason)
{
struct pwrctrl_priv *pwrpriv;
-// DBG_871X("+" FUNC_ADPT_FMT ": Cancel PS deny for %d(0x%08X)\n",
-// FUNC_ADPT_ARG(padapter), reason, BIT(reason));
+/* DBG_871X("+" FUNC_ADPT_FMT ": Cancel PS deny for %d(0x%08X)\n", */
+/* FUNC_ADPT_ARG(padapter), reason, BIT(reason)); */
pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->ps_deny &= ~BIT(reason);
up(&pwrpriv->lock);
-// DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n",
-// FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny);
+/* DBG_871X("-" FUNC_ADPT_FMT ": Now PS deny for 0x%08X\n", */
+/* FUNC_ADPT_ARG(padapter), pwrpriv->ps_deny); */
}
/*
* ATTENTION:
- * Before calling this function pwrctrl lock should be occupied already,
- * otherwise it may return incorrect value.
+ *Before calling this function pwrctrl lock should be occupied already,
+ *otherwise it may return incorrect value.
*/
-u32 rtw_ps_deny_get(PADAPTER padapter)
+u32 rtw_ps_deny_get(struct adapter *padapter)
{
u32 deny;
OSDN Git Service
