|
|
@@ -2175,38 +2175,6 @@ QDF_STATUS wma_pktlog_wmi_send_cmd(WMA_HANDLE handle,
|
|
|
}
|
|
|
#endif /* REMOVE_PKT_LOG */
|
|
|
|
|
|
-static void wma_send_status_to_suspend_ind(tp_wma_handle wma, bool suspended)
|
|
|
-{
|
|
|
- tSirReadyToSuspendInd *ready_to_suspend;
|
|
|
- QDF_STATUS status;
|
|
|
- struct scheduler_msg message;
|
|
|
- uint8_t len;
|
|
|
-
|
|
|
- WMA_LOGD("Posting ready to suspend indication to umac");
|
|
|
-
|
|
|
- len = sizeof(tSirReadyToSuspendInd);
|
|
|
- ready_to_suspend = (tSirReadyToSuspendInd *) qdf_mem_malloc(len);
|
|
|
-
|
|
|
- if (NULL == ready_to_suspend) {
|
|
|
- WMA_LOGE("%s: Memory allocation failure", __func__);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- ready_to_suspend->mesgType = eWNI_SME_READY_TO_SUSPEND_IND;
|
|
|
- ready_to_suspend->mesgLen = len;
|
|
|
- ready_to_suspend->suspended = suspended;
|
|
|
-
|
|
|
- message.type = eWNI_SME_READY_TO_SUSPEND_IND;
|
|
|
- message.bodyptr = (void *)ready_to_suspend;
|
|
|
- message.bodyval = 0;
|
|
|
-
|
|
|
- status = scheduler_post_msg(QDF_MODULE_ID_SME, &message);
|
|
|
- if (status != QDF_STATUS_SUCCESS) {
|
|
|
- WMA_LOGE("Failed to post ready to suspend");
|
|
|
- qdf_mem_free(ready_to_suspend);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
/**
|
|
|
* wma_wow_wake_reason_str() - Converts wow wakeup reason code to text format
|
|
|
* @wake_reason - WOW wake reason
|
|
|
@@ -3165,7 +3133,7 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event,
|
|
|
qdf_wow_wakeup_host_event(wake_info->wake_reason);
|
|
|
}
|
|
|
|
|
|
- qdf_event_set(&wma->wma_resume_event);
|
|
|
+ pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
|
|
|
|
|
|
if (param_buf->wow_packet_buffer &&
|
|
|
tlv_check_required(wake_info->wake_reason)) {
|
|
|
@@ -3431,7 +3399,7 @@ int wma_pdev_resume_event_handler(void *handle, uint8_t *event, uint32_t len)
|
|
|
|
|
|
WMA_LOGA("Received PDEV resume event");
|
|
|
|
|
|
- qdf_event_set(&wma->wma_resume_event);
|
|
|
+ pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
@@ -3449,144 +3417,18 @@ static inline void wma_set_wow_bus_suspend(tp_wma_handle wma, int val)
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * wma_enable_wow_in_fw() - wnable wow in fw
|
|
|
+ * wma_suspend_req() - Handles suspend indication request received from umac.
|
|
|
* @wma: wma handle
|
|
|
- * @wow_params: collection of wow enable override parameters
|
|
|
+ * @type: type of suspend
|
|
|
+ *
|
|
|
+ * The type controlls how we notify the indicator that the indication has
|
|
|
+ * been processed
|
|
|
*
|
|
|
* Return: QDF status
|
|
|
*/
|
|
|
-QDF_STATUS wma_enable_wow_in_fw(WMA_HANDLE handle,
|
|
|
- struct wow_enable_params wow_params)
|
|
|
+QDF_STATUS wma_suspend_req(tp_wma_handle wma, enum qdf_suspend_type type)
|
|
|
{
|
|
|
- tp_wma_handle wma = handle;
|
|
|
- int ret;
|
|
|
- struct hif_opaque_softc *scn;
|
|
|
- int host_credits;
|
|
|
- int wmi_pending_cmds;
|
|
|
- struct wow_cmd_params param = {0};
|
|
|
-
|
|
|
- tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
|
|
|
-
|
|
|
- if (NULL == pMac) {
|
|
|
- WMA_LOGE("%s: Unable to get PE context", __func__);
|
|
|
- return QDF_STATUS_E_FAILURE;
|
|
|
- }
|
|
|
-
|
|
|
- qdf_event_reset(&wma->target_suspend);
|
|
|
- wma->wow_nack = false;
|
|
|
-
|
|
|
- host_credits = wmi_get_host_credits(wma->wmi_handle);
|
|
|
- wmi_pending_cmds = wmi_get_pending_cmds(wma->wmi_handle);
|
|
|
-
|
|
|
- WMA_LOGD("Credits:%d; Pending_Cmds: %d",
|
|
|
- host_credits, wmi_pending_cmds);
|
|
|
-
|
|
|
- param.enable = true;
|
|
|
- if (wow_params.is_unit_test)
|
|
|
- param.flags = WMI_WOW_FLAG_UNIT_TEST_ENABLE;
|
|
|
-
|
|
|
- switch (wow_params.interface_pause) {
|
|
|
- default:
|
|
|
- WMA_LOGE("Invalid interface pause setting: %d",
|
|
|
- wow_params.interface_pause);
|
|
|
- /* intentional fall-through to default */
|
|
|
- case WOW_INTERFACE_PAUSE_DEFAULT:
|
|
|
- param.can_suspend_link = htc_can_suspend_link(wma->htc_handle);
|
|
|
- break;
|
|
|
- case WOW_INTERFACE_PAUSE_ENABLE:
|
|
|
- param.can_suspend_link = true;
|
|
|
- break;
|
|
|
- case WOW_INTERFACE_PAUSE_DISABLE:
|
|
|
- param.can_suspend_link = false;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- switch (wow_params.resume_trigger) {
|
|
|
- default:
|
|
|
- WMA_LOGE("Invalid resume trigger setting: %d",
|
|
|
- wow_params.resume_trigger);
|
|
|
- /* intentional fall-through to default */
|
|
|
- case WOW_RESUME_TRIGGER_DEFAULT:
|
|
|
- case WOW_RESUME_TRIGGER_GPIO:
|
|
|
- /*
|
|
|
- * GPIO is currently implicit. This means you can't actually
|
|
|
- * force GPIO if a platform's default wake trigger is HTC wakeup
|
|
|
- */
|
|
|
- break;
|
|
|
- case WOW_RESUME_TRIGGER_HTC_WAKEUP:
|
|
|
- param.flags |= WMI_WOW_FLAG_DO_HTC_WAKEUP;
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- ret = wmi_unified_wow_enable_send(wma->wmi_handle, ¶m,
|
|
|
- WMA_WILDCARD_PDEV_ID);
|
|
|
- if (ret) {
|
|
|
- WMA_LOGE("Failed to enable wow in fw");
|
|
|
- goto error;
|
|
|
- }
|
|
|
-
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, true);
|
|
|
-
|
|
|
- if (qdf_wait_single_event(&wma->target_suspend,
|
|
|
- WMA_TGT_SUSPEND_COMPLETE_TIMEOUT)
|
|
|
- != QDF_STATUS_SUCCESS) {
|
|
|
- WMA_LOGE("Failed to receive WoW Enable Ack from FW");
|
|
|
- WMA_LOGE("Credits:%d; Pending_Cmds: %d",
|
|
|
- wmi_get_host_credits(wma->wmi_handle),
|
|
|
- wmi_get_pending_cmds(wma->wmi_handle));
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, false);
|
|
|
- if (!cds_is_driver_recovering()) {
|
|
|
- if (pMac->sme.enableSelfRecovery) {
|
|
|
- cds_trigger_recovery(false);
|
|
|
- } else {
|
|
|
- QDF_BUG(0);
|
|
|
- }
|
|
|
- } else {
|
|
|
- WMA_LOGE("%s: LOGP is in progress, ignore!", __func__);
|
|
|
- }
|
|
|
-
|
|
|
- return QDF_STATUS_E_FAILURE;
|
|
|
- }
|
|
|
-
|
|
|
- if (wma->wow_nack) {
|
|
|
- WMA_LOGE("FW not ready to WOW");
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, false);
|
|
|
- return QDF_STATUS_E_AGAIN;
|
|
|
- }
|
|
|
-
|
|
|
- host_credits = wmi_get_host_credits(wma->wmi_handle);
|
|
|
- wmi_pending_cmds = wmi_get_pending_cmds(wma->wmi_handle);
|
|
|
-
|
|
|
- if (host_credits < WMI_WOW_REQUIRED_CREDITS) {
|
|
|
- WMA_LOGE("%s: No Credits after HTC ACK:%d, pending_cmds:%d, "
|
|
|
- "cannot resume back", __func__, host_credits,
|
|
|
- wmi_pending_cmds);
|
|
|
- htc_dump_counter_info(wma->htc_handle);
|
|
|
- if (!cds_is_driver_recovering())
|
|
|
- QDF_BUG(0);
|
|
|
- else
|
|
|
- WMA_LOGE("%s: SSR in progress, ignore no credit issue",
|
|
|
- __func__);
|
|
|
- }
|
|
|
-
|
|
|
- WMA_LOGD("WOW enabled successfully in fw: credits:%d"
|
|
|
- "pending_cmds: %d", host_credits, wmi_pending_cmds);
|
|
|
-
|
|
|
- scn = cds_get_context(QDF_MODULE_ID_HIF);
|
|
|
-
|
|
|
- if (scn == NULL) {
|
|
|
- WMA_LOGE("%s: Failed to get HIF context", __func__);
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, false);
|
|
|
- QDF_ASSERT(0);
|
|
|
- return QDF_STATUS_E_FAULT;
|
|
|
- }
|
|
|
-
|
|
|
- wma->wow.wow_enable_cmd_sent = true;
|
|
|
-
|
|
|
return QDF_STATUS_SUCCESS;
|
|
|
-
|
|
|
-error:
|
|
|
- return QDF_STATUS_E_FAILURE;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -3598,27 +3440,6 @@ error:
|
|
|
*/
|
|
|
QDF_STATUS wma_resume_req(tp_wma_handle wma, enum qdf_suspend_type type)
|
|
|
{
|
|
|
- if (type == QDF_SYSTEM_SUSPEND) {
|
|
|
- wma->no_of_resume_ind++;
|
|
|
-
|
|
|
- if (wma->no_of_resume_ind < wma_get_vdev_count(wma))
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
-
|
|
|
- wma->no_of_resume_ind = 0;
|
|
|
- }
|
|
|
-
|
|
|
- /* Reset the DTIM Parameters */
|
|
|
- wma_set_resume_dtim(wma);
|
|
|
- /* need to reset if hif_pci_suspend_fails */
|
|
|
- wma_set_wow_bus_suspend(wma, 0);
|
|
|
- /* unpause the vdev if left paused and hif_pci_suspend fails */
|
|
|
- wma_unpause_vdev(wma);
|
|
|
-
|
|
|
- wmi_set_runtime_pm_inprogress(wma->wmi_handle, false);
|
|
|
-
|
|
|
- if (type == QDF_RUNTIME_SUSPEND)
|
|
|
- qdf_runtime_pm_allow_suspend(wma->wma_runtime_resume_lock);
|
|
|
-
|
|
|
return QDF_STATUS_SUCCESS;
|
|
|
}
|
|
|
|
|
|
@@ -3731,456 +3552,6 @@ void wma_update_conn_state(tp_wma_handle wma, uint32_t conn_mask)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * wma_is_beaconning_vdev_up(): check if a beaconning vdev is up
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * Return TRUE if beaconning vdev is up
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_is_beaconning_vdev_up(tp_wma_handle wma)
|
|
|
-{
|
|
|
- int i;
|
|
|
- for (i = 0; i < wma->max_bssid; i++) {
|
|
|
- if (wma_is_vdev_in_beaconning_mode(wma, i)
|
|
|
- && wma_is_vdev_up(i))
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_support_wow_for_beaconing: wow query for beaconning
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * Need to configure wow to enable beaconning offload when
|
|
|
- * a beaconing vdev is up and beaonning offload is configured.
|
|
|
- *
|
|
|
- * Return: true if we need to enable wow for beaconning offload
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_support_wow_for_beaconing(tp_wma_handle wma)
|
|
|
-{
|
|
|
- if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
|
|
|
- WMI_SERVICE_BEACON_OFFLOAD)) {
|
|
|
- if (wma_is_beaconning_vdev_up(wma))
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef FEATURE_WLAN_SCAN_PNO
|
|
|
-/**
|
|
|
- * wma_is_pnoscan_in_progress(): check if a pnoscan is in progress
|
|
|
- * @wma: wma handle
|
|
|
- * @vdev_id: vdev_id
|
|
|
- *
|
|
|
- * Return: TRUE/FALSE
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_is_pnoscan_in_progress(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return wma->interfaces[vdev_id].pno_in_progress;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_pnoscan_match_found(): check if a scan match was found
|
|
|
- * @wma: wma handle
|
|
|
- * @vdev_id: vdev_id
|
|
|
- *
|
|
|
- * Return: TRUE/FALSE
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_is_pnoscan_match_found(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return wma->interfaces[vdev_id].nlo_match_evt_received;
|
|
|
-}
|
|
|
-#else
|
|
|
-/**
|
|
|
- * wma_is_pnoscan_in_progress(): dummy
|
|
|
- *
|
|
|
- * Return: False since no pnoscan cannot be in progress
|
|
|
- * when feature flag is not defined.
|
|
|
- */
|
|
|
-bool wma_is_pnoscan_in_progress(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return FALSE;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_pnoscan_match_found(): dummy
|
|
|
- * @wma: wma handle
|
|
|
- * @vdev_id: vdev_id
|
|
|
- *
|
|
|
- * Return: False since no pnoscan cannot occur
|
|
|
- * when feature flag is not defined.
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_is_pnoscan_match_found(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return FALSE;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef FEATURE_WLAN_EXTSCAN
|
|
|
-static inline
|
|
|
-/**
|
|
|
- * wma_is_extscan_in_progress(): check if an extscan is in progress
|
|
|
- * @wma: wma handle
|
|
|
- * @vdev_id: vdev_id
|
|
|
- *
|
|
|
- * Return: TRUE/FALSvE
|
|
|
- */
|
|
|
-bool wma_is_extscan_in_progress(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return wma->interfaces[vdev_id].extscan_in_progress;
|
|
|
-}
|
|
|
-#else
|
|
|
-/**
|
|
|
- * wma_is_extscan_in_progress(): dummy
|
|
|
- *
|
|
|
- * Return: False since no extscan can be in progress
|
|
|
- * when feature flag is not defined.
|
|
|
- */
|
|
|
-bool wma_is_extscan_in_progress(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return false;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_p2plo_in_progress(): check if P2P listen offload is in progress
|
|
|
- * @wma: wma handle
|
|
|
- * @vdev_id: vdev_id
|
|
|
- *
|
|
|
- * This function is to check if p2p listen offload is in progress,
|
|
|
- * true: p2p listen offload in progress
|
|
|
- * false: otherwise
|
|
|
- *
|
|
|
- * Return: TRUE/FALSE
|
|
|
- */
|
|
|
-static inline
|
|
|
-bool wma_is_p2plo_in_progress(tp_wma_handle wma, int vdev_id)
|
|
|
-{
|
|
|
- return wma->interfaces[vdev_id].p2p_lo_in_progress;
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef WLAN_FEATURE_LPSS
|
|
|
-/**
|
|
|
- * wma_is_lpass_enabled() - check if lpass is enabled
|
|
|
- * @handle: Pointer to wma handle
|
|
|
- *
|
|
|
- * WoW is needed if LPASS or NaN feature is enabled in INI because
|
|
|
- * target can't wake up itself if its put in PDEV suspend when LPASS
|
|
|
- * or NaN features are supported
|
|
|
- *
|
|
|
- * Return: true if lpass is enabled else false
|
|
|
- */
|
|
|
-bool static wma_is_lpass_enabled(tp_wma_handle wma)
|
|
|
-{
|
|
|
- if (wma->is_lpass_enabled)
|
|
|
- return true;
|
|
|
- else
|
|
|
- return false;
|
|
|
-}
|
|
|
-#else
|
|
|
-bool static wma_is_lpass_enabled(tp_wma_handle wma)
|
|
|
-{
|
|
|
- return false;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef WLAN_FEATURE_NAN
|
|
|
-/**
|
|
|
- * wma_is_nan_enabled() - check if NaN is enabled
|
|
|
- * @handle: Pointer to wma handle
|
|
|
- *
|
|
|
- * WoW is needed if LPASS or NaN feature is enabled in INI because
|
|
|
- * target can't wake up itself if its put in PDEV suspend when LPASS
|
|
|
- * or NaN features are supported
|
|
|
- *
|
|
|
- * Return: true if NaN is enabled else false
|
|
|
- */
|
|
|
-bool static wma_is_nan_enabled(tp_wma_handle wma)
|
|
|
-{
|
|
|
- if (wma->is_nan_enabled)
|
|
|
- return true;
|
|
|
- else
|
|
|
- return false;
|
|
|
-}
|
|
|
-#else
|
|
|
-bool static wma_is_nan_enabled(tp_wma_handle wma)
|
|
|
-{
|
|
|
- return false;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_wow_applicable(): should enable wow
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * Enable WOW if any one of the condition meets,
|
|
|
- * 1) Is any one of vdev in beaconning mode (in AP mode) ?
|
|
|
- * 2) Is any one of vdev in connected state (in STA mode) ?
|
|
|
- * 3) Is PNO in progress in any one of vdev ?
|
|
|
- * 4) Is Extscan in progress in any one of vdev ?
|
|
|
- * 5) Is P2P listen offload in any one of vdev?
|
|
|
- * 6) Is any vdev in NAN data mode? BSS is already started at the
|
|
|
- * the time of device creation. It is ready to accept data
|
|
|
- * requests.
|
|
|
- * 7) If LPASS feature is enabled
|
|
|
- * 8) If NaN feature is enabled
|
|
|
- * If none of above conditions is true then return false
|
|
|
- *
|
|
|
- * Return: true if wma needs to configure wow false otherwise.
|
|
|
- */
|
|
|
-static bool wma_is_wow_applicable(tp_wma_handle wma)
|
|
|
-{
|
|
|
- int vdev_id;
|
|
|
- if (wma_support_wow_for_beaconing(wma)) {
|
|
|
- WMA_LOGD("vdev is in beaconning mode, enabling wow");
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- for (vdev_id = 0; vdev_id < wma->max_bssid; vdev_id++) {
|
|
|
- if (wma->interfaces[vdev_id].conn_state) {
|
|
|
- WMA_LOGD("STA is connected, enabling wow");
|
|
|
- return true;
|
|
|
- } else if (wma_is_pnoscan_in_progress(wma, vdev_id)) {
|
|
|
- WMA_LOGD("PNO is in progress, enabling wow");
|
|
|
- return true;
|
|
|
- } else if (wma_is_extscan_in_progress(wma, vdev_id)) {
|
|
|
- WMA_LOGD("EXT is in progress, enabling wow");
|
|
|
- return true;
|
|
|
- } else if (wma_is_p2plo_in_progress(wma, vdev_id)) {
|
|
|
- WMA_LOGD("P2P LO is in progress, enabling wow");
|
|
|
- return true;
|
|
|
- } else if (wma_is_lpass_enabled(wma)) {
|
|
|
- WMA_LOGD("LPASS is enabled, enabling WoW");
|
|
|
- return true;
|
|
|
- } else if (wma_is_nan_enabled(wma)) {
|
|
|
- WMA_LOGD("NAN is enabled, enabling WoW");
|
|
|
- return true;
|
|
|
- } else if (WMA_IS_VDEV_IN_NDI_MODE(wma->interfaces, vdev_id)) {
|
|
|
- WMA_LOGD("vdev %d is in NAN data mode, enabling wow",
|
|
|
- vdev_id);
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- WMA_LOGD("All vdev are in disconnected state and pno/extscan is not in progress, skipping wow");
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_configure_dynamic_wake_events(): configure dyanmic wake events
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * Some wake events need to be enabled dynamically. Controll those here.
|
|
|
- *
|
|
|
- * Return: none
|
|
|
- */
|
|
|
-static void wma_configure_dynamic_wake_events(tp_wma_handle wma)
|
|
|
-{
|
|
|
- int vdev_id;
|
|
|
- int enable_mask;
|
|
|
- int disable_mask;
|
|
|
-
|
|
|
- for (vdev_id = 0; vdev_id < wma->max_bssid; vdev_id++) {
|
|
|
- enable_mask = 0;
|
|
|
- disable_mask = 0;
|
|
|
-
|
|
|
- if (wma_is_pnoscan_in_progress(wma, vdev_id)) {
|
|
|
- if (wma_is_pnoscan_match_found(wma, vdev_id))
|
|
|
- enable_mask |=
|
|
|
- (1 << WOW_NLO_SCAN_COMPLETE_EVENT);
|
|
|
- else
|
|
|
- disable_mask |=
|
|
|
- (1 << WOW_NLO_SCAN_COMPLETE_EVENT);
|
|
|
- }
|
|
|
-
|
|
|
- if (enable_mask != 0)
|
|
|
- pmo_ucfg_enable_wakeup_event(wma->psoc, vdev_id,
|
|
|
- enable_mask);
|
|
|
- if (disable_mask != 0)
|
|
|
- pmo_ucfg_disable_wakeup_event(wma->psoc, vdev_id,
|
|
|
- disable_mask);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef FEATURE_WLAN_LPHB
|
|
|
-/**
|
|
|
- * wma_apply_lphb(): apply cached LPHB settings
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * LPHB cache, if any item was enabled, should be
|
|
|
- * applied.
|
|
|
- */
|
|
|
-static inline
|
|
|
-void wma_apply_lphb(tp_wma_handle wma)
|
|
|
-{
|
|
|
- int i;
|
|
|
- WMA_LOGD("%s: checking LPHB cache", __func__);
|
|
|
- for (i = 0; i < 2; i++) {
|
|
|
- if (wma->wow.lphb_cache[i].params.lphbEnableReq.enable) {
|
|
|
- WMA_LOGD("%s: LPHB cache for item %d is marked as enable",
|
|
|
- __func__, i + 1);
|
|
|
- wma_lphb_conf_hbenable(wma, &(wma->wow.lphb_cache[i]),
|
|
|
- false);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-#else
|
|
|
-void wma_apply_lphb(tp_wma_handle wma) {}
|
|
|
-#endif /* FEATURE_WLAN_LPHB */
|
|
|
-
|
|
|
-static void wma_notify_suspend_req_procesed(tp_wma_handle wma,
|
|
|
- enum qdf_suspend_type type)
|
|
|
-{
|
|
|
- if (type == QDF_SYSTEM_SUSPEND)
|
|
|
- wma_send_status_to_suspend_ind(wma, true);
|
|
|
- else if (type == QDF_RUNTIME_SUSPEND)
|
|
|
- qdf_event_set(&wma->runtime_suspend);
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_suspend_req() - Handles suspend indication request received from umac.
|
|
|
- * @wma: wma handle
|
|
|
- * @type: type of suspend
|
|
|
- *
|
|
|
- * The type controlls how we notify the indicator that the indication has
|
|
|
- * been processed
|
|
|
- *
|
|
|
- * Return: QDF status
|
|
|
- */
|
|
|
-QDF_STATUS wma_suspend_req(tp_wma_handle wma, enum qdf_suspend_type type)
|
|
|
-{
|
|
|
- if (type == QDF_RUNTIME_SUSPEND)
|
|
|
- wmi_set_runtime_pm_inprogress(wma->wmi_handle, true);
|
|
|
-
|
|
|
- if (wma_is_wow_applicable(wma)) {
|
|
|
- WMA_LOGI("WOW Suspend");
|
|
|
- wma_apply_lphb(wma);
|
|
|
-
|
|
|
- wma_configure_dynamic_wake_events(wma);
|
|
|
-
|
|
|
- wma->wow.wow_enable = true;
|
|
|
- wma->wow.wow_enable_cmd_sent = false;
|
|
|
- }
|
|
|
-
|
|
|
- /* Set the Suspend DTIM Parameters */
|
|
|
- wma_set_suspend_dtim(wma);
|
|
|
-
|
|
|
- wma_notify_suspend_req_procesed(wma, type);
|
|
|
-
|
|
|
- /* to handle race between hif_pci_suspend and
|
|
|
- * unpause/pause tx handler
|
|
|
- */
|
|
|
- wma_set_wow_bus_suspend(wma, 1);
|
|
|
-
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_send_host_wakeup_ind_to_fw() - send wakeup ind to fw
|
|
|
- * @wma: wma handle
|
|
|
- *
|
|
|
- * Sends host wakeup indication to FW. On receiving this indication,
|
|
|
- * FW will come out of WOW.
|
|
|
- *
|
|
|
- * Return: QDF status
|
|
|
- */
|
|
|
-static QDF_STATUS wma_send_host_wakeup_ind_to_fw(tp_wma_handle wma)
|
|
|
-{
|
|
|
- QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
|
|
|
- int ret;
|
|
|
- tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
|
|
|
- if (NULL == pMac) {
|
|
|
- WMA_LOGE("%s: Unable to get PE context", __func__);
|
|
|
- return QDF_STATUS_E_FAILURE;
|
|
|
- }
|
|
|
-
|
|
|
- qdf_event_reset(&wma->wma_resume_event);
|
|
|
-
|
|
|
- ret = wmi_unified_host_wakeup_ind_to_fw_cmd(wma->wmi_handle);
|
|
|
- if (ret) {
|
|
|
- return QDF_STATUS_E_FAILURE;
|
|
|
- }
|
|
|
-
|
|
|
- WMA_LOGD("Host wakeup indication sent to fw");
|
|
|
-
|
|
|
- qdf_status = qdf_wait_single_event(&(wma->wma_resume_event),
|
|
|
- WMA_RESUME_TIMEOUT);
|
|
|
- if (QDF_STATUS_SUCCESS != qdf_status) {
|
|
|
- WMA_LOGP("%s: Timeout waiting for resume event from FW",
|
|
|
- __func__);
|
|
|
- WMA_LOGP("%s: Pending commands %d credits %d", __func__,
|
|
|
- wmi_get_pending_cmds(wma->wmi_handle),
|
|
|
- wmi_get_host_credits(wma->wmi_handle));
|
|
|
- if (!cds_is_driver_recovering()) {
|
|
|
- if (pMac->sme.enableSelfRecovery) {
|
|
|
- wmi_tag_crash_inject(wma->wmi_handle, true);
|
|
|
- cds_trigger_recovery(false);
|
|
|
- } else {
|
|
|
- QDF_BUG(0);
|
|
|
- }
|
|
|
- } else {
|
|
|
- WMA_LOGE("%s: SSR in progress, ignore resume timeout",
|
|
|
- __func__);
|
|
|
- }
|
|
|
- } else {
|
|
|
- WMA_LOGD("Host wakeup received");
|
|
|
- }
|
|
|
-
|
|
|
- if (QDF_STATUS_SUCCESS == qdf_status)
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, false);
|
|
|
-
|
|
|
- return qdf_status;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_disable_wow_in_fw() - Disable wow in PCIe resume context.
|
|
|
- * @handle: wma handle
|
|
|
- *
|
|
|
- * Return: 0 for success or error code
|
|
|
- */
|
|
|
-QDF_STATUS wma_disable_wow_in_fw(WMA_HANDLE handle)
|
|
|
-{
|
|
|
- tp_wma_handle wma = handle;
|
|
|
- QDF_STATUS ret;
|
|
|
-
|
|
|
- ret = wma_send_host_wakeup_ind_to_fw(wma);
|
|
|
-
|
|
|
- if (ret != QDF_STATUS_SUCCESS)
|
|
|
- return ret;
|
|
|
-
|
|
|
- wma->wow.wow_enable = false;
|
|
|
- wma->wow.wow_enable_cmd_sent = false;
|
|
|
-
|
|
|
- /* To allow the tx pause/unpause events */
|
|
|
- wma_set_wow_bus_suspend(wma, 0);
|
|
|
- /* Unpause the vdev as we are resuming */
|
|
|
- wma_unpause_vdev(wma);
|
|
|
-
|
|
|
- return ret;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_wow_mode_selected() - check if wow needs to be enabled in fw
|
|
|
- * @handle: Pointer to wma handle
|
|
|
- *
|
|
|
- * If lpass is enabled then always do wow else check wow_enable config
|
|
|
- *
|
|
|
- * Return: true is wow mode is needed else false
|
|
|
- */
|
|
|
-bool wma_is_wow_mode_selected(WMA_HANDLE handle)
|
|
|
-{
|
|
|
- tp_wma_handle wma = (tp_wma_handle) handle;
|
|
|
- WMA_LOGD("WoW enable %d", wma->wow.wow_enable);
|
|
|
- return wma->wow.wow_enable;
|
|
|
-}
|
|
|
-
|
|
|
/**
|
|
|
* wma_del_ts_req() - send DELTS request to fw
|
|
|
* @wma: wma handle
|
|
|
@@ -5485,45 +4856,6 @@ static QDF_STATUS wma_post_runtime_resume_msg(WMA_HANDLE handle)
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * wma_post_runtime_suspend_msg() - post the suspend request
|
|
|
- * @handle: validated wma handle
|
|
|
- *
|
|
|
- * Requests for offloads to be configured for runtime suspend
|
|
|
- * on the MC thread
|
|
|
- *
|
|
|
- * Return QDF_STATUS_E_AGAIN in case of timeout or QDF_STATUS_SUCCESS
|
|
|
- */
|
|
|
-static QDF_STATUS wma_post_runtime_suspend_msg(WMA_HANDLE handle)
|
|
|
-{
|
|
|
- struct scheduler_msg message;
|
|
|
- QDF_STATUS qdf_status;
|
|
|
- tp_wma_handle wma = (tp_wma_handle) handle;
|
|
|
-
|
|
|
- qdf_event_reset(&wma->runtime_suspend);
|
|
|
-
|
|
|
- message.bodyptr = NULL;
|
|
|
- message.type = WMA_RUNTIME_PM_SUSPEND_IND;
|
|
|
- qdf_status = scheduler_post_msg(QDF_MODULE_ID_WMA, &message);
|
|
|
-
|
|
|
- if (qdf_status != QDF_STATUS_SUCCESS)
|
|
|
- goto failure;
|
|
|
-
|
|
|
- if (qdf_wait_single_event(&wma->runtime_suspend,
|
|
|
- WMA_TGT_SUSPEND_COMPLETE_TIMEOUT) !=
|
|
|
- QDF_STATUS_SUCCESS) {
|
|
|
- WMA_LOGE("Failed to get runtime suspend event");
|
|
|
- goto msg_timed_out;
|
|
|
- }
|
|
|
-
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
-
|
|
|
-msg_timed_out:
|
|
|
- wma_post_runtime_resume_msg(wma);
|
|
|
-failure:
|
|
|
- return QDF_STATUS_E_AGAIN;
|
|
|
-}
|
|
|
-
|
|
|
/**
|
|
|
* __wma_bus_suspend(): handles bus suspend for wma
|
|
|
* @type: is this suspend part of runtime suspend or system suspend?
|
|
|
@@ -5537,33 +4869,7 @@ failure:
|
|
|
static int __wma_bus_suspend(enum qdf_suspend_type type,
|
|
|
struct wow_enable_params wow_params)
|
|
|
{
|
|
|
- WMA_HANDLE handle = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
- if (NULL == handle) {
|
|
|
- WMA_LOGE("%s: wma context is NULL", __func__);
|
|
|
- return -EFAULT;
|
|
|
- }
|
|
|
-
|
|
|
- if (wma_check_scan_in_progress(handle)) {
|
|
|
- WMA_LOGE("%s: Scan in progress. Aborting suspend", __func__);
|
|
|
- return -EBUSY;
|
|
|
- }
|
|
|
-
|
|
|
- if (type == QDF_RUNTIME_SUSPEND) {
|
|
|
- QDF_STATUS status = wma_post_runtime_suspend_msg(handle);
|
|
|
- if (status)
|
|
|
- return qdf_status_to_os_return(status);
|
|
|
- }
|
|
|
-
|
|
|
- if (type == QDF_SYSTEM_SUSPEND)
|
|
|
- WMA_LOGI("%s: wow mode selected %d", __func__,
|
|
|
- wma_is_wow_mode_selected(handle));
|
|
|
-
|
|
|
- if (wma_is_wow_mode_selected(handle)) {
|
|
|
- QDF_STATUS status = wma_enable_wow_in_fw(handle, wow_params);
|
|
|
- return qdf_status_to_os_return(status);
|
|
|
- }
|
|
|
-
|
|
|
- return wma_suspend_target(handle, 0);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -5585,19 +4891,6 @@ int wma_runtime_suspend(struct wow_enable_params wow_params)
|
|
|
return __wma_bus_suspend(QDF_RUNTIME_SUSPEND, wow_params);
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * wma_bus_suspend() - handles bus suspend request from hdd
|
|
|
- * @wow_params: collection of wow enable override parameters
|
|
|
- *
|
|
|
- * Calls the appropriate handler based on configuration and event
|
|
|
- *
|
|
|
- * Return: 0 for success or error code
|
|
|
- */
|
|
|
-int wma_bus_suspend(struct wow_enable_params wow_params)
|
|
|
-{
|
|
|
- return __wma_bus_suspend(QDF_SYSTEM_SUSPEND, wow_params);
|
|
|
-}
|
|
|
-
|
|
|
/**
|
|
|
* __wma_bus_resume() - bus resume for wma
|
|
|
*
|
|
|
@@ -5607,19 +4900,7 @@ int wma_bus_suspend(struct wow_enable_params wow_params)
|
|
|
*/
|
|
|
static int __wma_bus_resume(WMA_HANDLE handle)
|
|
|
{
|
|
|
- bool wow_mode = wma_is_wow_mode_selected(handle);
|
|
|
- tp_wma_handle wma = handle;
|
|
|
- QDF_STATUS status;
|
|
|
-
|
|
|
- WMA_LOGI("%s: wow mode %d", __func__, wow_mode);
|
|
|
-
|
|
|
- wma->wow_initial_wake_up = false;
|
|
|
-
|
|
|
- if (!wow_mode)
|
|
|
- return qdf_status_to_os_return(wma_resume_target(handle));
|
|
|
-
|
|
|
- status = wma_disable_wow_in_fw(handle);
|
|
|
- return qdf_status_to_os_return(status);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -5645,25 +4926,6 @@ int wma_runtime_resume(void)
|
|
|
return qdf_status_to_os_return(status);
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * wma_bus_resume() - handles bus resume request from hdd
|
|
|
- * @handle: valid wma handle
|
|
|
- *
|
|
|
- * Calls the appropriate handler based on configuration
|
|
|
- *
|
|
|
- * Return: 0 for success or error code
|
|
|
- */
|
|
|
-int wma_bus_resume(void)
|
|
|
-{
|
|
|
- WMA_HANDLE handle = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
- if (NULL == handle) {
|
|
|
- WMA_LOGE("%s: wma context is NULL", __func__);
|
|
|
- return -EFAULT;
|
|
|
- }
|
|
|
-
|
|
|
- return __wma_bus_resume(handle);
|
|
|
-}
|
|
|
-
|
|
|
/**
|
|
|
* wma_suspend_target_timeout() - Handles the target suspend timeout
|
|
|
* @is_self_recovery_enabled: Is self recovery enabled or not
|
|
|
@@ -5684,192 +4946,6 @@ static inline void wma_suspend_target_timeout(bool is_self_recovery_enabled)
|
|
|
QDF_BUG(0);
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * wma_suspend_target() - suspend target
|
|
|
- * @handle: wma handle
|
|
|
- * @disable_target_intr: disable target interrupt
|
|
|
- *
|
|
|
- * Return: QDF_STATUS_SUCCESS for success or error code
|
|
|
- */
|
|
|
-QDF_STATUS wma_suspend_target(WMA_HANDLE handle, int disable_target_intr)
|
|
|
-{
|
|
|
- tp_wma_handle wma_handle = (tp_wma_handle) handle;
|
|
|
- QDF_STATUS status;
|
|
|
- struct suspend_params param = {0};
|
|
|
-
|
|
|
- tpAniSirGlobal pmac = cds_get_context(QDF_MODULE_ID_PE);
|
|
|
-
|
|
|
- if (!wma_handle || !wma_handle->wmi_handle) {
|
|
|
- WMA_LOGE("WMA is closed. can not issue suspend cmd");
|
|
|
- return QDF_STATUS_E_INVAL;
|
|
|
- }
|
|
|
-
|
|
|
- if (NULL == pmac) {
|
|
|
- WMA_LOGE("%s: Unable to get PE context", __func__);
|
|
|
- return QDF_STATUS_E_INVAL;
|
|
|
- }
|
|
|
-
|
|
|
- qdf_event_reset(&wma_handle->target_suspend);
|
|
|
- param.disable_target_intr = disable_target_intr;
|
|
|
- status = wmi_unified_suspend_send(wma_handle->wmi_handle,
|
|
|
- ¶m,
|
|
|
- WMA_WILDCARD_PDEV_ID);
|
|
|
- if (QDF_IS_STATUS_ERROR(status))
|
|
|
- return status;
|
|
|
-
|
|
|
- wmi_set_target_suspend(wma_handle->wmi_handle, true);
|
|
|
-
|
|
|
- if (qdf_wait_single_event(&wma_handle->target_suspend,
|
|
|
- WMA_TGT_SUSPEND_COMPLETE_TIMEOUT)
|
|
|
- != QDF_STATUS_SUCCESS) {
|
|
|
- WMA_LOGE("Failed to get ACK from firmware for pdev suspend");
|
|
|
- wmi_set_target_suspend(wma_handle->wmi_handle, false);
|
|
|
- wma_suspend_target_timeout(pmac->sme.enableSelfRecovery);
|
|
|
- return QDF_STATUS_E_FAULT;
|
|
|
- }
|
|
|
-
|
|
|
- return QDF_STATUS_SUCCESS;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_target_suspend_acknowledge() - update target susspend status
|
|
|
- * @context: HTC_INIT_INFO->context
|
|
|
- * @wow_nack: true when wow is rejected
|
|
|
- *
|
|
|
- * Return: none
|
|
|
- */
|
|
|
-void wma_target_suspend_acknowledge(void *context, bool wow_nack)
|
|
|
-{
|
|
|
- tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
-
|
|
|
- if (NULL == wma) {
|
|
|
- WMA_LOGE("%s: wma is NULL", __func__);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- wma->wow_nack = wow_nack;
|
|
|
- qdf_event_set(&wma->target_suspend);
|
|
|
- if (wow_nack && !wmi_get_runtime_pm_inprogress(wma->wmi_handle)) {
|
|
|
- cds_host_diag_log_work(&wma->wow_wake_lock,
|
|
|
- WMA_WAKE_LOCK_TIMEOUT,
|
|
|
- WIFI_POWER_EVENT_WAKELOCK_WOW);
|
|
|
- qdf_wake_lock_timeout_acquire(&wma->wow_wake_lock,
|
|
|
- WMA_WAKE_LOCK_TIMEOUT);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_handle_initial_wake_up() - handle inital wake up
|
|
|
- *
|
|
|
- * Return: none
|
|
|
- */
|
|
|
-void wma_handle_initial_wake_up(void)
|
|
|
-{
|
|
|
- tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
-
|
|
|
- if (NULL == wma) {
|
|
|
- WMA_LOGE("%s: wma is NULL", __func__);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- wma->wow_initial_wake_up = true;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_is_target_wake_up_received() - check for initial wake up
|
|
|
- *
|
|
|
- * Check if target initial wake up is received and fail PM suspend gracefully
|
|
|
- *
|
|
|
- * Return: -EAGAIN if initial wake up is received else 0
|
|
|
- */
|
|
|
-int wma_is_target_wake_up_received(void)
|
|
|
-{
|
|
|
- tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
-
|
|
|
- if (NULL == wma) {
|
|
|
- WMA_LOGE("%s: wma is NULL", __func__);
|
|
|
- return -EAGAIN;
|
|
|
- }
|
|
|
-
|
|
|
- if (wma->wow_initial_wake_up) {
|
|
|
- WMA_LOGE("Target initial wake up received try again");
|
|
|
- return -EAGAIN;
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_clear_target_wake_up() - clear initial wake up
|
|
|
- *
|
|
|
- * Clear target initial wake up reason
|
|
|
- *
|
|
|
- * Return: 0 for success and negative error code for failure
|
|
|
- */
|
|
|
-int wma_clear_target_wake_up(void)
|
|
|
-{
|
|
|
- tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
|
|
|
-
|
|
|
- if (NULL == wma) {
|
|
|
- WMA_LOGE("%s: wma is NULL", __func__);
|
|
|
- return -EFAULT;
|
|
|
- }
|
|
|
-
|
|
|
- wma->wow_initial_wake_up = false;
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * wma_resume_target() - resume target
|
|
|
- * @handle: wma handle
|
|
|
- *
|
|
|
- * Return: QDF_STATUS_SUCCESS for success or error code
|
|
|
- */
|
|
|
-QDF_STATUS wma_resume_target(WMA_HANDLE handle)
|
|
|
-{
|
|
|
- tp_wma_handle wma = (tp_wma_handle) handle;
|
|
|
- QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
|
|
|
- tpAniSirGlobal pMac = cds_get_context(QDF_MODULE_ID_PE);
|
|
|
- if (NULL == pMac) {
|
|
|
- WMA_LOGE("%s: Unable to get PE context", __func__);
|
|
|
- return QDF_STATUS_E_INVAL;
|
|
|
- }
|
|
|
-
|
|
|
- qdf_event_reset(&wma->wma_resume_event);
|
|
|
- qdf_status = wmi_unified_resume_send(wma->wmi_handle,
|
|
|
- WMA_WILDCARD_PDEV_ID);
|
|
|
- if (QDF_IS_STATUS_ERROR(qdf_status))
|
|
|
- WMA_LOGE("Failed to send WMI_PDEV_RESUME_CMDID command");
|
|
|
-
|
|
|
- qdf_status = qdf_wait_single_event(&(wma->wma_resume_event),
|
|
|
- WMA_RESUME_TIMEOUT);
|
|
|
- if (QDF_STATUS_SUCCESS != qdf_status) {
|
|
|
- WMA_LOGP("%s: Timeout waiting for resume event from FW",
|
|
|
- __func__);
|
|
|
- WMA_LOGP("%s: Pending commands %d credits %d", __func__,
|
|
|
- wmi_get_pending_cmds(wma->wmi_handle),
|
|
|
- wmi_get_host_credits(wma->wmi_handle));
|
|
|
- if (!cds_is_driver_recovering()) {
|
|
|
- if (pMac->sme.enableSelfRecovery) {
|
|
|
- cds_trigger_recovery(false);
|
|
|
- } else {
|
|
|
- QDF_BUG(0);
|
|
|
- }
|
|
|
- } else {
|
|
|
- WMA_LOGE("%s: SSR in progress, ignore resume timeout",
|
|
|
- __func__);
|
|
|
- }
|
|
|
- } else {
|
|
|
- WMA_LOGD("Host wakeup received");
|
|
|
- }
|
|
|
-
|
|
|
- if (QDF_STATUS_SUCCESS == qdf_status)
|
|
|
- wmi_set_target_suspend(wma->wmi_handle, false);
|
|
|
-
|
|
|
- return qdf_status;
|
|
|
-}
|
|
|
-
|
|
|
#ifdef FEATURE_WLAN_TDLS
|
|
|
/**
|
|
|
* wma_tdls_event_handler() - handle TDLS event
|
Mukul Sharma