qcacld-3.0: Register PM QOS and bus suspend module

With restructuring in hif runtime pm module, modules are
required to register with the hif runtime pm module. Also,
link states are depreciated.
This change registers PM QOS and bus suspend modules which
use runtime PM module and replace link state with resuming
link up state in PMO resume.

Change-Id: I0df48e3d31a1fb0f03faaa0617b48937c9bc224b
CRs-Fixed: 3169425

components/pmo/core/src/wlan_pmo_suspend_resume.c

@@ -813,7 +813,7 @@ pmo_core_enable_wow_in_fw(struct wlan_objmgr_psoc *psoc,
 	} else {
 		pmo_info("Prevent link down, non-drv wow is enabled");
 		if (hif_ctx) {
-			hif_print_runtime_pm_prevent_list(hif_ctx);
+			hif_rtpm_print_prevent_list();
 			htc_log_link_user_votes();
 		}
 	}
@@ -1131,8 +1131,6 @@ QDF_STATUS pmo_core_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
 	if (status != QDF_STATUS_SUCCESS)
 		goto resume_htc;
 
-	hif_pm_set_link_state(hif_ctx, HIF_PM_LINK_STATE_DOWN);
-
 	status = pmo_core_psoc_bus_suspend_req(psoc, QDF_RUNTIME_SUSPEND,
 					       &wow_params);
 	if (status != QDF_STATUS_SUCCESS)
@@ -1174,18 +1172,18 @@ QDF_STATUS pmo_core_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
 		 * shares CE interrupt, there is a chance of wow wakeup
 		 * while suspend is in-progress, so handling such scenario
 		 */
-		hif_pm_runtime_suspend_lock(hif_ctx);
+		hif_rtpm_suspend_lock();
 		psoc_ctx = pmo_psoc_get_priv(psoc);
 		if (pmo_core_get_wow_initial_wake_up(psoc_ctx)) {
-			hif_pm_runtime_suspend_unlock(hif_ctx);
+			hif_rtpm_suspend_unlock();
 			pmo_err("Target wake up received before suspend completion");
 			status = QDF_STATUS_E_BUSY;
 			goto resume_txrx;
 		}
-		hif_process_runtime_suspend_success(hif_ctx);
-		hif_pm_runtime_suspend_unlock(hif_ctx);
+		hif_process_runtime_suspend_success();
+		hif_rtpm_suspend_unlock();
 	} else {
-		hif_process_runtime_suspend_success(hif_ctx);
+		hif_process_runtime_suspend_success();
 	}
 
 	if (hif_try_prevent_ep_vote_access(hif_ctx)) {
@@ -1211,8 +1209,6 @@ pmo_resume_configure:
 	PMO_CORE_PSOC_RUNTIME_PM_QDF_BUG(QDF_STATUS_SUCCESS !=
 		pmo_core_psoc_configure_resume(psoc, true));
 
-	hif_pm_set_link_state(hif_ctx, HIF_PM_LINK_STATE_UP);
-
 resume_htc:
 	PMO_CORE_PSOC_RUNTIME_PM_QDF_BUG(QDF_STATUS_SUCCESS !=
 		pmo_tgt_psoc_set_runtime_pm_inprogress(psoc, false));
@@ -1222,7 +1218,7 @@ cdp_runtime_resume:
 		cdp_runtime_resume(dp_soc, pdev_id));
 
 runtime_failure:
-	hif_process_runtime_suspend_failure(hif_ctx);
+	hif_process_runtime_suspend_failure();
 
 /* always make sure HTC queue kicker is at the end, so if any
  * cmd is pending during suspending, it can re-trigger if suspend
@@ -1276,7 +1272,7 @@ QDF_STATUS pmo_core_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
 		goto dec_psoc_ref;
 	}
 
-	hif_pre_runtime_resume(hif_ctx);
+	hif_pre_runtime_resume();
 	if (pld_cb) {
 		begin = qdf_get_log_timestamp_usecs();
 		ret = pld_cb();
@@ -1302,7 +1298,7 @@ QDF_STATUS pmo_core_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
 	if (QDF_IS_STATUS_ERROR(status))
 		goto fail;
 
-	hif_pm_set_link_state(hif_ctx, HIF_PM_LINK_STATE_UP);
+	hif_process_runtime_resume_linkup();
 
 	status = pmo_core_psoc_configure_resume(psoc, true);
 	if (status != QDF_STATUS_SUCCESS)
@@ -1312,7 +1308,7 @@ QDF_STATUS pmo_core_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
 	if (status != QDF_STATUS_SUCCESS)
 		goto fail;
 
-	hif_process_runtime_resume_success(hif_ctx);
+	hif_process_runtime_resume_success();
 
 	if (htc_runtime_resume(htc_ctx)) {
 		status = QDF_STATUS_E_FAILURE;

core/dp/txrx3.0/dp_swlm.c

@@ -181,8 +181,7 @@ static void dp_swlm_tcl_flush_timer(void *arg)
 	if (hal_srng_try_access_start(soc->hal_soc, hal_ring_hdl) < 0)
 		goto fail;
 
-	if (hif_pm_runtime_get(soc->hif_handle, RTPM_ID_DW_TX_HW_ENQUEUE,
-			       true)) {
+	if (hif_rtpm_get(HIF_RTPM_GET_ASYNC, HIF_RTPM_ID_DP)) {
 		hal_srng_access_end_reap(soc->hal_soc, hal_ring_hdl);
 		hal_srng_set_event(hal_ring_hdl, HAL_SRNG_FLUSH_EVENT);
 		hal_srng_inc_flush_cnt(hal_ring_hdl);
@@ -191,7 +190,7 @@ static void dp_swlm_tcl_flush_timer(void *arg)
 
 	DP_STATS_INC(swlm, tcl[tcl->ring_id].timer_flush_success, 1);
 	hal_srng_access_end(soc->hal_soc, hal_ring_hdl);
-	hif_pm_runtime_put(soc->hif_handle, RTPM_ID_DW_TX_HW_ENQUEUE);
+	hif_rtpm_put(HIF_RTPM_PUT_ASYNC, HIF_RTPM_ID_DP);
 
 	return;
 

core/hdd/inc/wlan_hdd_tx_rx.h

@@ -578,16 +578,6 @@ uint32_t
 wlan_hdd_dump_queue_history_state(struct hdd_netif_queue_history *q_hist,
 				  char *buf, uint32_t size);
 
-/**
- * wlan_hdd_rx_rpm_mark_last_busy() - Check if dp rx marked last busy
- * @hdd_ctx: Pointer to hdd context
- * @hif_ctx: Pointer to hif context
- *
- * Return: dp mark last busy less than runtime delay value
- */
-bool wlan_hdd_rx_rpm_mark_last_busy(struct hdd_context *hdd_ctx,
-				    void *hif_ctx);
-
 /**
  * hdd_sta_notify_tx_comp_cb() - notify tx comp callback registered with dp
  * @skb: pointer to skb

core/hdd/src/wlan_hdd_cm_disconnect.c

@@ -218,7 +218,6 @@ QDF_STATUS wlan_hdd_cm_issue_disconnect(struct hdd_adapter *adapter,
 {
 	QDF_STATUS status;
 	struct wlan_objmgr_vdev *vdev;
-	void *hif_ctx;
 	struct hdd_station_ctx *sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 
 	vdev = hdd_objmgr_get_vdev_by_user(adapter, WLAN_OSIF_CM_ID);
@@ -231,12 +230,7 @@ QDF_STATUS wlan_hdd_cm_issue_disconnect(struct hdd_adapter *adapter,
 				     WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER,
 				     WLAN_CONTROL_PATH);
 
-	hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
-	if (hif_ctx)
-		/*
-		 * Trigger runtime sync resume before sending disconneciton
-		 */
-		hif_pm_runtime_sync_resume(hif_ctx, RTPM_ID_CONN_DISCONNECT);
+	qdf_rtpm_sync_resume();
 
 	wlan_rec_conn_info(adapter->vdev_id, DEBUG_CONN_DISCONNECT,
 			   sta_ctx->conn_info.bssid.bytes, 0, reason);
@@ -486,7 +480,7 @@ wlan_hdd_runtime_pm_wow_disconnect_handler(struct hdd_context *hdd_ctx)
 	hdd_debug("Runtime allowed : %d", hdd_ctx->runtime_pm_prevented);
 	qdf_spin_lock_irqsave(&hdd_ctx->pm_qos_lock);
 	if (hdd_ctx->runtime_pm_prevented) {
-		hif_pm_runtime_put(hif_ctx, RTPM_ID_QOS_NOTIFY);
+		qdf_rtpm_put(QDF_RTPM_PUT, QDF_RTPM_ID_PM_QOS_NOTIFY);
 		hdd_ctx->runtime_pm_prevented = false;
 	}
 	qdf_spin_unlock_irqrestore(&hdd_ctx->pm_qos_lock);

core/hdd/src/wlan_hdd_driver_ops.c

@@ -814,7 +814,6 @@ static int hdd_soc_recovery_reinit(struct device *dev,
 static void __hdd_soc_remove(struct device *dev)
 {
 	struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
-	void *hif_ctx;
 
 	QDF_BUG(hdd_ctx);
 	if (!hdd_ctx)
@@ -823,15 +822,7 @@ static void __hdd_soc_remove(struct device *dev)
 	pr_info("%s: Removing driver v%s\n", WLAN_MODULE_NAME,
 		QWLAN_VERSIONSTR);
 
-	hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
-	if (hif_ctx) {
-		/*
-		 * Trigger runtime sync resume before setting unload in progress
-		 * such that resume can happen successfully
-		 */
-		hif_pm_runtime_sync_resume(hif_ctx, RTPM_ID_SOC_REMOVE);
-	}
-
+	qdf_rtpm_sync_resume();
 	cds_set_driver_loaded(false);
 	cds_set_unload_in_progress(true);
 	if (!hdd_wait_for_debugfs_threads_completion())

core/hdd/src/wlan_hdd_main.c

@@ -1583,6 +1583,9 @@ static void hdd_runtime_suspend_context_init(struct hdd_context *hdd_ctx)
 	qdf_runtime_lock_init(&ctx->monitor_mode);
 	qdf_runtime_lock_init(&ctx->wow_unit_test);
 
+	qdf_rtpm_register(QDF_RTPM_ID_WIPHY_SUSPEND, NULL);
+	qdf_rtpm_register(QDF_RTPM_ID_PM_QOS_NOTIFY, NULL);
+
 	ctx->is_user_wakelock_acquired = false;
 
 	wlan_scan_runtime_pm_init(hdd_ctx->pdev);
@@ -1607,6 +1610,9 @@ static void hdd_runtime_suspend_context_deinit(struct hdd_context *hdd_ctx)
 	qdf_runtime_lock_deinit(&ctx->connect);
 	qdf_runtime_lock_deinit(&ctx->dfs);
 
+	qdf_rtpm_deregister(QDF_RTPM_ID_WIPHY_SUSPEND);
+	qdf_rtpm_deregister(QDF_RTPM_ID_PM_QOS_NOTIFY);
+
 	wlan_scan_runtime_pm_deinit(hdd_ctx->pdev);
 }
 
@@ -4274,7 +4280,6 @@ static int hdd_wlan_register_pm_qos_notifier(struct hdd_context *hdd_ctx)
  */
 static void hdd_wlan_unregister_pm_qos_notifier(struct hdd_context *hdd_ctx)
 {
-	void *hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
 	int ret;
 
 	if (hdd_ctx->config->runtime_pm != hdd_runtime_pm_dynamic) {
@@ -4290,7 +4295,7 @@ static void hdd_wlan_unregister_pm_qos_notifier(struct hdd_context *hdd_ctx)
 	qdf_spin_lock_irqsave(&hdd_ctx->pm_qos_lock);
 
 	if (hdd_ctx->runtime_pm_prevented) {
-		hif_pm_runtime_put_noidle(hif_ctx, RTPM_ID_QOS_NOTIFY);
+		hif_rtpm_put(HIF_RTPM_PUT_NOIDLE, HIF_RTPM_ID_PM_QOS_NOTIFY);
 		hdd_ctx->runtime_pm_prevented = false;
 	}
 
@@ -13296,7 +13301,7 @@ static void hdd_psoc_idle_timeout_callback(void *priv)
 		 * Trigger runtime sync resume before psoc_idle_shutdown
 		 * such that resume can happen successfully
 		 */
-		hif_pm_runtime_sync_resume(hif_ctx, RTPM_ID_SOC_IDLE_SHUTDOWN);
+		qdf_rtpm_sync_resume();
 	}
 
 	hdd_info("Psoc idle timeout elapsed; starting psoc shutdown");
@@ -17883,8 +17888,7 @@ static int hdd_disable_wifi(struct hdd_context *hdd_ctx)
 			 * Trigger runtime sync resume before psoc_idle_shutdown
 			 * such that resume can happen successfully
 			 */
-			hif_pm_runtime_sync_resume(hif_ctx,
-						   RTPM_ID_SOC_IDLE_SHUTDOWN);
+			qdf_rtpm_sync_resume();
 		}
 		ret = pld_idle_shutdown(hdd_ctx->parent_dev,
 					hdd_psoc_idle_shutdown);
@@ -19129,7 +19133,7 @@ void hdd_driver_unload(void)
 		 * Trigger runtime sync resume before setting unload in progress
 		 * such that resume can happen successfully
 		 */
-		hif_pm_runtime_sync_resume(hif_ctx, RTPM_ID_DRIVER_UNLOAD);
+		qdf_rtpm_sync_resume();
 	}
 
 	cds_set_driver_loaded(false);

core/hdd/src/wlan_hdd_power.c

@@ -1223,11 +1223,11 @@ int wlan_hdd_pm_qos_notify(struct notifier_block *nb, unsigned long curr_val,
 	if (!hdd_ctx->runtime_pm_prevented &&
 	    is_any_sta_connected &&
 	    !wlan_hdd_is_cpu_cxpc_allowed(curr_val)) {
-		hif_pm_runtime_get_noresume(hif_ctx, RTPM_ID_QOS_NOTIFY);
+		hif_rtpm_get(HIF_RTPM_GET_NORESUME, HIF_RTPM_ID_PM_QOS_NOTIFY);
 		hdd_ctx->runtime_pm_prevented = true;
 	} else if (hdd_ctx->runtime_pm_prevented &&
 		   wlan_hdd_is_cpu_cxpc_allowed(curr_val)) {
-		hif_pm_runtime_put(hif_ctx, RTPM_ID_QOS_NOTIFY);
+		hif_rtpm_put(HIF_RTPM_PUT_NOIDLE, HIF_RTPM_ID_PM_QOS_NOTIFY);
 		hdd_ctx->runtime_pm_prevented = false;
 	}
 
@@ -2363,13 +2363,10 @@ exit_with_code:
 
 static int _wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy)
 {
-	void *hif_ctx;
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
 	int errno;
 
-	hif_ctx = cds_get_context(QDF_MODULE_ID_HIF);
-	if (hif_ctx)
-		hif_pm_runtime_put(hif_ctx, RTPM_ID_SUSPEND_RESUME);
+	qdf_rtpm_put(QDF_RTPM_PUT, QDF_RTPM_ID_WIPHY_SUSPEND);
 
 	if (!hdd_ctx) {
 		hdd_err_rl("hdd context is null");
@@ -2723,13 +2720,13 @@ static int _wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	if (!hif_ctx)
 		return -EINVAL;
 
-	errno = hif_pm_runtime_get_sync(hif_ctx, RTPM_ID_SUSPEND_RESUME);
+	errno = qdf_rtpm_get(QDF_RTPM_GET_SYNC, QDF_RTPM_ID_WIPHY_SUSPEND);
 	if (errno)
 		return errno;
 
 	errno = __wlan_hdd_cfg80211_suspend_wlan(wiphy, wow);
 	if (errno) {
-		hif_pm_runtime_put(hif_ctx, RTPM_ID_SUSPEND_RESUME);
+		qdf_rtpm_put(QDF_RTPM_PUT, QDF_RTPM_ID_WIPHY_SUSPEND);
 		return errno;
 	}
 

core/hdd/src/wlan_hdd_tx_rx.c

@@ -3876,27 +3876,6 @@ void hdd_dp_cfg_update(struct wlan_objmgr_psoc *psoc,
 	hdd_dp_nud_tracking_cfg_update(config, psoc);
 }
 
-bool wlan_hdd_rx_rpm_mark_last_busy(struct hdd_context *hdd_ctx,
-				    void *hif_ctx)
-{
-	uint64_t duration_us, dp_rx_busy_us, current_us;
-	uint32_t rpm_delay_ms;
-
-	if (!hif_pm_runtime_is_dp_rx_busy(hif_ctx))
-		return false;
-
-	dp_rx_busy_us = hif_pm_runtime_get_dp_rx_busy_mark(hif_ctx);
-	current_us = qdf_get_log_timestamp_usecs();
-	duration_us = (unsigned long)((ULONG_MAX - dp_rx_busy_us) +
-				      current_us + 1);
-	rpm_delay_ms = ucfg_pmo_get_runtime_pm_delay(hdd_ctx->psoc);
-
-	if (duration_us < (rpm_delay_ms * 1000))
-		return true;
-	else
-		return false;
-}
-
 void hdd_sta_notify_tx_comp_cb(qdf_nbuf_t skb, void *ctx, uint16_t flag)
 {
 	struct hdd_adapter *adapter = ctx;