/**
* @brief Perform hs related activities on receving the power up interrupt
*
* @param pmadapter A pointer to the adapter structure
* @return N/A
*/
t_void
wlan_process_hs_config(pmlan_adapter pmadapter)
{
PRINTM(MINFO,
"Auto Cancelling host sleep since there is some interrupt from the firmware\n");
wlan_pm_wakeup_card(pmadapter);
pmadapter->hs_activated = MFALSE;
pmadapter->is_hs_configured = MFALSE;
wlan_host_sleep_activated_event(wlan_get_priv(pmadapter, MLAN_BSS_TYPE_STA),
MFALSE);
return;
}
/**
* @brief The main process
*
* @param pmlan_adapter A pointer to mlan_adapter structure
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
mlan_main_process(IN t_void * pmlan_adapter)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
mlan_adapter *pmadapter = (mlan_adapter *) pmlan_adapter;
pmlan_callbacks pcb;
ENTER();
MASSERT(pmlan_adapter);
pcb = &pmadapter->callbacks;
pcb->moal_spin_lock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
/* Check if already processing */
if (pmadapter->mlan_processing) {
pmadapter->more_task_flag = MTRUE;
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
goto exit_main_proc;
} else {
pmadapter->mlan_processing = MTRUE;
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
}
process_start:
do {
pcb->moal_spin_lock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
pmadapter->more_task_flag = MFALSE;
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
/* Is MLAN shutting down or not ready? */
if ((pmadapter->hw_status == WlanHardwareStatusClosing) ||
(pmadapter->hw_status == WlanHardwareStatusNotReady))
break;
if (util_scalar_read
(pmadapter->pmoal_handle, &pmadapter->rx_pkts_queued,
pmadapter->callbacks.moal_spin_lock,
pmadapter->callbacks.moal_spin_unlock) > HIGH_RX_PENDING) {
PRINTM(MEVENT, "Pause\n");
pmadapter->delay_task_flag = MTRUE;
break;
}
/* Handle pending SDIO interrupts if any */
if (pmadapter->sdio_ireg) {
if (pmadapter->hs_activated == MTRUE)
wlan_process_hs_config(pmadapter);
wlan_process_int_status(pmadapter);
if (pmadapter->data_received && pmadapter->rx_work_flag)
wlan_recv_event(wlan_get_priv
(pmadapter, MLAN_BSS_ROLE_ANY),
MLAN_EVENT_ID_DRV_DEFER_RX_WORK,
MNULL);
}
/* Need to wake up the card ? */
if ((pmadapter->ps_state == PS_STATE_SLEEP) &&
(pmadapter->pm_wakeup_card_req &&
!pmadapter->pm_wakeup_fw_try) &&
(util_peek_list
(pmadapter->pmoal_handle, &pmadapter->cmd_pending_q,
pcb->moal_spin_lock, pcb->moal_spin_unlock)
|| !wlan_bypass_tx_list_empty(pmadapter)
|| !wlan_wmm_lists_empty(pmadapter)
)) {
wlan_pm_wakeup_card(pmadapter);
pmadapter->pm_wakeup_fw_try = MTRUE;
continue;
}
if (IS_CARD_RX_RCVD(pmadapter)) {
pmadapter->data_received = MFALSE;
if (pmadapter->hs_activated == MTRUE) {
pmadapter->is_hs_configured = MFALSE;
wlan_host_sleep_activated_event(wlan_get_priv
(pmadapter,
MLAN_BSS_ROLE_ANY),
MFALSE);
}
pmadapter->pm_wakeup_fw_try = MFALSE;
if (pmadapter->ps_state == PS_STATE_SLEEP)
pmadapter->ps_state = PS_STATE_AWAKE;
} else {
/* We have tried to wakeup the card already */
if (pmadapter->pm_wakeup_fw_try)
break;
if (pmadapter->ps_state != PS_STATE_AWAKE ||
(pmadapter->tx_lock_flag == MTRUE))
break;
if (pmadapter->scan_processing
|| pmadapter->data_sent
|| (wlan_bypass_tx_list_empty(pmadapter) &&
wlan_wmm_lists_empty(pmadapter))
|| wlan_11h_radar_detected_tx_blocked(pmadapter)
) {
if (pmadapter->cmd_sent || pmadapter->curr_cmd
||
(!util_peek_list
(pmadapter->pmoal_handle,
&pmadapter->cmd_pending_q,
pcb->moal_spin_lock,
pcb->moal_spin_unlock))) {
break;
}
}
}
/* Check for Cmd Resp */
if (pmadapter->cmd_resp_received) {
pmadapter->cmd_resp_received = MFALSE;
wlan_process_cmdresp(pmadapter);
/* call moal back when init_fw is done */
if (pmadapter->hw_status == WlanHardwareStatusInitdone) {
pmadapter->hw_status = WlanHardwareStatusReady;
wlan_init_fw_complete(pmadapter);
}
}
/* Check for event */
if (pmadapter->event_received) {
pmadapter->event_received = MFALSE;
wlan_process_event(pmadapter);
}
/* Check if we need to confirm Sleep Request received
previously */
if (pmadapter->ps_state == PS_STATE_PRE_SLEEP) {
if (!pmadapter->cmd_sent && !pmadapter->curr_cmd) {
wlan_check_ps_cond(pmadapter);
}
}
/*
* The ps_state may have been changed during processing of
* Sleep Request event.
*/
if ((pmadapter->ps_state == PS_STATE_SLEEP)
|| (pmadapter->ps_state == PS_STATE_PRE_SLEEP)
|| (pmadapter->ps_state == PS_STATE_SLEEP_CFM)
|| (pmadapter->tx_lock_flag == MTRUE)
)
continue;
if (!pmadapter->cmd_sent && !pmadapter->curr_cmd) {
if (wlan_exec_next_cmd(pmadapter) ==
MLAN_STATUS_FAILURE) {
ret = MLAN_STATUS_FAILURE;
break;
}
}
if (!pmadapter->scan_processing
&& !pmadapter->data_sent &&
!wlan_11h_radar_detected_tx_blocked(pmadapter) &&
!wlan_bypass_tx_list_empty(pmadapter)) {
PRINTM(MINFO, "mlan_send_pkt(): deq(bybass_txq)\n");
wlan_process_bypass_tx(pmadapter);
if (pmadapter->hs_activated == MTRUE) {
pmadapter->is_hs_configured = MFALSE;
wlan_host_sleep_activated_event(wlan_get_priv
(pmadapter,
MLAN_BSS_ROLE_ANY),
MFALSE);
}
}
if (!pmadapter->scan_processing
&& !pmadapter->data_sent && !wlan_wmm_lists_empty(pmadapter)
&& !wlan_11h_radar_detected_tx_blocked(pmadapter)
) {
wlan_wmm_process_tx(pmadapter);
if (pmadapter->hs_activated == MTRUE) {
pmadapter->is_hs_configured = MFALSE;
wlan_host_sleep_activated_event(wlan_get_priv
(pmadapter,
MLAN_BSS_ROLE_ANY),
MFALSE);
}
}
#ifdef STA_SUPPORT
if (pmadapter->delay_null_pkt && !pmadapter->cmd_sent &&
!pmadapter->curr_cmd && !IS_COMMAND_PENDING(pmadapter) &&
wlan_bypass_tx_list_empty(pmadapter) &&
wlan_wmm_lists_empty(pmadapter)) {
if (wlan_send_null_packet
(wlan_get_priv(pmadapter, MLAN_BSS_ROLE_STA),
MRVDRV_TxPD_POWER_MGMT_NULL_PACKET |
MRVDRV_TxPD_POWER_MGMT_LAST_PACKET)
== MLAN_STATUS_SUCCESS) {
pmadapter->delay_null_pkt = MFALSE;
}
break;
}
#endif
} while (MTRUE);
pcb->moal_spin_lock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
if (pmadapter->more_task_flag == MTRUE) {
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
goto process_start;
}
pmadapter->mlan_processing = MFALSE;
pcb->moal_spin_unlock(pmadapter->pmoal_handle,
pmadapter->pmain_proc_lock);
exit_main_proc:
if (pmadapter->hw_status == WlanHardwareStatusClosing)
mlan_shutdown_fw(pmadapter);
LEAVE();
return ret;
}
/**
* @brief This function executes next command in command
* pending queue. It will put firmware back to PS mode
* if applicable.
*
* @param pmadapter A pointer to mlan_adapter structure
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_exec_next_cmd(mlan_adapter * pmadapter)
{
mlan_private *priv = MNULL;
cmd_ctrl_node *pcmd_node = MNULL;
mlan_status ret = MLAN_STATUS_SUCCESS;
HostCmd_DS_COMMAND *pcmd;
ENTER();
/* Sanity test */
if (pmadapter == MNULL) {
PRINTM(MERROR, "EXEC_NEXT_CMD: pmadapter is MNULL\n");
ret = MLAN_STATUS_FAILURE;
goto done;
}
/* Check if already in processing */
if (pmadapter->curr_cmd) {
PRINTM(MERROR, "EXEC_NEXT_CMD: there is command in processing!\n");
ret = MLAN_STATUS_FAILURE;
goto done;
}
wlan_request_cmd_lock(pmadapter);
/* Check if any command is pending */
pcmd_node = (cmd_ctrl_node *) util_peek_list(&pmadapter->cmd_pending_q,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock);
if (pcmd_node) {
pcmd =
(HostCmd_DS_COMMAND *) (pcmd_node->cmdbuf->pbuf +
pcmd_node->cmdbuf->data_offset);
priv = pcmd_node->priv;
if (pmadapter->ps_state != PS_STATE_AWAKE) {
PRINTM(MERROR,
"Cannot send command in sleep state, this should not happen\n");
wlan_release_cmd_lock(pmadapter);
goto done;
}
util_unlink_list(&pmadapter->cmd_pending_q,
(pmlan_linked_list) pcmd_node,
pmadapter->callbacks.moal_spin_lock,
pmadapter->callbacks.moal_spin_unlock);
wlan_release_cmd_lock(pmadapter);
ret = wlan_dnld_cmd_to_fw(priv, pcmd_node);
priv = wlan_get_priv(pmadapter, MLAN_BSS_TYPE_STA);
/* Any command sent to the firmware when host is in sleep mode, should
de-configure host sleep */
/* We should skip the host sleep configuration command itself though */
if (priv &&
(pcmd->command !=
wlan_cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH))) {
if (pmadapter->hs_activated == MTRUE) {
pmadapter->is_hs_configured = MFALSE;
wlan_host_sleep_activated_event(priv, MFALSE);
}
}
goto done;
} else {
wlan_release_cmd_lock(pmadapter);
}
ret = MLAN_STATUS_SUCCESS;
done:
LEAVE();
return ret;
}
/**
* @brief This function sends sleep confirm command to firmware.
*
* @param pmadapter A pointer to mlan_adapter structure
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_dnld_sleep_confirm_cmd(mlan_adapter * pmadapter)
{
mlan_status ret = MLAN_STATUS_SUCCESS;
static t_u32 i = 0;
t_u16 cmd_len = 0;
HostCmd_DS_802_11_PS_MODE_ENH *pps_mode = MNULL;
opt_sleep_confirm_buffer *sleep_cfm_buf =
(opt_sleep_confirm_buffer *) (pmadapter->psleep_cfm->pbuf +
pmadapter->psleep_cfm->data_offset);
ENTER();
if ((wlan_get_priv(pmadapter, MLAN_BSS_TYPE_ANY))->bss_type ==
MLAN_BSS_TYPE_STA) {
cmd_len = sizeof(HostCmd_DS_COMMAND);
pps_mode = &sleep_cfm_buf->ps_cfm_sleep.params.psmode_enh;
sleep_cfm_buf->ps_cfm_sleep.seq_num =
wlan_cpu_to_le16(++pmadapter->seq_num);
pps_mode->params.sleep_cfm.resp_ctrl = wlan_cpu_to_le16(RESP_NEEDED);
DBG_HEXDUMP(MCMD_D, "SLEEP_CFM", &sleep_cfm_buf->ps_cfm_sleep, cmd_len);
}
/* Send sleep confirm command to firmware */
pmadapter->psleep_cfm->data_len = cmd_len + INTF_HEADER_LEN;
ret = wlan_sdio_host_to_card(pmadapter, MLAN_TYPE_CMD,
pmadapter->psleep_cfm, MNULL);
if (ret == MLAN_STATUS_FAILURE) {
PRINTM(MERROR, "SLEEP_CFM: failed\n");
pmadapter->dbg.num_cmd_sleep_cfm_host_to_card_failure++;
goto done;
} else {
if ((wlan_get_priv(pmadapter, MLAN_BSS_TYPE_ANY))->bss_type ==
MLAN_BSS_TYPE_STA) {
if (!pps_mode->params.sleep_cfm.resp_ctrl) {
/* Response is not needed for sleep confirm command */
pmadapter->ps_state = PS_STATE_SLEEP;
} else {
pmadapter->ps_state = PS_STATE_SLEEP_CFM;
}
if (pps_mode->params.sleep_cfm.resp_ctrl != RESP_NEEDED
&& (pmadapter->is_hs_configured &&
!pmadapter->sleep_period.period)) {
pmadapter->pm_wakeup_card_req = MTRUE;
wlan_host_sleep_activated_event(wlan_get_priv
(pmadapter, MLAN_BSS_TYPE_STA),
MTRUE);
}
}
#define NUM_SC_PER_LINE 16
if (++i % NUM_SC_PER_LINE == 0)
PRINTM(MEVENT, "+\n");
else
PRINTM(MEVENT, "+");
}
done:
LEAVE();
return ret;
}