qcacld-3.0: Replace hdd_psoc with psoc

The name 'hdd_psoc' is misleading, since it is not actually an HDD psoc
context. Rather, it is the Object Manager psoc context. Rename hdd_psoc
to psoc for consistency, and to make room for HDD to have its own psoc
context.

After the introduction of hdd_context.psoc in
I9971c478c0d1dc111bb20a7cd6614f73ffb0b15d, replace more instances of
hdd_psoc with psoc.

Change-Id: I1aa67d0554400ed552dc488805ba3421531a26c3
CRs-Fixed: 2315992

core/hdd/src/wlan_hdd_cfg.c

@@ -6255,7 +6255,7 @@ void hdd_get_pmkid_modes(struct hdd_context *hdd_ctx,
 	uint32_t cur_pmkid_modes;
 	QDF_STATUS status;
 
-	status = ucfg_mlme_get_pmkid_modes(hdd_ctx->hdd_psoc, &cur_pmkid_modes);
+	status = ucfg_mlme_get_pmkid_modes(hdd_ctx->psoc, &cur_pmkid_modes);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("get pmkid modes fail");
 

core/hdd/src/wlan_hdd_cfg80211.c

@@ -5186,7 +5186,7 @@ static int wlan_hdd_save_default_scan_ies(struct hdd_context *hdd_ctx,
 	}
 
 	scan_info->default_scan_ies_len = ie_len;
-	ucfg_mlme_get_qcn_ie_support(hdd_ctx->hdd_psoc, &add_qcn_ie);
+	ucfg_mlme_get_qcn_ie_support(hdd_ctx->psoc, &add_qcn_ie);
 	if (add_qcn_ie)
 		ie_len += (QCN_IE_HDR_LEN + QCN_IE_VERSION_SUBATTR_LEN);
 
@@ -6051,7 +6051,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 		}
 	}
 
-	ucfg_mlme_get_force_rsne_override(hdd_ctx->hdd_psoc, &b_value);
+	ucfg_mlme_get_force_rsne_override(hdd_ctx->psoc, &b_value);
 	if (tb[QCA_WLAN_VENDOR_ATTR_CONFIG_RSN_IE] && b_value) {
 		uint8_t force_rsne_override;
 

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->hdd_psoc, hif_ctx);
+	pmo_ucfg_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->hdd_psoc, NULL);
+	pmo_ucfg_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->hdd_psoc,
+	status = pmo_ucfg_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->hdd_psoc,
+	status = pmo_ucfg_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->hdd_psoc);
+	errno = pmo_ucfg_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,7 +998,7 @@ static int __wlan_hdd_bus_resume(void)
 		goto out;
 	}
 
-	qdf_status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->hdd_psoc,
+	qdf_status = pmo_ucfg_psoc_bus_resume_req(hdd_ctx->psoc,
 			QDF_SYSTEM_SUSPEND);
 	status = qdf_status_to_os_return(qdf_status);
 	if (status) {
@@ -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->hdd_psoc);
+	qdf_status = pmo_ucfg_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->hdd_psoc,
+	status = pmo_ucfg_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->hdd_psoc,
+	status = pmo_ucfg_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_green_ap.c

@@ -48,7 +48,7 @@ static int hdd_green_ap_check_enable(struct hdd_context *hdd_ctx,
 			continue;
 
 		status = policy_mgr_mode_specific_num_active_sessions(
-					hdd_ctx->hdd_psoc, mode, &num_sessions);
+					hdd_ctx->psoc, mode, &num_sessions);
 		hdd_debug("No. of active sessions for mode: %d is %d",
 			  mode, num_sessions);
 		if (status != QDF_STATUS_SUCCESS) {
@@ -128,10 +128,10 @@ int hdd_green_ap_start_state_mc(struct hdd_context *hdd_ctx,
 		return 0;
 	}
 
-	policy_mgr_mode_specific_num_active_sessions(hdd_ctx->hdd_psoc,
+	policy_mgr_mode_specific_num_active_sessions(hdd_ctx->psoc,
 						     QDF_SAP_MODE,
 						     &num_sap_sessions);
-	policy_mgr_mode_specific_num_active_sessions(hdd_ctx->hdd_psoc,
+	policy_mgr_mode_specific_num_active_sessions(hdd_ctx->psoc,
 						     QDF_P2P_GO_MODE,
 						     &num_p2p_go_sessions);
 

core/hdd/src/wlan_hdd_hostapd.c

@@ -763,7 +763,7 @@ static int hdd_stop_bss_link(struct hdd_adapter *adapter)
 			hdd_debug("Deleting SAP/P2P link!!!!!!");
 
 		clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 					adapter->device_mode,
 					adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
@@ -1670,7 +1670,7 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 		qdf_atomic_set(&adapter->dfs_radar_found, 0);
 
 		status = policy_mgr_set_chan_switch_complete_evt(
-						hdd_ctx->hdd_psoc);
+						hdd_ctx->psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("set event failed");
 			goto stopbss;
@@ -1799,17 +1799,17 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 
 		hdd_debug("check for SAP restart");
 		policy_mgr_check_concurrent_intf_and_restart_sap(
-						hdd_ctx->hdd_psoc);
+						hdd_ctx->psoc);
 
 		if (policy_mgr_is_hw_mode_change_after_vdev_up(
-			hdd_ctx->hdd_psoc)) {
+			hdd_ctx->psoc)) {
 			hdd_debug("check for possible hw mode change");
 			status = policy_mgr_set_hw_mode_on_channel_switch(
-				hdd_ctx->hdd_psoc, adapter->session_id);
+				hdd_ctx->psoc, adapter->session_id);
 			if (QDF_IS_STATUS_ERROR(status))
 				hdd_debug("set hw mode change not done");
 			policy_mgr_set_do_hw_mode_change_flag(
-					hdd_ctx->hdd_psoc, false);
+					hdd_ctx->psoc, false);
 		}
 		/*
 		 * set this event at the very end because once this events
@@ -2267,7 +2267,7 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 
 		/* Update the beacon Interval if it is P2P GO */
 		qdf_status = policy_mgr_change_mcc_go_beacon_interval(
-			hdd_ctx->hdd_psoc, adapter->session_id,
+			hdd_ctx->psoc, adapter->session_id,
 			adapter->device_mode);
 		if (QDF_STATUS_SUCCESS != qdf_status) {
 			hdd_err("Failed to update Beacon interval status: %d",
@@ -2746,7 +2746,7 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel,
 	 * should will be prevented.
 	 */
 	if (!policy_mgr_allow_concurrency_csa(
-				hdd_ctx->hdd_psoc,
+				hdd_ctx->psoc,
 				policy_mgr_convert_device_mode_to_qdf_type(
 					adapter->device_mode),
 				target_channel,
@@ -2756,7 +2756,7 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel,
 		return -EINVAL;
 	}
 
-	status = policy_mgr_reset_chan_switch_complete_evt(hdd_ctx->hdd_psoc);
+	status = policy_mgr_reset_chan_switch_complete_evt(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_err("clear event failed");
 		qdf_atomic_set(&adapter->dfs_radar_found, 0);
@@ -2913,10 +2913,10 @@ QDF_STATUS wlan_hdd_get_channel_for_sap_restart(
 		hdd_ctx->config->WlanMccToSccSwitchMode) {
 		if (QDF_IS_STATUS_ERROR(
 			policy_mgr_valid_sap_conc_channel_check(
-				hdd_ctx->hdd_psoc,
+				hdd_ctx->psoc,
 				&intf_ch,
 				policy_mgr_mode_specific_get_channel(
-					hdd_ctx->hdd_psoc, PM_SAP_MODE)))) {
+					hdd_ctx->psoc, PM_SAP_MODE)))) {
 			hdd_debug("can't move sap to %d",
 				hdd_sta_ctx->conn_info.operationChannel);
 			return QDF_STATUS_E_FAILURE;
@@ -3176,7 +3176,7 @@ struct hdd_adapter *hdd_wlan_create_ap_dev(struct hdd_context *hdd_ctx,
 
 	hdd_debug("dev = %pK, adapter = %pK, concurrency_mode=0x%x",
 		dev, adapter,
-		(int)policy_mgr_get_concurrency_mode(hdd_ctx->hdd_psoc));
+		(int)policy_mgr_get_concurrency_mode(hdd_ctx->psoc));
 
 	/* Init the net_device structure */
 	strlcpy(dev->name, (const char *)iface_name, IFNAMSIZ);
@@ -4515,9 +4515,9 @@ int wlan_hdd_cfg80211_start_bss(struct hdd_adapter *adapter,
 
 	hdd_notify_teardown_tdls_links(adapter->vdev);
 
-	if (policy_mgr_is_hw_mode_change_in_progress(hdd_ctx->hdd_psoc)) {
+	if (policy_mgr_is_hw_mode_change_in_progress(hdd_ctx->psoc)) {
 		status = policy_mgr_wait_for_connection_update(
-			hdd_ctx->hdd_psoc);
+			hdd_ctx->psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("qdf wait for event failed!!");
 			return -EINVAL;
@@ -4654,7 +4654,7 @@ int wlan_hdd_cfg80211_start_bss(struct hdd_adapter *adapter,
 		pConfig->acs_dfs_mode = wlan_hdd_get_dfs_mode(mode);
 	}
 
-	policy_mgr_update_user_config_sap_chan(hdd_ctx->hdd_psoc,
+	policy_mgr_update_user_config_sap_chan(hdd_ctx->psoc,
 					       pConfig->channel);
 	hdd_debug("pConfig->channel %d, pConfig->acs_dfs_mode %d",
 		pConfig->channel, pConfig->acs_dfs_mode);
@@ -5077,7 +5077,7 @@ int wlan_hdd_cfg80211_start_bss(struct hdd_adapter *adapter,
 	}
 
 	if (check_for_concurrency) {
-		if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
+		if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
 				policy_mgr_convert_device_mode_to_qdf_type(
 					adapter->device_mode),
 					pConfig->channel, HW_MODE_20_MHZ)) {
@@ -5143,7 +5143,7 @@ int wlan_hdd_cfg80211_start_bss(struct hdd_adapter *adapter,
 	/* Initialize WMM configuation */
 	hdd_wmm_init(adapter);
 	if (hostapd_state->bss_state == BSS_START) {
-		policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
+		policy_mgr_incr_active_session(hdd_ctx->psoc,
 					adapter->device_mode,
 					adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
@@ -5338,7 +5338,7 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
 		clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
 
 		/*BSS stopped, clear the active sessions for this device mode*/
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 						adapter->device_mode,
 						adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
@@ -5564,9 +5564,9 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		adapter, hdd_device_mode_to_string(adapter->device_mode),
 		adapter->device_mode, cds_is_sub_20_mhz_enabled());
 
-	if (policy_mgr_is_hw_mode_change_in_progress(hdd_ctx->hdd_psoc)) {
+	if (policy_mgr_is_hw_mode_change_in_progress(hdd_ctx->psoc)) {
 		status = policy_mgr_wait_for_connection_update(
-			hdd_ctx->hdd_psoc);
+			hdd_ctx->psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("qdf wait for event failed!!");
 			return -EINVAL;
@@ -5581,20 +5581,20 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	if (policy_mgr_is_sap_mandatory_chan_list_enabled(hdd_ctx->hdd_psoc)) {
+	if (policy_mgr_is_sap_mandatory_chan_list_enabled(hdd_ctx->psoc)) {
 		if (WLAN_REG_IS_5GHZ_CH(channel)) {
 			hdd_debug("channel %hu, sap mandatory chan list enabled",
 			          channel);
 			if (!policy_mgr_get_sap_mandatory_chan_list_len(
-							hdd_ctx->hdd_psoc))
+							hdd_ctx->psoc))
 				policy_mgr_init_sap_mandatory_2g_chan(
-							hdd_ctx->hdd_psoc);
+							hdd_ctx->psoc);
 
-			policy_mgr_add_sap_mandatory_chan(hdd_ctx->hdd_psoc,
+			policy_mgr_add_sap_mandatory_chan(hdd_ctx->psoc,
 							  channel);
 		} else {
 			policy_mgr_init_sap_mandatory_2g_chan(
-							hdd_ctx->hdd_psoc);
+							hdd_ctx->psoc);
 		}
 	}
 
@@ -5605,10 +5605,10 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 
 	sta_sap_scc_on_dfs_chan =
 		policy_mgr_is_sta_sap_scc_allowed_on_dfs_chan(
-							hdd_ctx->hdd_psoc);
+							hdd_ctx->psoc);
 	sta_cnt =
 		policy_mgr_mode_specific_connection_count(
-					hdd_ctx->hdd_psoc, PM_STA_MODE, NULL);
+					hdd_ctx->psoc, PM_STA_MODE, NULL);
 
 	hdd_debug("sta_sap_scc_on_dfs_chan %u, sta_cnt %u",
 		  sta_sap_scc_on_dfs_chan, sta_cnt);
@@ -5661,7 +5661,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	}
 
 	/* check if concurrency is allowed */
-	if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
+	if (!policy_mgr_allow_concurrency(hdd_ctx->psoc,
 				policy_mgr_convert_device_mode_to_qdf_type(
 				adapter->device_mode),
 				channel,
@@ -5670,7 +5670,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	status = policy_mgr_reset_connection_update(hdd_ctx->hdd_psoc);
+	status = policy_mgr_reset_connection_update(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("ERR: clear event failed");
 
@@ -5687,14 +5687,14 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	 * back to single MAC 2x2 (if initial was 2x2).
 	 */
 
-	policy_mgr_checkn_update_hw_mode_single_mac_mode(hdd_ctx->hdd_psoc,
+	policy_mgr_checkn_update_hw_mode_single_mac_mode(hdd_ctx->psoc,
 							 channel);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to stop DBS opportunistic timer");
 		return -EINVAL;
 	}
 
-	status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc,
+	status = policy_mgr_current_connections_update(hdd_ctx->psoc,
 			adapter->session_id, channel,
 			POLICY_MGR_UPDATE_REASON_START_AP);
 	if (status == QDF_STATUS_E_FAILURE) {
@@ -5703,7 +5703,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	}
 
 	if (QDF_STATUS_SUCCESS == status) {
-		status = policy_mgr_wait_for_connection_update(hdd_ctx->hdd_psoc);
+		status = policy_mgr_wait_for_connection_update(hdd_ctx->psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("ERROR: qdf wait for event failed!!");
 			return -EINVAL;
@@ -5796,7 +5796,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 							  sap_config->channel);
 		}
 
-		ucfg_mlme_get_sap_inactivity_override(hdd_ctx->hdd_psoc, &val);
+		ucfg_mlme_get_sap_inactivity_override(hdd_ctx->psoc, &val);
 		if (val) {
 			sta_inactivity_timer = qdf_mem_malloc(
 					sizeof(*sta_inactivity_timer));

core/hdd/src/wlan_hdd_hostapd_wext.c

@@ -2145,7 +2145,7 @@ __iw_softap_stopbss(struct net_device *dev,
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 					     adapter->device_mode,
 					     adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,

core/hdd/src/wlan_hdd_ioctl.c

@@ -4509,7 +4509,7 @@ static int drv_cmd_set_okc_mode(struct hdd_adapter *adapter,
 	value = value + command_len + 1;
 
 	/* get the current configured value */
-	status = ucfg_mlme_get_pmkid_modes(hdd_ctx->hdd_psoc,
+	status = ucfg_mlme_get_pmkid_modes(hdd_ctx->psoc,
 					   &cur_pmkid_modes);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("get pmkid modes failed");
@@ -4542,7 +4542,7 @@ static int drv_cmd_set_okc_mode(struct hdd_adapter *adapter,
 		cur_pmkid_modes |= CFG_PMKID_MODES_OKC;
 	else
 		cur_pmkid_modes &= ~CFG_PMKID_MODES_OKC;
-	status = ucfg_mlme_set_pmkid_modes(hdd_ctx->hdd_psoc,
+	status = ucfg_mlme_set_pmkid_modes(hdd_ctx->psoc,
 					   cur_pmkid_modes);
 	if (status != QDF_STATUS_SUCCESS) {
 		ret = -EPERM;
@@ -4707,14 +4707,14 @@ static int drv_cmd_miracast(struct hdd_adapter *adapter,
 		hdd_err("Failed to set miracast");
 		return -EBUSY;
 	}
-	ret_status = ucfg_scan_set_miracast(hdd_ctx->hdd_psoc,
+	ret_status = ucfg_scan_set_miracast(hdd_ctx->psoc,
 					    filterType ? true : false);
 	if (QDF_IS_STATUS_ERROR(ret_status)) {
 		hdd_err("Failed to set miracastn scan");
 		return -EBUSY;
 	}
 
-	if (policy_mgr_is_mcc_in_24G(hdd_ctx->hdd_psoc))
+	if (policy_mgr_is_mcc_in_24G(hdd_ctx->psoc))
 		return wlan_hdd_set_mas(adapter, filterType);
 
 exit:
@@ -6654,7 +6654,7 @@ int hdd_set_antenna_mode(struct hdd_adapter *adapter,
 
 	/* Check TDLS status and update antenna mode */
 	if ((QDF_STA_MODE == adapter->device_mode) &&
-	    policy_mgr_is_sta_active_connection_exists(hdd_ctx->hdd_psoc)) {
+	    policy_mgr_is_sta_active_connection_exists(hdd_ctx->psoc)) {
 		ret = wlan_hdd_tdls_antenna_switch(hdd_ctx, adapter, mode);
 		if (0 != ret)
 			goto exit;

core/hdd/src/wlan_hdd_ipa.c

@@ -67,7 +67,7 @@ void hdd_ipa_set_tx_flow_info(void)
 		return;
 	}
 
-	psoc = hdd_ctx->hdd_psoc;
+	psoc = hdd_ctx->psoc;
 
 	hdd_for_each_adapter(hdd_ctx, adapter) {
 		switch (adapter->device_mode) {

core/hdd/src/wlan_hdd_main.c

@@ -1159,14 +1159,14 @@ void hdd_update_macaddr(struct hdd_config *config,
 
 static int hdd_update_tdls_config(struct hdd_context *hdd_ctx)
 {
-	struct wlan_objmgr_psoc *psoc = hdd_ctx->hdd_psoc;
+	struct wlan_objmgr_psoc *psoc = hdd_ctx->psoc;
 	struct tdls_start_params tdls_cfg;
 	struct hdd_config *cfg = hdd_ctx->config;
 	QDF_STATUS status;
 
-	cfg_tdls_set_vdev_nss_2g(hdd_ctx->hdd_psoc,
+	cfg_tdls_set_vdev_nss_2g(hdd_ctx->psoc,
 				 CFG_TDLS_NSS(cfg->vdev_type_nss_2g));
-	cfg_tdls_set_vdev_nss_5g(hdd_ctx->hdd_psoc,
+	cfg_tdls_set_vdev_nss_5g(hdd_ctx->psoc,
 				 CFG_TDLS_NSS(cfg->vdev_type_nss_5g));
 	tdls_cfg.tdls_send_mgmt_req = eWNI_SME_TDLS_SEND_MGMT_REQ;
 	tdls_cfg.tdls_add_sta_req = eWNI_SME_TDLS_ADD_STA_REQ;
@@ -1204,8 +1204,8 @@ static void hdd_update_roam_offload(struct hdd_context *hdd_ctx,
 {
 	bool roam_offload_enable;
 
-	ucfg_mlme_get_roaming_offload(hdd_ctx->hdd_psoc, &roam_offload_enable);
-	ucfg_mlme_set_roaming_offload(hdd_ctx->hdd_psoc,
+	ucfg_mlme_get_roaming_offload(hdd_ctx->psoc, &roam_offload_enable);
+	ucfg_mlme_set_roaming_offload(hdd_ctx->psoc,
 				      roam_offload_enable &
 				      cfg->en_roam_offload);
 }
@@ -1250,25 +1250,25 @@ static void hdd_update_tgt_services(struct hdd_context *hdd_ctx,
 		config->PnoOffload = true;
 #endif
 #ifdef FEATURE_WLAN_TDLS
-	cfg_tdls_get_support_enable(hdd_ctx->hdd_psoc, &tdls_support);
-	cfg_tdls_set_support_enable(hdd_ctx->hdd_psoc,
+	cfg_tdls_get_support_enable(hdd_ctx->psoc, &tdls_support);
+	cfg_tdls_set_support_enable(hdd_ctx->psoc,
 				    tdls_support & cfg->en_tdls);
 
-	cfg_tdls_get_off_channel_enable(hdd_ctx->hdd_psoc, &tdls_off_channel);
-	cfg_tdls_set_off_channel_enable(hdd_ctx->hdd_psoc,
+	cfg_tdls_get_off_channel_enable(hdd_ctx->psoc, &tdls_off_channel);
+	cfg_tdls_set_off_channel_enable(hdd_ctx->psoc,
 					tdls_off_channel &&
 					cfg->en_tdls_offchan);
 
-	cfg_tdls_get_buffer_sta_enable(hdd_ctx->hdd_psoc, &tdls_buffer_sta);
-	cfg_tdls_set_buffer_sta_enable(hdd_ctx->hdd_psoc,
+	cfg_tdls_get_buffer_sta_enable(hdd_ctx->psoc, &tdls_buffer_sta);
+	cfg_tdls_set_buffer_sta_enable(hdd_ctx->psoc,
 				       tdls_buffer_sta &&
 				       cfg->en_tdls_uapsd_buf_sta);
 
-	cfg_tdls_get_uapsd_mask(hdd_ctx->hdd_psoc, &tdls_uapsd_mask);
+	cfg_tdls_get_uapsd_mask(hdd_ctx->psoc, &tdls_uapsd_mask);
 	if (tdls_uapsd_mask && cfg->en_tdls_uapsd_sleep_sta)
-		cfg_tdls_set_sleep_sta_enable(hdd_ctx->hdd_psoc, true);
+		cfg_tdls_set_sleep_sta_enable(hdd_ctx->psoc, true);
 	else
-		cfg_tdls_set_sleep_sta_enable(hdd_ctx->hdd_psoc, false);
+		cfg_tdls_set_sleep_sta_enable(hdd_ctx->psoc, false);
 #endif
 	hdd_update_roam_offload(hdd_ctx, cfg);
 
@@ -1352,7 +1352,7 @@ static void hdd_update_hw_dbs_capable(struct hdd_context *hdd_ctx)
 	struct hdd_config *cfg_ini = hdd_ctx->config;
 	uint8_t hw_dbs_capable = 0;
 
-	if (policy_mgr_is_hw_dbs_capable(hdd_ctx->hdd_psoc) &&
+	if (policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc) &&
 		((cfg_ini->dual_mac_feature_disable ==
 			ENABLE_DBS_CXN_AND_SCAN) ||
 		(cfg_ini->dual_mac_feature_disable ==
@@ -1396,7 +1396,7 @@ static void hdd_update_tgt_ht_cap(struct hdd_context *hdd_ctx,
 	}
 
 	/* get the HT capability info */
-	status = ucfg_mlme_get_ht_cap_info(hdd_ctx->hdd_psoc, &ht_cap_info);
+	status = ucfg_mlme_get_ht_cap_info(hdd_ctx->psoc, &ht_cap_info);
 	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("could not get HT capability info");
 		return;
@@ -1445,7 +1445,7 @@ static void hdd_update_tgt_ht_cap(struct hdd_context *hdd_ctx,
 	if (!(cfg->ht_tx_stbc && pconfig->enable2x2))
 		ht_cap_info.tx_stbc = 0;
 
-	status = ucfg_mlme_set_ht_cap_info(hdd_ctx->hdd_psoc, ht_cap_info);
+	status = ucfg_mlme_set_ht_cap_info(hdd_ctx->psoc, ht_cap_info);
 	if (status != QDF_STATUS_SUCCESS)
 		hdd_err("could not set HT capability to CCM");
 #define WLAN_HDD_RX_MCS_ALL_NSTREAM_RATES 0xff
@@ -1961,9 +1961,9 @@ void hdd_update_tgt_cfg(hdd_handle_t hdd_handle, struct wma_tgt_cfg *cfg)
 
 	ret = hdd_green_ap_update_config(hdd_ctx);
 
-	ucfg_ipa_set_dp_handle(hdd_ctx->hdd_psoc,
+	ucfg_ipa_set_dp_handle(hdd_ctx->psoc,
 			       cds_get_context(QDF_MODULE_ID_SOC));
-	ucfg_ipa_set_txrx_handle(hdd_ctx->hdd_psoc,
+	ucfg_ipa_set_txrx_handle(hdd_ctx->psoc,
 				 cds_get_context(QDF_MODULE_ID_TXRX));
 	ucfg_ipa_reg_sap_xmit_cb(hdd_ctx->pdev,
 				 hdd_softap_hard_start_xmit);
@@ -2315,7 +2315,7 @@ wlan_hdd_update_dbs_scan_and_fw_mode_config(void)
 	}
 
 
-	if (!policy_mgr_is_hw_dbs_capable(hdd_ctx->hdd_psoc))
+	if (!policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc))
 		return QDF_STATUS_SUCCESS;
 
 	cfg.scan_config = 0;
@@ -2328,7 +2328,7 @@ wlan_hdd_update_dbs_scan_and_fw_mode_config(void)
 	if (hdd_ctx->config->dual_mac_feature_disable !=
 	    DISABLE_DBS_CXN_AND_SCAN) {
 		status = policy_mgr_get_updated_scan_and_fw_mode_config(
-				hdd_ctx->hdd_psoc, &cfg.scan_config,
+				hdd_ctx->psoc, &cfg.scan_config,
 				&cfg.fw_mode_config,
 				hdd_ctx->config->dual_mac_feature_disable,
 				channel_select_logic_conc);
@@ -2775,7 +2775,7 @@ static void hdd_nan_register_callbacks(struct hdd_context *hdd_ctx)
 	cb_obj.get_peer_idx = hdd_ndp_get_peer_idx;
 	cb_obj.peer_departed_ind = hdd_ndp_peer_departed_handler;
 
-	os_if_nan_register_hdd_callbacks(hdd_ctx->hdd_psoc, &cb_obj);
+	os_if_nan_register_hdd_callbacks(hdd_ctx->psoc, &cb_obj);
 }
 
 #ifdef CONFIG_LEAK_DETECTION
@@ -2798,9 +2798,9 @@ static void hdd_check_for_leaks(struct hdd_context *hdd_ctx, bool is_ssr)
 {
 	/* DO NOT REMOVE these checks; for false positives, read above first */
 
-	wlan_objmgr_psoc_check_for_peer_leaks(hdd_ctx->hdd_psoc);
-	wlan_objmgr_psoc_check_for_vdev_leaks(hdd_ctx->hdd_psoc);
-	wlan_objmgr_psoc_check_for_pdev_leaks(hdd_ctx->hdd_psoc);
+	wlan_objmgr_psoc_check_for_peer_leaks(hdd_ctx->psoc);
+	wlan_objmgr_psoc_check_for_vdev_leaks(hdd_ctx->psoc);
+	wlan_objmgr_psoc_check_for_pdev_leaks(hdd_ctx->psoc);
 
 	/* many adapter resources are not freed by design during SSR */
 	if (is_ssr)
@@ -2922,7 +2922,7 @@ int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit)
 
 		hdd_update_cds_ac_specs_params(hdd_ctx);
 
-		status = hdd_component_psoc_open(hdd_ctx->hdd_psoc);
+		status = hdd_component_psoc_open(hdd_ctx->psoc);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			hdd_err("Failed to Open legacy components; status: %d",
 				status);
@@ -2941,7 +2941,7 @@ int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit)
 		if (QDF_IS_STATUS_ERROR(status))
 			hdd_err("WBUFF init unsuccessful; status: %d", status);
 
-		status = cds_open(hdd_ctx->hdd_psoc);
+		status = cds_open(hdd_ctx->psoc);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			hdd_err("Failed to Open CDS; status: %d", status);
 			ret = qdf_status_to_os_return(status);
@@ -2961,7 +2961,7 @@ int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit)
 				ret);
 			goto close;
 		}
-		status = cds_dp_open(hdd_ctx->hdd_psoc);
+		status = cds_dp_open(hdd_ctx->psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("Failed to Open cds post open; status: %d",
 				status);
@@ -2984,9 +2984,9 @@ int hdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit)
 		}
 
 		hdd_register_policy_manager_callback(
-			hdd_ctx->hdd_psoc);
+			hdd_ctx->psoc);
 
-		hdd_sysfs_create_version_interface(hdd_ctx->hdd_psoc);
+		hdd_sysfs_create_version_interface(hdd_ctx->psoc);
 		hdd_update_hw_sw_info(hdd_ctx);
 
 		if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
@@ -3027,7 +3027,7 @@ post_disable:
 	cds_post_disable();
 
 cds_txrx_free:
-	tgt_hdl = wlan_psoc_get_tgt_if_handle(hdd_ctx->hdd_psoc);
+	tgt_hdl = wlan_psoc_get_tgt_if_handle(hdd_ctx->psoc);
 
 	if (tgt_hdl && target_psoc_get_wmi_ready(tgt_hdl)) {
 		hdd_runtime_suspend_context_deinit(hdd_ctx);
@@ -3035,16 +3035,16 @@ cds_txrx_free:
 		hdd_objmgr_release_and_destroy_pdev(hdd_ctx);
 	}
 
-	cds_dp_close(hdd_ctx->hdd_psoc);
+	cds_dp_close(hdd_ctx->psoc);
 
 close:
 	hdd_ctx->driver_status = DRIVER_MODULES_CLOSED;
 	hdd_info("Wlan transition aborted (now CLOSED)");
 
-	cds_close(hdd_ctx->hdd_psoc);
+	cds_close(hdd_ctx->psoc);
 
 hdd_psoc_close:
-	hdd_component_psoc_close(hdd_ctx->hdd_psoc);
+	hdd_component_psoc_close(hdd_ctx->psoc);
 	cds_deinit_ini_config();
 
 cds_free:
@@ -3101,7 +3101,7 @@ static int hdd_deactivate_wifi_pos(void)
  */
 static void hdd_populate_wifi_pos_cfg(struct hdd_context *hdd_ctx)
 {
-	struct wlan_objmgr_psoc *psoc = hdd_ctx->hdd_psoc;
+	struct wlan_objmgr_psoc *psoc = hdd_ctx->psoc;
 	struct hdd_config *cfg = hdd_ctx->config;
 
 	wifi_pos_set_oem_target_type(psoc, hdd_ctx->target_type);
@@ -3600,7 +3600,7 @@ static void __hdd_set_multicast_list(struct net_device *dev)
 	struct netdev_hw_addr *ha;
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	struct pmo_mc_addr_list_params *mc_list_request = NULL;
-	struct wlan_objmgr_psoc *psoc = hdd_ctx->hdd_psoc;
+	struct wlan_objmgr_psoc *psoc = hdd_ctx->psoc;
 	int mc_count = 0;
 
 	hdd_enter_dev(dev);
@@ -4538,7 +4538,7 @@ static int hdd_configure_chain_mask(struct hdd_adapter *adapter)
 		return 0;
 	}
 
-	status = ucfg_mlme_configure_chain_mask(hdd_ctx->hdd_psoc,
+	status = ucfg_mlme_configure_chain_mask(hdd_ctx->psoc,
 						adapter->session_id);
 	if (status != QDF_STATUS_SUCCESS)
 		goto error;
@@ -5041,7 +5041,7 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx, uint8_t sessio
 	hdd_apf_context_init(adapter);
 
 	if (QDF_STATUS_SUCCESS == status) {
-		policy_mgr_set_concurrency_mode(hdd_ctx->hdd_psoc,
+		policy_mgr_set_concurrency_mode(hdd_ctx->psoc,
 			session_type);
 
 		/* Adapter successfully added. Increment the vdev count */
@@ -5093,7 +5093,7 @@ QDF_STATUS hdd_close_adapter(struct hdd_context *hdd_ctx, struct hdd_adapter *ad
 	qdf_mutex_destroy(&adapter->blocked_scan_request_q_lock);
 
 	/* cleanup adapter */
-	policy_mgr_clear_concurrency_mode(hdd_ctx->hdd_psoc,
+	policy_mgr_clear_concurrency_mode(hdd_ctx->psoc,
 					  adapter->device_mode);
 	hdd_remove_adapter(hdd_ctx, adapter);
 	hdd_cleanup_adapter(hdd_ctx, adapter, rtnl_held);
@@ -5226,13 +5226,13 @@ QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
 	 * if this is the last active connection check & stop the
 	 * opportunistic timer first
 	 */
-	if (((policy_mgr_get_connection_count(hdd_ctx->hdd_psoc) == 1) &&
-		(policy_mgr_mode_specific_connection_count(hdd_ctx->hdd_psoc,
+	if (((policy_mgr_get_connection_count(hdd_ctx->psoc) == 1) &&
+		(policy_mgr_mode_specific_connection_count(hdd_ctx->psoc,
 			policy_mgr_convert_device_mode_to_qdf_type(
 				adapter->device_mode), NULL) == 1)) ||
-			!policy_mgr_get_connection_count(hdd_ctx->hdd_psoc))
+			!policy_mgr_get_connection_count(hdd_ctx->psoc))
 		policy_mgr_check_and_stop_opportunistic_timer(
-			hdd_ctx->hdd_psoc, adapter->session_id);
+			hdd_ctx->psoc, adapter->session_id);
 
 	mac_handle = hdd_ctx->mac_handle;
 
@@ -5380,7 +5380,7 @@ QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
 				hdd_err("failure in wlansap_stop_bss");
 			}
 			clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
-			policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+			policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 						adapter->device_mode,
 						adapter->session_id);
 			hdd_green_ap_start_state_mc(hdd_ctx,
@@ -5569,7 +5569,7 @@ QDF_STATUS hdd_reset_all_adapters(struct hdd_context *hdd_ctx)
 		hdd_reset_scan_operation(hdd_ctx, adapter);
 
 		hdd_deinit_tx_rx(adapter);
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 				adapter->device_mode, adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, adapter->device_mode,
 					    false);
@@ -8420,7 +8420,7 @@ hdd_get_safe_channel_from_pcl_and_acs_range(struct hdd_adapter *adapter)
 		return INVALID_CHANNEL_ID;
 	}
 
-	status = policy_mgr_get_pcl_for_existing_conn(hdd_ctx->hdd_psoc,
+	status = policy_mgr_get_pcl_for_existing_conn(hdd_ctx->psoc,
 			PM_SAP_MODE, pcl.pcl_list, &pcl.pcl_len,
 			pcl.weight_list, QDF_ARRAY_SIZE(pcl.weight_list),
 			false);
@@ -8502,7 +8502,7 @@ void hdd_switch_sap_channel(struct hdd_adapter *adapter, uint8_t channel,
 				    hdd_ap_ctx->sap_config.sec_ch,
 				    &hdd_ap_ctx->sap_config.ch_params);
 
-	policy_mgr_change_sap_channel_with_csa(hdd_ctx->hdd_psoc,
+	policy_mgr_change_sap_channel_with_csa(hdd_ctx->psoc,
 		adapter->session_id, channel,
 		hdd_ap_ctx->sap_config.ch_width_orig, forced);
 }
@@ -8571,7 +8571,7 @@ void hdd_unsafe_channel_restart_sap(struct hdd_context *hdd_ctxt)
 		 * If STA+SAP is doing SCC & g_sta_sap_scc_on_lte_coex_chan
 		 * is set, no need to move SAP.
 		 */
-		if (policy_mgr_is_sta_sap_scc(hdd_ctxt->hdd_psoc,
+		if (policy_mgr_is_sta_sap_scc(hdd_ctxt->psoc,
 			adapter->session.ap.operating_channel) &&
 			hdd_ctxt->config->sta_sap_scc_on_lte_coex_chan)
 			hdd_debug("SAP is allowed on SCC channel, no need to move SAP");
@@ -9255,7 +9255,7 @@ static int hdd_open_p2p_interface(struct hdd_context *hdd_ctx, bool rtnl_held)
 	uint8_t *p2p_dev_addr;
 	bool p2p_dev_addr_admin = false;
 
-	cfg_p2p_get_device_addr_admin(hdd_ctx->hdd_psoc, &p2p_dev_addr_admin);
+	cfg_p2p_get_device_addr_admin(hdd_ctx->psoc, &p2p_dev_addr_admin);
 	if (p2p_dev_addr_admin &&
 	    !(hdd_ctx->config->intfMacAddr[0].bytes[0] & 0x02)) {
 		qdf_mem_copy(hdd_ctx->p2p_device_address.bytes,
@@ -9469,7 +9469,7 @@ static int hdd_open_interfaces(struct hdd_context *hdd_ctx, bool rtnl_held)
 
 		return 0;
 	}
-	ucfg_mlme_get_dot11p_mode(hdd_ctx->hdd_psoc, &dot11p_mode);
+	ucfg_mlme_get_dot11p_mode(hdd_ctx->psoc, &dot11p_mode);
 	if (dot11p_mode == CFG_11P_STANDALONE)
 		/* Create only 802.11p interface */
 		return hdd_open_ocb_interface(hdd_ctx, rtnl_held);
@@ -9732,11 +9732,11 @@ static int hdd_update_user_config(struct hdd_context *hdd_ctx)
 		hdd_ctx->config->Is11hSupportEnabled;
 	user_config->optimize_chan_avoid_event =
 		hdd_ctx->config->goptimize_chan_avoid_event;
-	cfg_p2p_get_skip_dfs_channel_p2p_search(hdd_ctx->hdd_psoc,
+	cfg_p2p_get_skip_dfs_channel_p2p_search(hdd_ctx->psoc,
 						&skip_dfs_in_p2p_search);
 	user_config->skip_dfs_chnl_in_p2p_search = skip_dfs_in_p2p_search;
 	user_config->band_capability = hdd_ctx->config->nBandCapability;
-	wlan_objmgr_psoc_set_user_config(hdd_ctx->hdd_psoc, user_config);
+	wlan_objmgr_psoc_set_user_config(hdd_ctx->psoc, user_config);
 
 	qdf_mem_free(user_config);
 	return 0;
@@ -10245,7 +10245,7 @@ static int hdd_pre_enable_configure(struct hdd_context *hdd_ctx)
 		goto out;
 	}
 
-	status = ucfg_mlme_get_tx_chainmask_1ss(hdd_ctx->hdd_psoc, &val);
+	status = ucfg_mlme_get_tx_chainmask_1ss(hdd_ctx->psoc, &val);
 	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("Get tx_chainmask_1ss from mlme failed");
 		ret = qdf_status_to_os_return(status);
@@ -10310,7 +10310,7 @@ static int hdd_pre_enable_configure(struct hdd_context *hdd_ctx)
 	hdd_init_channel_avoidance(hdd_ctx);
 
 	/* update enable sap mandatory chan list */
-	policy_mgr_enable_disable_sap_mandatory_chan_list(hdd_ctx->hdd_psoc,
+	policy_mgr_enable_disable_sap_mandatory_chan_list(hdd_ctx->psoc,
 			hdd_ctx->config->enable_sap_mandatory_chan_list);
 out:
 	return ret;
@@ -10600,7 +10600,7 @@ static int hdd_features_init(struct hdd_context *hdd_ctx)
 	sme_cli_set_command(0, WMI_PDEV_PARAM_DATA_STALL_DETECT_ENABLE,
 	hdd_ctx->config->enable_data_stall_det, PDEV_CMD);
 
-	ucfg_mlme_get_go_cts2self_for_sta(hdd_ctx->hdd_psoc, &b_cts2self);
+	ucfg_mlme_get_go_cts2self_for_sta(hdd_ctx->psoc, &b_cts2self);
 	if (b_cts2self)
 		sme_set_cts2self_for_p2p_go(mac_handle);
 
@@ -10703,7 +10703,7 @@ static inline QDF_STATUS hdd_register_bcn_cb(struct hdd_context *hdd_ctx)
 {
 	QDF_STATUS status;
 
-	status = ucfg_scan_register_bcn_cb(hdd_ctx->hdd_psoc,
+	status = ucfg_scan_register_bcn_cb(hdd_ctx->psoc,
 		wlan_cfg80211_inform_bss_frame,
 		SCAN_CB_TYPE_INFORM_BCN);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
@@ -10775,7 +10775,7 @@ static void hdd_action_oui_config(struct hdd_context *hdd_ctx)
 		if (!qdf_str_len(str))
 			continue;
 
-		status = ucfg_action_oui_parse(hdd_ctx->hdd_psoc, str, id);
+		status = ucfg_action_oui_parse(hdd_ctx->psoc, str, id);
 		if (!QDF_IS_STATUS_SUCCESS(status))
 			hdd_err("Failed to parse action_oui str: %u", id);
 	}
@@ -10797,7 +10797,7 @@ static void hdd_action_oui_send(struct hdd_context *hdd_ctx)
 	if (!hdd_ctx->config->action_oui_enable)
 		return;
 
-	status = ucfg_action_oui_send(hdd_ctx->hdd_psoc);
+	status = ucfg_action_oui_send(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("Failed to send one or all action_ouis");
 }
@@ -10855,14 +10855,14 @@ int hdd_configure_cds(struct hdd_context *hdd_ctx)
 				    set_value, PDEV_CMD);
 	}
 
-	status = ucfg_mlme_get_num_11b_tx_chains(hdd_ctx->hdd_psoc,
+	status = ucfg_mlme_get_num_11b_tx_chains(hdd_ctx->psoc,
 						 &num_11b_tx_chains);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to get num_11b_tx_chains");
 		goto out;
 	}
 
-	status = ucfg_mlme_get_num_11ag_tx_chains(hdd_ctx->hdd_psoc,
+	status = ucfg_mlme_get_num_11ag_tx_chains(hdd_ctx->psoc,
 						  &num_11ag_tx_chains);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Failed to get num_11ag_tx_chains");
@@ -10902,7 +10902,7 @@ int hdd_configure_cds(struct hdd_context *hdd_ctx)
 	 * Start CDS which starts up the SME/MAC/HAL modules and everything
 	 * else
 	 */
-	status = cds_enable(hdd_ctx->hdd_psoc);
+	status = cds_enable(hdd_ctx->psoc);
 
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_err("cds_enable failed");
@@ -10931,12 +10931,12 @@ int hdd_configure_cds(struct hdd_context *hdd_ctx)
 	dp_cbs.hdd_ipa_set_mcc_mode_cb = hdd_ipa_set_mcc_mode;
 	dp_cbs.hdd_v2_flow_pool_map = hdd_v2_flow_pool_map;
 	dp_cbs.hdd_v2_flow_pool_unmap = hdd_v2_flow_pool_unmap;
-	status = policy_mgr_register_dp_cb(hdd_ctx->hdd_psoc, &dp_cbs);
+	status = policy_mgr_register_dp_cb(hdd_ctx->psoc, &dp_cbs);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_debug("Failed to register DP cb with Policy Manager");
 		goto cds_disable;
 	}
-	status = policy_mgr_register_mode_change_cb(hdd_ctx->hdd_psoc,
+	status = policy_mgr_register_mode_change_cb(hdd_ctx->psoc,
 					       wlan_hdd_send_mode_change_event);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_debug("Failed to register mode change cb with Policy Manager");
@@ -10962,7 +10962,7 @@ int hdd_configure_cds(struct hdd_context *hdd_ctx)
 	return 0;
 
 cds_disable:
-	cds_disable(hdd_ctx->hdd_psoc);
+	cds_disable(hdd_ctx->psoc);
 
 out:
 	return -EINVAL;
@@ -10989,11 +10989,11 @@ static int hdd_deconfigure_cds(struct hdd_context *hdd_ctx)
 	/* De-register the SME callbacks */
 	hdd_deregister_cb(hdd_ctx);
 
-	qdf_status = policy_mgr_deregister_mode_change_cb(hdd_ctx->hdd_psoc);
+	qdf_status = policy_mgr_deregister_mode_change_cb(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 		hdd_debug("Failed to deregister mode change cb with Policy Manager");
 
-	qdf_status = cds_disable(hdd_ctx->hdd_psoc);
+	qdf_status = cds_disable(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_err("Failed to Disable the CDS Modules! :%d",
 			qdf_status);
@@ -11049,7 +11049,7 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 
 	hdd_enter();
 
-	hdd_deregister_policy_manager_callback(hdd_ctx->hdd_psoc);
+	hdd_deregister_policy_manager_callback(hdd_ctx->psoc);
 
 	qdf_ctx = cds_get_context(QDF_MODULE_ID_QDF_DEVICE);
 	if (!qdf_ctx) {
@@ -11132,14 +11132,14 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 
 	hdd_runtime_suspend_context_deinit(hdd_ctx);
 
-	qdf_status = cds_dp_close(hdd_ctx->hdd_psoc);
+	qdf_status = cds_dp_close(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_warn("Failed to stop CDS DP: %d", qdf_status);
 		ret = -EINVAL;
 		QDF_ASSERT(0);
 	}
 
-	qdf_status = cds_close(hdd_ctx->hdd_psoc);
+	qdf_status = cds_close(hdd_ctx->psoc);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_warn("Failed to stop CDS: %d", qdf_status);
 		ret = -EINVAL;
@@ -11152,7 +11152,7 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 
 	hdd_component_pdev_close(hdd_ctx->pdev);
 
-	hdd_component_psoc_close(hdd_ctx->hdd_psoc);
+	hdd_component_psoc_close(hdd_ctx->psoc);
 	dispatcher_pdev_close(hdd_ctx->pdev);
 	ret = hdd_objmgr_release_and_destroy_pdev(hdd_ctx);
 	if (ret) {
@@ -11165,7 +11165,7 @@ int hdd_wlan_stop_modules(struct hdd_context *hdd_ctx, bool ftm_mode)
 	 * next module start same psoc is used to populate new service
 	 * ready data
 	 */
-	tgt_hdl = wlan_psoc_get_tgt_if_handle(hdd_ctx->hdd_psoc);
+	tgt_hdl = wlan_psoc_get_tgt_if_handle(hdd_ctx->psoc);
 	if (tgt_hdl)
 		target_psoc_set_total_mac_phy_cnt(tgt_hdl, 0);
 
@@ -11405,7 +11405,7 @@ int hdd_wlan_startup(struct device *dev)
 	}
 
 	hdd_action_oui_config(hdd_ctx);
-	psoc = hdd_ctx->hdd_psoc;
+	psoc = hdd_ctx->psoc;
 
 	qdf_nbuf_init_replenish_timer();
 
@@ -11833,7 +11833,7 @@ void wlan_hdd_disable_roaming(struct hdd_adapter *cur_adapter)
 	struct csr_roam_profile *roam_profile;
 	struct hdd_station_ctx *sta_ctx;
 
-	if (!policy_mgr_is_sta_active_connection_exists(hdd_ctx->hdd_psoc)) {
+	if (!policy_mgr_is_sta_active_connection_exists(hdd_ctx->psoc)) {
 		hdd_debug("No active sta session");
 		return;
 	}
@@ -11860,7 +11860,7 @@ void wlan_hdd_enable_roaming(struct hdd_adapter *cur_adapter)
 	struct csr_roam_profile *roam_profile;
 	struct hdd_station_ctx *sta_ctx;
 
-	if (!policy_mgr_is_sta_active_connection_exists(hdd_ctx->hdd_psoc)) {
+	if (!policy_mgr_is_sta_active_connection_exists(hdd_ctx->psoc)) {
 		hdd_debug("No active sta session");
 		return;
 	}
@@ -12020,7 +12020,7 @@ void wlan_hdd_auto_shutdown_enable(struct hdd_context *hdd_ctx, bool enable)
 	}
 
 	/* To enable shutdown timer check conncurrency */
-	if (policy_mgr_concurrent_open_sessions_running(hdd_ctx->hdd_psoc)) {
+	if (policy_mgr_concurrent_open_sessions_running(hdd_ctx->psoc)) {
 		hdd_for_each_adapter(hdd_ctx, adapter) {
 			if (adapter->device_mode == QDF_STA_MODE) {
 				if (WLAN_HDD_GET_STATION_CTX_PTR(adapter)->
@@ -12315,7 +12315,7 @@ void wlan_hdd_stop_sap(struct hdd_adapter *ap_adapter)
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 						ap_adapter->device_mode,
 						ap_adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, ap_adapter->device_mode,
@@ -12388,7 +12388,7 @@ void wlan_hdd_start_sap(struct hdd_adapter *ap_adapter, bool reinit)
 	wlansap_reset_sap_config_add_ie(sap_config, eUPDATE_IE_ALL);
 	set_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
 	if (hostapd_state->bss_state == BSS_START) {
-		policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
+		policy_mgr_incr_active_session(hdd_ctx->psoc,
 					ap_adapter->device_mode,
 					ap_adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, ap_adapter->device_mode,
@@ -13788,7 +13788,7 @@ static int hdd_update_pmo_config(struct hdd_context *hdd_ctx)
 	hdd_ra_populate_pmo_config(&psoc_cfg, hdd_ctx);
 	hdd_lpass_populate_pmo_config(&psoc_cfg, hdd_ctx);
 
-	status = ucfg_pmo_update_psoc_config(hdd_ctx->hdd_psoc, &psoc_cfg);
+	status = ucfg_pmo_update_psoc_config(hdd_ctx->psoc, &psoc_cfg);
 	if (QDF_IS_STATUS_ERROR(status))
 		hdd_err("failed pmo psoc configuration; status:%d", status);
 
@@ -13914,7 +13914,7 @@ hdd_update_score_config(struct scoring_config *score_config,
  */
 static int hdd_update_dfs_config(struct hdd_context *hdd_ctx)
 {
-	struct wlan_objmgr_psoc *psoc = hdd_ctx->hdd_psoc;
+	struct wlan_objmgr_psoc *psoc = hdd_ctx->psoc;
 	struct hdd_config *cfg = hdd_ctx->config;
 	struct dfs_user_config dfs_cfg;
 	QDF_STATUS status;
@@ -13937,7 +13937,7 @@ static int hdd_update_dfs_config(struct hdd_context *hdd_ctx)
  */
 static int hdd_update_scan_config(struct hdd_context *hdd_ctx)
 {
-	struct wlan_objmgr_psoc *psoc = hdd_ctx->hdd_psoc;
+	struct wlan_objmgr_psoc *psoc = hdd_ctx->psoc;
 	struct scan_user_cfg scan_cfg;
 	struct hdd_config *cfg = hdd_ctx->config;
 	QDF_STATUS status;
@@ -13955,7 +13955,7 @@ static int hdd_update_scan_config(struct hdd_context *hdd_ctx)
 		cfg->scanAgingTimeout * 1000;
 	scan_cfg.prefer_5ghz = cfg->nRoamPrefer5GHz;
 	scan_cfg.select_5ghz_margin = cfg->nSelect5GHzMargin;
-	ucfg_mlme_get_first_scan_bucket_threshold(hdd_ctx->hdd_psoc,
+	ucfg_mlme_get_first_scan_bucket_threshold(hdd_ctx->psoc,
 						  &scan_bucket_thre);
 	scan_cfg.scan_bucket_threshold = (int32_t)scan_bucket_thre;
 	scan_cfg.rssi_cat_gap = cfg->nRssiCatGap;
@@ -14253,7 +14253,7 @@ void hdd_restart_sap(struct hdd_adapter *ap_adapter)
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
-		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->psoc,
 			ap_adapter->device_mode, ap_adapter->session_id);
 		hdd_green_ap_start_state_mc(hdd_ctx, ap_adapter->device_mode,
 					    false);
@@ -14289,7 +14289,7 @@ void hdd_restart_sap(struct hdd_adapter *ap_adapter)
 		hdd_err("SAP Start Success");
 		set_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
 		if (hostapd_state->bss_state == BSS_START) {
-			policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
+			policy_mgr_incr_active_session(hdd_ctx->psoc,
 						ap_adapter->device_mode,
 						ap_adapter->session_id);
 			hdd_green_ap_start_state_mc(hdd_ctx,
@@ -14328,7 +14328,7 @@ void hdd_check_and_restart_sap_with_non_dfs_acs(void)
 		return;
 	}
 
-	if (policy_mgr_get_concurrency_mode(hdd_ctx->hdd_psoc)
+	if (policy_mgr_get_concurrency_mode(hdd_ctx->psoc)
 		!= (QDF_STA_MASK | QDF_SAP_MASK)) {
 		hdd_debug("Concurrency mode is not SAP");
 		return;
@@ -14472,7 +14472,7 @@ int hdd_reset_limit_off_chan(struct hdd_adapter *adapter)
 		return ret;
 
 	/* set the system preferece to default */
-	policy_mgr_set_cur_conc_system_pref(hdd_ctx->hdd_psoc,
+	policy_mgr_set_cur_conc_system_pref(hdd_ctx->psoc,
 			hdd_ctx->config->conc_system_pref);
 
 	/* clear the bitmap */