qcacld-3.0: Rename some ucfg APIs of PMO

To keep names of PMO ucfg APIs consistent, change some of them from
"pmo_ucfg_xxx" to "ucfg_pmo_xxx".

Change-Id: I77165be8c5c408c3f91f84a477c15be1c6ea15e8
CRs-Fixed: 2334109

components/pmo/dispatcher/src/wlan_pmo_ucfg_api.c

@@ -106,80 +106,85 @@ bool ucfg_pmo_is_vdev_supports_offload(struct wlan_objmgr_vdev *vdev)
 	return pmo_core_is_vdev_supports_offload(vdev);
 }
 
-void pmo_ucfg_enable_wakeup_event(struct wlan_objmgr_psoc *psoc,
-	uint32_t vdev_id, WOW_WAKE_EVENT_TYPE wow_event)
+void ucfg_pmo_enable_wakeup_event(struct wlan_objmgr_psoc *psoc,
+				  uint32_t vdev_id,
+				  WOW_WAKE_EVENT_TYPE wow_event)
 {
 	pmo_core_enable_wakeup_event(psoc, vdev_id, wow_event);
 }
 
-void pmo_ucfg_disable_wakeup_event(struct wlan_objmgr_psoc *psoc,
-	uint32_t vdev_id, WOW_WAKE_EVENT_TYPE wow_event)
+void ucfg_pmo_disable_wakeup_event(struct wlan_objmgr_psoc *psoc,
+				   uint32_t vdev_id,
+				   WOW_WAKE_EVENT_TYPE wow_event)
 {
 	pmo_core_disable_wakeup_event(psoc, vdev_id, wow_event);
 }
 
-QDF_STATUS pmo_ucfg_cache_arp_offload_req(struct pmo_arp_req *arp_req)
+QDF_STATUS ucfg_pmo_cache_arp_offload_req(struct pmo_arp_req *arp_req)
 {
 	return pmo_core_cache_arp_offload_req(arp_req);
 }
 
-QDF_STATUS pmo_ucfg_flush_arp_offload_req(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_flush_arp_offload_req(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_flush_arp_offload_req(vdev);
 }
 
-QDF_STATUS pmo_ucfg_enable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
-		enum pmo_offload_trigger trigger)
+QDF_STATUS ucfg_pmo_enable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
+					      enum pmo_offload_trigger trigger)
 {
 	return pmo_core_enable_arp_offload_in_fwr(vdev, trigger);
 }
 
-QDF_STATUS pmo_ucfg_disable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
-		enum pmo_offload_trigger trigger)
+QDF_STATUS
+ucfg_pmo_disable_arp_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
+				    enum pmo_offload_trigger trigger)
 {
 	return pmo_core_disable_arp_offload_in_fwr(vdev, trigger);
 }
 
 QDF_STATUS
-pmo_ucfg_get_arp_offload_params(struct wlan_objmgr_vdev *vdev,
+ucfg_pmo_get_arp_offload_params(struct wlan_objmgr_vdev *vdev,
 				struct pmo_arp_offload_params *params)
 {
 	return pmo_core_get_arp_offload_params(vdev, params);
 }
 
 #ifdef WLAN_NS_OFFLOAD
-QDF_STATUS pmo_ucfg_cache_ns_offload_req(struct pmo_ns_req *ns_req)
+QDF_STATUS ucfg_pmo_cache_ns_offload_req(struct pmo_ns_req *ns_req)
 {
 	return pmo_core_cache_ns_offload_req(ns_req);
 }
 
-QDF_STATUS pmo_ucfg_flush_ns_offload_req(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_flush_ns_offload_req(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_flush_ns_offload_req(vdev);
 }
 
-QDF_STATUS pmo_ucfg_enable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
-		enum pmo_offload_trigger trigger)
+QDF_STATUS
+ucfg_pmo_enable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
+				  enum pmo_offload_trigger trigger)
 {
 	return pmo_core_enable_ns_offload_in_fwr(vdev, trigger);
 }
 
-QDF_STATUS pmo_ucfg_disable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
-		enum pmo_offload_trigger trigger)
+QDF_STATUS
+ucfg_pmo_disable_ns_offload_in_fwr(struct wlan_objmgr_vdev *vdev,
+				   enum pmo_offload_trigger trigger)
 {
 	return pmo_core_disable_ns_offload_in_fwr(vdev, trigger);
 }
 #endif /* WLAN_NS_OFFLOAD */
 
 QDF_STATUS
-pmo_ucfg_get_ns_offload_params(struct wlan_objmgr_vdev *vdev,
+ucfg_pmo_get_ns_offload_params(struct wlan_objmgr_vdev *vdev,
 			       struct pmo_ns_offload_params *params)
 {
 	return pmo_core_get_ns_offload_params(vdev, params);
 }
 
 enum pmo_ns_addr_scope
-pmo_ucfg_ns_addr_scope(uint32_t ipv6_scope)
+ucfg_pmo_ns_addr_scope(uint32_t ipv6_scope)
 {
 	switch (ipv6_scope) {
 	case IPV6_ADDR_SCOPE_NODELOCAL:
@@ -197,19 +202,19 @@ pmo_ucfg_ns_addr_scope(uint32_t ipv6_scope)
 	return PMO_NS_ADDR_SCOPE_INVALID;
 }
 
-QDF_STATUS pmo_ucfg_cache_mc_addr_list(
+QDF_STATUS ucfg_pmo_cache_mc_addr_list(
 		struct pmo_mc_addr_list_params *mc_list_config)
 {
 	return pmo_core_cache_mc_addr_list(mc_list_config);
 }
 
-QDF_STATUS pmo_ucfg_flush_mc_addr_list(struct wlan_objmgr_psoc *psoc,
-	uint8_t vdev_id)
+QDF_STATUS ucfg_pmo_flush_mc_addr_list(struct wlan_objmgr_psoc *psoc,
+				       uint8_t vdev_id)
 {
 	return pmo_core_flush_mc_addr_list(psoc, vdev_id);
 }
 
-QDF_STATUS pmo_ucfg_enable_mc_addr_filtering_in_fwr(
+QDF_STATUS ucfg_pmo_enable_mc_addr_filtering_in_fwr(
 		struct wlan_objmgr_psoc *psoc,
 		uint8_t vdev_id,
 		enum pmo_offload_trigger trigger)
@@ -218,7 +223,7 @@ QDF_STATUS pmo_ucfg_enable_mc_addr_filtering_in_fwr(
 			vdev_id, trigger);
 }
 
-QDF_STATUS pmo_ucfg_disable_mc_addr_filtering_in_fwr(
+QDF_STATUS ucfg_pmo_disable_mc_addr_filtering_in_fwr(
 		struct wlan_objmgr_psoc *psoc,
 		uint8_t vdev_id,
 		enum pmo_offload_trigger trigger)
@@ -227,36 +232,37 @@ QDF_STATUS pmo_ucfg_disable_mc_addr_filtering_in_fwr(
 			vdev_id, trigger);
 }
 
-uint8_t pmo_ucfg_max_mc_addr_supported(struct wlan_objmgr_psoc *psoc)
+uint8_t ucfg_pmo_max_mc_addr_supported(struct wlan_objmgr_psoc *psoc)
 {
 	return pmo_core_max_mc_addr_supported(psoc);
 }
 
 QDF_STATUS
-pmo_ucfg_get_mc_addr_list(struct wlan_objmgr_psoc *psoc,
+ucfg_pmo_get_mc_addr_list(struct wlan_objmgr_psoc *psoc,
 			  uint8_t vdev_id,
 			  struct pmo_mc_addr_list *mc_list_req)
 {
 	return pmo_core_get_mc_addr_list(psoc, vdev_id, mc_list_req);
 }
 
-QDF_STATUS pmo_ucfg_cache_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
-		struct pmo_gtk_req *gtk_req)
+QDF_STATUS
+ucfg_pmo_cache_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
+			       struct pmo_gtk_req *gtk_req)
 {
 	return pmo_core_cache_gtk_offload_req(vdev, gtk_req);
 }
 
-QDF_STATUS pmo_ucfg_flush_gtk_offload_req(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_flush_gtk_offload_req(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_flush_gtk_offload_req(vdev);
 }
 
-QDF_STATUS pmo_ucfg_enable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_enable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_enable_gtk_offload_in_fwr(vdev);
 }
 
-QDF_STATUS pmo_ucfg_disable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_disable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_disable_gtk_offload_in_fwr(vdev);
 }
@@ -278,14 +284,16 @@ uint32_t ucfg_pmo_get_num_packet_filters(struct wlan_objmgr_psoc *psoc)
 	return pmo_get_num_packet_filters(psoc);
 }
 
-QDF_STATUS pmo_ucfg_set_pkt_filter(struct wlan_objmgr_psoc *psoc,
-		struct pmo_rcv_pkt_fltr_cfg *pmo_set_pkt_fltr_req,
-		uint8_t vdev_id)
+QDF_STATUS
+ucfg_pmo_set_pkt_filter(struct wlan_objmgr_psoc *psoc,
+			struct pmo_rcv_pkt_fltr_cfg *pmo_set_pkt_fltr_req,
+			uint8_t vdev_id)
 {
 	return pmo_core_set_pkt_filter(psoc, pmo_set_pkt_fltr_req, vdev_id);
 }
 
-QDF_STATUS pmo_ucfg_clear_pkt_filter(struct wlan_objmgr_psoc *psoc,
+QDF_STATUS ucfg_pmo_clear_pkt_filter(
+		struct wlan_objmgr_psoc *psoc,
 		struct pmo_rcv_pkt_fltr_clear_param *pmo_clr_pkt_fltr_param,
 		uint8_t vdev_id)
 {
@@ -294,167 +302,175 @@ QDF_STATUS pmo_ucfg_clear_pkt_filter(struct wlan_objmgr_psoc *psoc,
 }
 #endif
 
-QDF_STATUS pmo_ucfg_get_gtk_rsp(struct wlan_objmgr_vdev *vdev,
-		struct pmo_gtk_rsp_req *gtk_rsp_req)
+QDF_STATUS ucfg_pmo_get_gtk_rsp(struct wlan_objmgr_vdev *vdev,
+				struct pmo_gtk_rsp_req *gtk_rsp_req)
 {
 	return pmo_core_get_gtk_rsp(vdev, gtk_rsp_req);
 }
 
-void pmo_ucfg_update_extscan_in_progress(struct wlan_objmgr_vdev *vdev,
-	bool value)
+void ucfg_pmo_update_extscan_in_progress(struct wlan_objmgr_vdev *vdev,
+					 bool value)
 {
 	pmo_core_update_extscan_in_progress(vdev, value);
 }
 
-void pmo_ucfg_update_p2plo_in_progress(struct wlan_objmgr_vdev *vdev,
-	bool value)
+void ucfg_pmo_update_p2plo_in_progress(struct wlan_objmgr_vdev *vdev,
+				       bool value)
 {
 	pmo_core_update_p2plo_in_progress(vdev, value);
 }
 
-QDF_STATUS pmo_ucfg_lphb_config_req(struct wlan_objmgr_psoc *psoc,
-		struct pmo_lphb_req *lphb_req, void *lphb_cb_ctx,
-		pmo_lphb_callback callback)
+QDF_STATUS ucfg_pmo_lphb_config_req(struct wlan_objmgr_psoc *psoc,
+				    struct pmo_lphb_req *lphb_req,
+				    void *lphb_cb_ctx,
+				    pmo_lphb_callback callback)
 {
 	return pmo_core_lphb_config_req(psoc, lphb_req, lphb_cb_ctx, callback);
 }
 
-void pmo_ucfg_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc,
-	uint8_t value)
+void ucfg_pmo_psoc_update_power_save_mode(struct wlan_objmgr_psoc *psoc,
+					  uint8_t value)
 {
 	pmo_core_psoc_update_power_save_mode(psoc, value);
 }
 
-void pmo_ucfg_psoc_update_dp_handle(struct wlan_objmgr_psoc *psoc,
-		void *dp_handle)
+void ucfg_pmo_psoc_update_dp_handle(struct wlan_objmgr_psoc *psoc,
+				    void *dp_handle)
 {
 	pmo_core_psoc_update_dp_handle(psoc, dp_handle);
 }
 
-void pmo_ucfg_psoc_update_htc_handle(struct wlan_objmgr_psoc *psoc,
-		void *htc_handle)
+void ucfg_pmo_psoc_update_htc_handle(struct wlan_objmgr_psoc *psoc,
+				     void *htc_handle)
 {
 	pmo_core_psoc_update_htc_handle(psoc, htc_handle);
 }
 
-void pmo_ucfg_psoc_set_hif_handle(struct wlan_objmgr_psoc *psoc,
-		void *hif_handle)
+void ucfg_pmo_psoc_set_hif_handle(struct wlan_objmgr_psoc *psoc,
+				  void *hif_handle)
 {
 	pmo_core_psoc_set_hif_handle(psoc, hif_handle);
 }
 
-void pmo_ucfg_psoc_set_txrx_handle(struct wlan_objmgr_psoc *psoc,
-		void *txrx_handle)
+void ucfg_pmo_psoc_set_txrx_handle(struct wlan_objmgr_psoc *psoc,
+				   void *txrx_handle)
 {
 	pmo_core_psoc_set_txrx_handle(psoc, txrx_handle);
 }
 
-void pmo_ucfg_psoc_handle_initial_wake_up(void *cb_ctx)
+void ucfg_pmo_psoc_handle_initial_wake_up(void *cb_ctx)
 {
 	return pmo_core_psoc_handle_initial_wake_up(cb_ctx);
 }
 
-QDF_STATUS pmo_ucfg_psoc_user_space_suspend_req(struct wlan_objmgr_psoc *psoc,
-		enum qdf_suspend_type type)
+QDF_STATUS
+ucfg_pmo_psoc_user_space_suspend_req(struct wlan_objmgr_psoc *psoc,
+				     enum qdf_suspend_type type)
 {
 	return pmo_core_psoc_user_space_suspend_req(psoc, type);
 }
 
 
-QDF_STATUS pmo_ucfg_psoc_user_space_resume_req(struct wlan_objmgr_psoc *psoc,
-		enum qdf_suspend_type type)
+QDF_STATUS
+ucfg_pmo_psoc_user_space_resume_req(struct wlan_objmgr_psoc *psoc,
+				    enum qdf_suspend_type type)
 {
 	return pmo_core_psoc_user_space_resume_req(psoc, type);
 }
 
-QDF_STATUS pmo_ucfg_psoc_bus_suspend_req(struct wlan_objmgr_psoc *psoc,
-		enum qdf_suspend_type type,
-		struct pmo_wow_enable_params *wow_params)
+QDF_STATUS
+ucfg_pmo_psoc_bus_suspend_req(struct wlan_objmgr_psoc *psoc,
+			      enum qdf_suspend_type type,
+			      struct pmo_wow_enable_params *wow_params)
 {
 	return pmo_core_psoc_bus_suspend_req(psoc, type, wow_params);
 }
 
 #ifdef FEATURE_RUNTIME_PM
-QDF_STATUS pmo_ucfg_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
+QDF_STATUS ucfg_pmo_psoc_bus_runtime_suspend(struct wlan_objmgr_psoc *psoc,
 					     pmo_pld_auto_suspend_cb pld_cb)
 {
 	return pmo_core_psoc_bus_runtime_suspend(psoc, pld_cb);
 }
 
-QDF_STATUS pmo_ucfg_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
+QDF_STATUS ucfg_pmo_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
 					    pmo_pld_auto_suspend_cb pld_cb)
 {
 	return pmo_core_psoc_bus_runtime_resume(psoc, pld_cb);
 }
 #endif
 
-QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
-		int disable_target_intr)
+QDF_STATUS
+ucfg_pmo_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
+			     int disable_target_intr)
 {
 	return pmo_core_psoc_suspend_target(psoc, disable_target_intr);
 }
 
-QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
-		struct pmo_wow_add_pattern *ptrn)
+QDF_STATUS
+ucfg_pmo_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+			      struct pmo_wow_add_pattern *ptrn)
 {
 	return pmo_core_add_wow_user_pattern(vdev, ptrn);
 }
 
-QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
-		uint8_t pattern_id)
+QDF_STATUS
+ucfg_pmo_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+			      uint8_t pattern_id)
 {
 	return pmo_core_del_wow_user_pattern(vdev, pattern_id);
 }
 
-QDF_STATUS pmo_ucfg_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
-		enum qdf_suspend_type type)
+QDF_STATUS
+ucfg_pmo_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
+			     enum qdf_suspend_type type)
 {
 	return pmo_core_psoc_bus_resume_req(psoc, type);
 }
 
-bool pmo_ucfg_get_wow_bus_suspend(struct wlan_objmgr_psoc *psoc)
+bool ucfg_pmo_get_wow_bus_suspend(struct wlan_objmgr_psoc *psoc)
 {
 	return pmo_core_get_wow_bus_suspend(psoc);
 }
 
-int pmo_ucfg_psoc_is_target_wake_up_received(struct wlan_objmgr_psoc *psoc)
+int ucfg_pmo_psoc_is_target_wake_up_received(struct wlan_objmgr_psoc *psoc)
 {
 	return pmo_core_psoc_is_target_wake_up_received(psoc);
 }
 
-int pmo_ucfg_psoc_clear_target_wake_up(struct wlan_objmgr_psoc *psoc)
+int ucfg_pmo_psoc_clear_target_wake_up(struct wlan_objmgr_psoc *psoc)
 {
 	return pmo_core_psoc_clear_target_wake_up(psoc);
 }
 
-void pmo_ucfg_psoc_target_suspend_acknowledge(void *context, bool wow_nack)
+void ucfg_pmo_psoc_target_suspend_acknowledge(void *context, bool wow_nack)
 {
 	pmo_core_psoc_target_suspend_acknowledge(context, wow_nack);
 }
 
-void pmo_ucfg_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc)
+void ucfg_pmo_psoc_wakeup_host_event_received(struct wlan_objmgr_psoc *psoc)
 {
 	pmo_core_psoc_wakeup_host_event_received(psoc);
 }
 
-QDF_STATUS pmo_ucfg_enable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_enable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_enable_hw_filter_in_fwr(vdev);
 }
 
-QDF_STATUS pmo_ucfg_disable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
+QDF_STATUS ucfg_pmo_disable_hw_filter_in_fwr(struct wlan_objmgr_vdev *vdev)
 {
 	return pmo_core_disable_hw_filter_in_fwr(vdev);
 }
 
-QDF_STATUS pmo_ucfg_config_listen_interval(struct wlan_objmgr_vdev *vdev,
-					     uint32_t listen_interval)
+QDF_STATUS ucfg_pmo_config_listen_interval(struct wlan_objmgr_vdev *vdev,
+					   uint32_t listen_interval)
 {
 	return pmo_core_config_listen_interval(vdev, listen_interval);
 }
 
-QDF_STATUS pmo_ucfg_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
-				       uint32_t mod_dtim)
+QDF_STATUS ucfg_pmo_config_modulated_dtim(struct wlan_objmgr_vdev *vdev,
+					  uint32_t mod_dtim)
 {
 	return pmo_core_config_modulated_dtim(vdev, mod_dtim);
 }

core/cds/src/cds_api.c

@@ -536,8 +536,8 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 	htcInfo.pContext = ol_ctx;
 	htcInfo.TargetFailure = ol_target_failure;
 	htcInfo.TargetSendSuspendComplete =
-		pmo_ucfg_psoc_target_suspend_acknowledge;
-	htcInfo.target_initial_wakeup_cb = pmo_ucfg_psoc_handle_initial_wake_up;
+		ucfg_pmo_psoc_target_suspend_acknowledge;
+	htcInfo.target_initial_wakeup_cb = ucfg_pmo_psoc_handle_initial_wake_up;
 	htcInfo.target_psoc = (void *)psoc;
 	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 
@@ -550,7 +550,7 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 		status = QDF_STATUS_E_FAILURE;
 		goto err_bmi_close;
 	}
-	pmo_ucfg_psoc_update_htc_handle(psoc, (void *)gp_cds_context->htc_ctx);
+	ucfg_pmo_psoc_update_htc_handle(psoc, (void *)gp_cds_context->htc_ctx);
 
 	status = bmi_done(ol_ctx);
 	if (QDF_IS_STATUS_ERROR(status)) {
@@ -618,7 +618,7 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 	}
 
 	wlan_psoc_set_dp_handle(psoc, gp_cds_context->dp_soc);
-	pmo_ucfg_psoc_update_dp_handle(psoc, gp_cds_context->dp_soc);
+	ucfg_pmo_psoc_update_dp_handle(psoc, gp_cds_context->dp_soc);
 	ucfg_ocb_update_dp_handle(psoc, gp_cds_context->dp_soc);
 
 	cds_set_ac_specs_params(cds_cfg);
@@ -667,7 +667,7 @@ err_soc_detach:
 	gp_cds_context->dp_soc = NULL;
 
 	ucfg_ocb_update_dp_handle(psoc, NULL);
-	pmo_ucfg_psoc_update_dp_handle(psoc, NULL);
+	ucfg_pmo_psoc_update_dp_handle(psoc, NULL);
 	wlan_psoc_set_dp_handle(psoc, NULL);
 
 err_wma_close:
@@ -679,7 +679,7 @@ err_htc_close:
 	if (gp_cds_context->htc_ctx) {
 		htc_destroy(gp_cds_context->htc_ctx);
 		gp_cds_context->htc_ctx = NULL;
-		pmo_ucfg_psoc_update_htc_handle(psoc, NULL);
+		ucfg_pmo_psoc_update_htc_handle(psoc, NULL);
 	}
 
 err_bmi_close:
@@ -732,7 +732,7 @@ QDF_STATUS cds_dp_open(struct wlan_objmgr_psoc *psoc)
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 		goto pdev_detach;
 
-	pmo_ucfg_psoc_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
+	ucfg_pmo_psoc_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
 	ucfg_ocb_set_txrx_handle(psoc, gp_cds_context->pdev_txrx_ctx);
 
 	cds_debug("CDS successfully Opened");
@@ -1003,7 +1003,7 @@ static inline void cds_suspend_target(tp_wma_handle wma_handle)
 {
 	QDF_STATUS status;
 	/* Suspend the target and disable interrupt */
-	status = pmo_ucfg_psoc_suspend_target(wma_handle->psoc, 0);
+	status = ucfg_pmo_psoc_suspend_target(wma_handle->psoc, 0);
 	if (status)
 		cds_err("Failed to suspend target, status = %d", status);
 }
@@ -1012,7 +1012,7 @@ static inline void cds_suspend_target(tp_wma_handle wma_handle)
 {
 	QDF_STATUS status;
 	/* Suspend the target and disable interrupt */
-	status = pmo_ucfg_psoc_suspend_target(wma_handle->psoc, 1);
+	status = ucfg_pmo_psoc_suspend_target(wma_handle->psoc, 1);
 	if (status)
 		cds_err("Failed to suspend target, status = %d", status);
 }
@@ -1106,7 +1106,7 @@ QDF_STATUS cds_close(struct wlan_objmgr_psoc *psoc)
 
 	if (gp_cds_context->htc_ctx) {
 		htc_destroy(gp_cds_context->htc_ctx);
-		pmo_ucfg_psoc_update_htc_handle(psoc, NULL);
+		ucfg_pmo_psoc_update_htc_handle(psoc, NULL);
 		gp_cds_context->htc_ctx = NULL;
 	}
 
@@ -1125,7 +1125,7 @@ QDF_STATUS cds_close(struct wlan_objmgr_psoc *psoc)
 	gp_cds_context->mac_context = NULL;
 
 	cdp_soc_detach(gp_cds_context->dp_soc);
-	pmo_ucfg_psoc_update_dp_handle(psoc, NULL);
+	ucfg_pmo_psoc_update_dp_handle(psoc, NULL);
 	wlan_psoc_set_dp_handle(psoc, NULL);
 
 	cds_shutdown_notifier_purge();
@@ -1173,7 +1173,7 @@ QDF_STATUS cds_dp_close(struct wlan_objmgr_psoc *psoc)
 		       (struct cdp_pdev *)ctx, 1);
 
 	cds_set_context(QDF_MODULE_ID_TXRX, NULL);
-	pmo_ucfg_psoc_set_txrx_handle(psoc, NULL);
+	ucfg_pmo_psoc_set_txrx_handle(psoc, NULL);
 
 	return QDF_STATUS_SUCCESS;
 }

core/hdd/src/wlan_hdd_assoc.c

@@ -1854,7 +1854,7 @@ static QDF_STATUS hdd_dis_connect_handler(struct hdd_adapter *adapter,
 					       eConnectionState_NotConnected);
 		 hdd_set_roaming_in_progress(false);
 	}
-	pmo_ucfg_flush_gtk_offload_req(adapter->vdev);
+	ucfg_pmo_flush_gtk_offload_req(adapter->vdev);
 
 	if ((QDF_STA_MODE == adapter->device_mode) ||
 	    (QDF_P2P_CLIENT_MODE == adapter->device_mode)) {

core/hdd/src/wlan_hdd_cfg80211.c

@@ -4821,7 +4821,7 @@ void wlan_hdd_save_gtk_offload_params(struct hdd_adapter *adapter,
 	for (i = 0; i < 8; i++)
 		buf[7 - i] = replay_ctr[i];
 
-	status = pmo_ucfg_cache_gtk_offload_req(adapter->vdev, gtk_req);
+	status = ucfg_pmo_cache_gtk_offload_req(adapter->vdev, gtk_req);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("Failed to cache GTK Offload");
 
@@ -5590,7 +5590,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 		modulated_dtim = nla_get_u32(
 			tb[QCA_WLAN_VENDOR_ATTR_CONFIG_MODULATED_DTIM]);
 
-		status = pmo_ucfg_config_modulated_dtim(adapter->vdev,
+		status = ucfg_pmo_config_modulated_dtim(adapter->vdev,
 							modulated_dtim);
 		if (QDF_STATUS_SUCCESS != status)
 			ret_val = -EPERM;
@@ -5606,7 +5606,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 			return -EINVAL;
 		}
 
-		status = pmo_ucfg_config_listen_interval(adapter->vdev,
+		status = ucfg_pmo_config_listen_interval(adapter->vdev,
 							 override_li);
 		if (status != QDF_STATUS_SUCCESS)
 			ret_val = -EPERM;
@@ -14944,7 +14944,7 @@ static int wlan_hdd_cfg80211_connect_start(struct hdd_adapter *adapter,
 			}
 		}
 #endif
-		pmo_ucfg_flush_gtk_offload_req(adapter->vdev);
+		ucfg_pmo_flush_gtk_offload_req(adapter->vdev);
 		roam_profile->csrPersona = adapter->device_mode;
 
 		if (operatingChannel) {
@@ -18638,7 +18638,7 @@ int __wlan_hdd_cfg80211_set_rekey_data(struct wiphy *wiphy,
 	wlan_hdd_copy_gtk_kek(gtk_req, data);
 	qdf_mem_copy(gtk_req->kck, data->kck, NL80211_KCK_LEN);
 	gtk_req->is_fils_connection = hdd_is_fils_connection(adapter);
-	status = pmo_ucfg_cache_gtk_offload_req(adapter->vdev, gtk_req);
+	status = ucfg_pmo_cache_gtk_offload_req(adapter->vdev, gtk_req);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to cache GTK Offload");
 		result = qdf_status_to_os_return(status);
@@ -18948,9 +18948,10 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
 
 		qdf_mem_zero(hb_params, sizeof(*hb_params));
 		qdf_mem_copy(hb_params, buf, buf_len);
-		status = pmo_ucfg_lphb_config_req(hdd_ctx->psoc,
+		status = ucfg_pmo_lphb_config_req(
+					hdd_ctx->psoc,
 					hb_params, (void *)hdd_ctx,
-					    wlan_hdd_cfg80211_lphb_ind_handler);
+					wlan_hdd_cfg80211_lphb_ind_handler);
 		if (status != QDF_STATUS_SUCCESS)
 			hdd_err("LPHB Config Fail, disable");
 

core/hdd/src/wlan_hdd_debugfs_offload.c

@@ -69,7 +69,7 @@ wlan_hdd_mc_addr_list_info_debugfs(struct hdd_context *hdd_ctx,
 		return length;
 	}
 
-	status = pmo_ucfg_get_mc_addr_list(hdd_ctx->psoc,
+	status = ucfg_pmo_get_mc_addr_list(hdd_ctx->psoc,
 					   adapter->session_id,
 					   &mc_addr_list);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -142,7 +142,7 @@ wlan_hdd_arp_offload_info_debugfs(struct hdd_context *hdd_ctx,
 	struct pmo_arp_offload_params info = {0};
 	QDF_STATUS status;
 
-	status = pmo_ucfg_get_arp_offload_params(adapter->vdev,
+	status = ucfg_pmo_get_arp_offload_params(adapter->vdev,
 						 &info);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		ret_val = scnprintf(buf, buf_avail_len,
@@ -232,7 +232,7 @@ wlan_hdd_ns_offload_info_debugfs(struct hdd_context *hdd_ctx,
 	QDF_STATUS status;
 	uint32_t i;
 
-	status = pmo_ucfg_get_ns_offload_params(adapter->vdev,
+	status = ucfg_pmo_get_ns_offload_params(adapter->vdev,
 						&info);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		ret = scnprintf(buf, buf_avail_len,

core/hdd/src/wlan_hdd_driver_ops.c

@@ -263,7 +263,7 @@ int hdd_hif_open(struct device *dev, void *bdev, const struct hif_bus_id *bid,
 
 	hif_set_ce_service_max_yield_time(hif_ctx,
 				hdd_ctx->config->ce_service_max_yield_time);
-	pmo_ucfg_psoc_set_hif_handle(hdd_ctx->psoc, hif_ctx);
+	ucfg_pmo_psoc_set_hif_handle(hdd_ctx->psoc, hif_ctx);
 	hif_set_ce_service_max_rx_ind_flush(hif_ctx,
 				hdd_ctx->config->ce_service_max_rx_ind_flush);
 	return 0;
@@ -291,7 +291,7 @@ void hdd_hif_close(struct hdd_context *hdd_ctx, void *hif_ctx)
 	hdd_deinit_cds_hif_context();
 	hif_close(hif_ctx);
 
-	pmo_ucfg_psoc_set_hif_handle(hdd_ctx->psoc, NULL);
+	ucfg_pmo_psoc_set_hif_handle(hdd_ctx->psoc, NULL);
 }
 
 /**
@@ -808,7 +808,7 @@ static int __wlan_hdd_bus_suspend(struct wow_enable_params wow_params)
 		goto resume_cdp;
 	}
 
-	status = pmo_ucfg_psoc_bus_suspend_req(hdd_ctx->psoc,
+	status = ucfg_pmo_psoc_bus_suspend_req(hdd_ctx->psoc,
 					       QDF_SYSTEM_SUSPEND,
 					       &pmo_params);
 	err = qdf_status_to_os_return(status);
@@ -827,7 +827,7 @@ static int __wlan_hdd_bus_suspend(struct wow_enable_params wow_params)
 	return 0;
 
 resume_pmo:
-	status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->psoc,
+	status = ucfg_pmo_psoc_bus_resume_req(hdd_ctx->psoc,
 					      QDF_SYSTEM_SUSPEND);
 	QDF_BUG(QDF_IS_STATUS_SUCCESS(status));
 
@@ -906,7 +906,7 @@ static int __wlan_hdd_bus_suspend_noirq(void)
 	if (errno)
 		goto done;
 
-	errno = pmo_ucfg_psoc_is_target_wake_up_received(hdd_ctx->psoc);
+	errno = ucfg_pmo_psoc_is_target_wake_up_received(hdd_ctx->psoc);
 	if (errno == -EAGAIN) {
 		hdd_err("Firmware attempting wakeup, try again");
 		wlan_hdd_inc_suspend_stats(hdd_ctx,
@@ -998,8 +998,8 @@ static int __wlan_hdd_bus_resume(void)
 		goto out;
 	}
 
-	qdf_status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->psoc,
-			QDF_SYSTEM_SUSPEND);
+	qdf_status = ucfg_pmo_psoc_bus_resume_req(hdd_ctx->psoc,
+						  QDF_SYSTEM_SUSPEND);
 	status = qdf_status_to_os_return(qdf_status);
 	if (status) {
 		hdd_err("Failed pmo bus resume");
@@ -1080,7 +1080,7 @@ static int __wlan_hdd_bus_resume_noirq(void)
 	if (NULL == hif_ctx)
 		return -EINVAL;
 
-	qdf_status = pmo_ucfg_psoc_clear_target_wake_up(hdd_ctx->psoc);
+	qdf_status = ucfg_pmo_psoc_clear_target_wake_up(hdd_ctx->psoc);
 	QDF_BUG(!qdf_status);
 
 	status = hif_bus_resume_noirq(hif_ctx);
@@ -1178,7 +1178,7 @@ static int __wlan_hdd_runtime_suspend(struct device *dev)
 		return -EBUSY;
 	}
 
-	status = pmo_ucfg_psoc_bus_runtime_suspend(hdd_ctx->psoc,
+	status = ucfg_pmo_psoc_bus_runtime_suspend(hdd_ctx->psoc,
 						   hdd_pld_runtime_suspend_cb);
 	err = qdf_status_to_os_return(status);
 
@@ -1246,7 +1246,7 @@ static int __wlan_hdd_runtime_resume(struct device *dev)
 		return 0;
 	}
 
-	status = pmo_ucfg_psoc_bus_runtime_resume(hdd_ctx->psoc,
+	status = ucfg_pmo_psoc_bus_runtime_resume(hdd_ctx->psoc,
 						  hdd_pld_runtime_resume_cb);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("PMO Runtime resume failed: %d", status);

core/hdd/src/wlan_hdd_main.c

@@ -3411,9 +3411,9 @@ static void __hdd_set_multicast_list(struct net_device *dev)
 			pmo_mc_list_change_notify);
 	} else {
 		mc_count = netdev_mc_count(dev);
-		if (mc_count > pmo_ucfg_max_mc_addr_supported(psoc)) {
+		if (mc_count > ucfg_pmo_max_mc_addr_supported(psoc)) {
 			hdd_debug("Exceeded max MC filter addresses (%d). Allowing all MC frames by disabling MC address filtering",
-				  pmo_ucfg_max_mc_addr_supported(psoc));
+				  ucfg_pmo_max_mc_addr_supported(psoc));
 			hdd_disable_and_flush_mc_addr_list(adapter,
 				pmo_mc_list_change_notify);
 			goto free_req;
@@ -3749,9 +3749,9 @@ int hdd_vdev_ready(struct hdd_adapter *adapter)
 		return qdf_status_to_os_return(status);
 
 	if (wma_capability_enhanced_mcast_filter())
-		status = pmo_ucfg_enhanced_mc_filter_enable(adapter->vdev);
+		status = ucfg_pmo_enhanced_mc_filter_enable(adapter->vdev);
 	else
-		status = pmo_ucfg_enhanced_mc_filter_disable(adapter->vdev);
+		status = ucfg_pmo_enhanced_mc_filter_disable(adapter->vdev);
 
 	return qdf_status_to_os_return(status);
 }

core/hdd/src/wlan_hdd_packet_filter.c

@@ -212,10 +212,11 @@ int wlan_hdd_set_filter(struct hdd_context *hdd_ctx,
 				request->params_data[i].data_mask[5]);
 		}
 
-		if (QDF_STATUS_SUCCESS !=
-			pmo_ucfg_set_pkt_filter(hdd_ctx->psoc,
-				pmo_set_pkt_fltr_req,
-				sessionId)) {
+
+		status= ucfg_pmo_set_pkt_filter(hdd_ctx->psoc,
+						pmo_set_pkt_fltr_req,
+						sessionId);
+		if (QDF_IS_STATUS_ERROR(status)) {
 			hdd_err("Failure to execute Set Filter");
 			status = QDF_STATUS_E_INVAL;
 			goto out;
@@ -235,10 +236,10 @@ int wlan_hdd_set_filter(struct hdd_context *hdd_ctx,
 		}
 
 		pmo_clr_pkt_fltr_param->filter_id = request->filter_id;
-		if (QDF_STATUS_SUCCESS !=
-			pmo_ucfg_clear_pkt_filter(hdd_ctx->psoc,
-			    pmo_clr_pkt_fltr_param,
-			    sessionId)) {
+		status = ucfg_pmo_clear_pkt_filter(hdd_ctx->psoc,
+						   pmo_clr_pkt_fltr_param,
+						   sessionId);
+		if (QDF_IS_STATUS_ERROR(status)) {
 			hdd_err("Failure to execute Clear Filter");
 			status = QDF_STATUS_E_INVAL;
 			goto out;

core/hdd/src/wlan_hdd_power.c

@@ -136,7 +136,7 @@ static void hdd_enable_gtk_offload(struct hdd_adapter *adapter)
 {
 	QDF_STATUS status;
 
-	status = pmo_ucfg_enable_gtk_offload_in_fwr(adapter->vdev);
+	status = ucfg_pmo_enable_gtk_offload_in_fwr(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_info("Failed to enable gtk offload");
 }
@@ -160,14 +160,14 @@ static void hdd_disable_gtk_offload(struct hdd_adapter *adapter)
 	/* Passing as void* as PMO does not know legacy HDD adapter type */
 	gtk_rsp_request.callback_context = (void *)adapter;
 
-	status = pmo_ucfg_get_gtk_rsp(adapter->vdev, &gtk_rsp_request);
+	status = ucfg_pmo_get_gtk_rsp(adapter->vdev, &gtk_rsp_request);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to send get gtk rsp status:%d", status);
 		return;
 	}
 
 	hdd_debug("send get_gtk_rsp successful");
-	status = pmo_ucfg_disable_gtk_offload_in_fwr(adapter->vdev);
+	status = ucfg_pmo_disable_gtk_offload_in_fwr(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_info("Failed to disable gtk offload");
 }
@@ -279,7 +279,7 @@ static int hdd_fill_ipv6_uc_addr(struct inet6_dev *idev,
 			qdf_mem_copy(ipv6_uc_addr[*count], &ifa->addr.s6_addr,
 				sizeof(ifa->addr.s6_addr));
 			ipv6addr_type[*count] = PMO_IPV6_ADDR_UC_TYPE;
-			scope_array[*count] = pmo_ucfg_ns_addr_scope(scope);
+			scope_array[*count] = ucfg_pmo_ns_addr_scope(scope);
 			hdd_debug("Index %d scope = %s UC-Address: %pI6",
 				*count, (scope == IPV6_ADDR_SCOPE_LINKLOCAL) ?
 				"LINK LOCAL" : "GLOBAL", ipv6_uc_addr[*count]);
@@ -329,7 +329,7 @@ static int hdd_fill_ipv6_ac_addr(struct inet6_dev *idev,
 			qdf_mem_copy(ipv6_ac_addr[*count], &ifaca->aca_addr,
 				sizeof(ifaca->aca_addr));
 			ipv6addr_type[*count] = PMO_IPV6_ADDR_AC_TYPE;
-			scope_array[*count] = pmo_ucfg_ns_addr_scope(scope);
+			scope_array[*count] = ucfg_pmo_ns_addr_scope(scope);
 			hdd_debug("Index %d scope = %s AC-Address: %pI6",
 				*count, (scope == IPV6_ADDR_SCOPE_LINKLOCAL) ?
 				"LINK LOCAL" : "GLOBAL", ipv6_ac_addr[*count]);
@@ -397,14 +397,14 @@ void hdd_enable_ns_offload(struct hdd_adapter *adapter,
 	}
 
 	/* cache ns request */
-	status = pmo_ucfg_cache_ns_offload_req(ns_req);
+	status = ucfg_pmo_cache_ns_offload_req(ns_req);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Failed to cache ns request; status:%d", status);
 		goto free_req;
 	}
 
 	/* enable ns request */
-	status = pmo_ucfg_enable_ns_offload_in_fwr(adapter->vdev, trigger);
+	status = ucfg_pmo_enable_ns_offload_in_fwr(adapter->vdev, trigger);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Failed to enable ns offload; status:%d", status);
 		goto free_req;
@@ -425,13 +425,13 @@ void hdd_disable_ns_offload(struct hdd_adapter *adapter,
 	QDF_STATUS status;
 
 	hdd_enter();
-	status = pmo_ucfg_flush_ns_offload_req(adapter->vdev);
+	status = ucfg_pmo_flush_ns_offload_req(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to flush NS Offload");
 		goto out;
 	}
 
-	status = pmo_ucfg_disable_ns_offload_in_fwr(adapter->vdev, trigger);
+	status = ucfg_pmo_disable_ns_offload_in_fwr(adapter->vdev, trigger);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("Failed to disable NS Offload");
 	else
@@ -491,7 +491,7 @@ static void hdd_enable_hw_filter(struct hdd_adapter *adapter)
 
 	hdd_enter();
 
-	status = pmo_ucfg_enable_hw_filter_in_fwr(adapter->vdev);
+	status = ucfg_pmo_enable_hw_filter_in_fwr(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_info("Failed to enable hardware filter");
 
@@ -504,7 +504,7 @@ static void hdd_disable_hw_filter(struct hdd_adapter *adapter)
 
 	hdd_enter();
 
-	status = pmo_ucfg_disable_hw_filter_in_fwr(adapter->vdev);
+	status = ucfg_pmo_disable_hw_filter_in_fwr(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_info("Failed to disable hardware filter");
 
@@ -886,13 +886,13 @@ void hdd_enable_arp_offload(struct hdd_adapter *adapter,
 
 	arp_req->ipv4_addr = (uint32_t)ifa->ifa_local;
 
-	status = pmo_ucfg_cache_arp_offload_req(arp_req);
+	status = ucfg_pmo_cache_arp_offload_req(arp_req);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("failed to cache arp offload req; status:%d", status);
 		goto free_req;
 	}
 
-	status = pmo_ucfg_enable_arp_offload_in_fwr(adapter->vdev, trigger);
+	status = ucfg_pmo_enable_arp_offload_in_fwr(adapter->vdev, trigger);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("failed arp offload config in fw; status:%d", status);
 		goto free_req;
@@ -913,13 +913,13 @@ void hdd_disable_arp_offload(struct hdd_adapter *adapter,
 	QDF_STATUS status;
 
 	hdd_enter();
-	status = pmo_ucfg_flush_arp_offload_req(adapter->vdev);
+	status = ucfg_pmo_flush_arp_offload_req(adapter->vdev);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to flush arp Offload");
 		goto out;
 	}
 
-	status = pmo_ucfg_disable_arp_offload_in_fwr(adapter->vdev,
+	status = ucfg_pmo_disable_arp_offload_in_fwr(adapter->vdev,
 						     trigger);
 	if (status == QDF_STATUS_SUCCESS)
 		hdd_wlan_offload_event(PMO_IPV4_ARP_REPLY_OFFLOAD,
@@ -944,7 +944,7 @@ void hdd_enable_mc_addr_filtering(struct hdd_adapter *adapter,
 	if (!hdd_adapter_is_connected_sta(adapter))
 		goto out;
 
-	status = pmo_ucfg_enable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
+	status = ucfg_pmo_enable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
 							  adapter->session_id,
 							  trigger);
 	if (QDF_IS_STATUS_ERROR(status))
@@ -968,7 +968,7 @@ void hdd_disable_mc_addr_filtering(struct hdd_adapter *adapter,
 	if (!hdd_adapter_is_connected_sta(adapter))
 		goto out;
 
-	status = pmo_ucfg_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
+	status = ucfg_pmo_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
 							   adapter->session_id,
 							   trigger);
 	if (QDF_IS_STATUS_ERROR(status))
@@ -983,7 +983,7 @@ int hdd_cache_mc_addr_list(struct pmo_mc_addr_list_params *mc_list_config)
 	QDF_STATUS status;
 
 	hdd_enter();
-	status = pmo_ucfg_cache_mc_addr_list(mc_list_config);
+	status = ucfg_pmo_cache_mc_addr_list(mc_list_config);
 	hdd_exit();
 
 	return qdf_status_to_os_return(status);
@@ -1001,14 +1001,14 @@ void hdd_disable_and_flush_mc_addr_list(struct hdd_adapter *adapter,
 		goto flush_mc_list;
 
 	/* disable mc list first because the mc list is cached in PMO */
-	status = pmo_ucfg_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
+	status = ucfg_pmo_disable_mc_addr_filtering_in_fwr(hdd_ctx->psoc,
 							   adapter->session_id,
 							   trigger);
 	if (QDF_IS_STATUS_ERROR(status))
 		hdd_err("failed to disable mc list; status:%d", status);
 
 flush_mc_list:
-	status = pmo_ucfg_flush_mc_addr_list(hdd_ctx->psoc,
+	status = ucfg_pmo_flush_mc_addr_list(hdd_ctx->psoc,
 					     adapter->session_id);
 	if (QDF_IS_STATUS_ERROR(status))
 		hdd_err("failed to flush mc list; status:%d", status);
@@ -1087,8 +1087,8 @@ hdd_suspend_wlan(void)
 		hdd_update_conn_state_mask(adapter, &conn_state_mask);
 	}
 
-	status = pmo_ucfg_psoc_user_space_suspend_req(hdd_ctx->psoc,
-			QDF_SYSTEM_SUSPEND);
+	status = ucfg_pmo_psoc_user_space_suspend_req(hdd_ctx->psoc,
+						      QDF_SYSTEM_SUSPEND);
 	if (status != QDF_STATUS_SUCCESS)
 		return -EAGAIN;
 
@@ -1146,7 +1146,7 @@ static int hdd_resume_wlan(void)
 	}
 
 	ucfg_ipa_resume(hdd_ctx->pdev);
-	status = pmo_ucfg_psoc_user_space_resume_req(hdd_ctx->psoc,
+	status = ucfg_pmo_psoc_user_space_resume_req(hdd_ctx->psoc,
 						     QDF_SYSTEM_SUSPEND);
 	if (QDF_IS_STATUS_ERROR(status))
 		return qdf_status_to_os_return(status);

core/hdd/src/wlan_hdd_wowl.c

@@ -221,7 +221,7 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 		localPattern.session_id = sessionId;
 
 		/* Register the pattern downstream */
-		status = pmo_ucfg_add_wow_user_pattern(
+		status = ucfg_pmo_add_wow_user_pattern(
 					adapter->vdev, &localPattern);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			/* Add failed, so invalidate the local storage */
@@ -281,7 +281,7 @@ bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 	if (!patternFound)
 		return false;
 
-	status = pmo_ucfg_del_wow_user_pattern(adapter->vdev, id);
+	status = ucfg_pmo_del_wow_user_pattern(adapter->vdev, id);
 	if (QDF_IS_STATUS_ERROR(status))
 		return false;
 
@@ -388,7 +388,7 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
 	}
 
 	/* Register the pattern downstream */
-	qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
+	qdf_ret_status = ucfg_pmo_add_wow_user_pattern(
 				adapter->vdev, &localPattern);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
 		hdd_err("pmo_wow_user_pattern failed with error code (%d).",
@@ -435,7 +435,7 @@ bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
 		return false;
 	}
 
-	qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
+	qdf_ret_status = ucfg_pmo_del_wow_user_pattern(
 				adapter->vdev, pattern_idx);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
 		hdd_err("sme_wowl_del_bcast_pattern failed with error code (%d).",

core/wma/src/wma_data.c

@@ -1525,7 +1525,7 @@ int wma_mcc_vdev_tx_pause_evt_handler(void *handle, uint8_t *event,
 		return -EINVAL;
 	}
 
-	if (pmo_ucfg_get_wow_bus_suspend(wma->psoc)) {
+	if (ucfg_pmo_get_wow_bus_suspend(wma->psoc)) {
 		WMA_LOGD(" Suspend is in progress: Pause/Unpause Tx is NoOp");
 		return 0;
 	}

core/wma/src/wma_dev_if.c

@@ -3968,7 +3968,7 @@ static void wma_add_bss_ap_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 		goto send_fail_resp;
 	}
 	if (SAP_WPS_DISABLED == add_bss->wps_state)
-		pmo_ucfg_disable_wakeup_event(wma->psoc, vdev_id,
+		ucfg_pmo_disable_wakeup_event(wma->psoc, vdev_id,
 					      WOW_PROBE_REQ_WPS_IE_EVENT);
 	wma_set_bss_rate_flags(wma, vdev_id, add_bss);
 	status = wma_create_peer(wma, pdev, vdev, add_bss->bssId,

core/wma/src/wma_features.c

@@ -2960,7 +2960,7 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event, uint32_t len)
 
 	wma_wake_event_log_reason(wma, wake_info);
 
-	pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
+	ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
 
 	wma_print_wow_stats(wma, wake_info);
 	/* split based on payload type */
@@ -3005,7 +3005,7 @@ int wma_d0_wow_disable_ack_event(void *handle, uint8_t *event, uint32_t len)
 
 	resp_data = param_buf->fixed_param;
 
-	pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
+	ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
 
 	WMA_LOGD("Received D0-WOW disable ACK");
 
@@ -3032,7 +3032,7 @@ int wma_pdev_resume_event_handler(void *handle, uint8_t *event, uint32_t len)
 
 	WMA_LOGA("Received PDEV resume event");
 
-	pmo_ucfg_psoc_wakeup_host_event_received(wma->psoc);
+	ucfg_pmo_psoc_wakeup_host_event_received(wma->psoc);
 
 	return 0;
 }

core/wma/src/wma_main.c

@@ -1956,7 +1956,7 @@ static void wma_shutdown_notifier_cb(void *priv)
 	QDF_STATUS status;
 
 	qdf_event_set(&wma_handle->wma_resume_event);
-	pmo_ucfg_psoc_wakeup_host_event_received(wma_handle->psoc);
+	ucfg_pmo_psoc_wakeup_host_event_received(wma_handle->psoc);
 	wmi_stop(wma_handle->wmi_handle);
 
 	msg.bodyptr = priv;