qcacld-3.0: Send async event to user space in case of roaming

Currently, if SR (Spatial Reuse) is supported by AP and then
STA roams to another AP then host needs to parse SR IE and
send events to userspace and commands to Fw based on below
scenarios:

i.) Roamed AP doesn't support SR: If roamed AP doesn't support
SR then async event with SR disable is required to be sent to
userspace.

ii.) Roamed AP supports SR: If roamed AP supports SR then below
validations are required.

a.) existing thresholds are in range of roamed AP: Send SR enable
command to FW with previous thresholds , as FW disables SR during
roaming.

b.) existing thresholds are not in range of roamed AP: then decision
will be based on whether threshold is provided during SR enable command
or not. If threshold is provided along with SR enable command then send
disable to userspace and in other case update thresholds as per roamed
AP , send async event to userspace with new configured values and send
enable command to fw with new thresholds.

Change-Id: I0c39de349c0f723d49d510c6e8ba09dcb98c6d17
CRs-Fixed: 3316985

components/spatial_reuse/dispatcher/src/spatial_reuse_ucfg_api.c

@@ -33,7 +33,7 @@ void ucfg_spatial_reuse_get_sr_config(struct wlan_objmgr_vdev *vdev,
 				      bool *he_spr_enabled)
 {
 	*sr_ctrl = wlan_vdev_mlme_get_sr_ctrl(vdev);
-	*non_srg_max_pd_offset = wlan_vdev_mlme_get_pd_offset(vdev);
+	*non_srg_max_pd_offset = wlan_vdev_mlme_get_non_srg_pd_offset(vdev);
 	*he_spr_enabled = wlan_vdev_mlme_get_he_spr_enabled(vdev);
 }
 
@@ -42,7 +42,7 @@ void ucfg_spatial_reuse_set_sr_config(struct wlan_objmgr_vdev *vdev,
 				      uint8_t non_srg_max_pd_offset)
 {
 	wlan_vdev_mlme_set_sr_ctrl(vdev, sr_ctrl);
-	wlan_vdev_mlme_set_pd_offset(vdev, non_srg_max_pd_offset);
+	wlan_vdev_mlme_set_non_srg_pd_offset(vdev, non_srg_max_pd_offset);
 }
 
 bool ucfg_spatial_reuse_is_sr_disabled_due_conc(struct wlan_objmgr_vdev *vdev)
@@ -72,7 +72,8 @@ void ucfg_spatial_reuse_send_sr_config(struct wlan_objmgr_vdev *vdev,
 
 	if (enable) {
 		sr_ctrl = wlan_vdev_mlme_get_sr_ctrl(vdev);
-		non_srg_max_pd_offset = wlan_vdev_mlme_get_pd_offset(vdev);
+		non_srg_max_pd_offset =
+				wlan_vdev_mlme_get_non_srg_pd_offset(vdev);
 		if (sr_ctrl && non_srg_max_pd_offset)
 			wlan_spatial_reuse_config_set(vdev, sr_ctrl,
 						      non_srg_max_pd_offset);

core/hdd/src/wlan_hdd_he.c

@@ -33,6 +33,7 @@
 #include "spatial_reuse_ucfg_api.h"
 #include "cdp_txrx_host_stats.h"
 #include "wlan_policy_mgr_i.h"
+#include "wlan_objmgr_vdev_obj.h"
 
 const struct nla_policy
 wlan_hdd_sr_policy[QCA_WLAN_VENDOR_ATTR_SR_MAX + 1] = {
@@ -291,17 +292,22 @@ hdd_sr_event_convert_operation(enum sr_osif_operation sr_osif_oper,
 	return status;
 }
 
-static QDF_STATUS hdd_sr_pack_conc_event(struct sk_buff *skb,
+static QDF_STATUS hdd_sr_pack_suspend_resume_event(
+					 struct sk_buff *skb,
 					 enum qca_wlan_sr_operation sr_nl_oper,
-					 enum qca_wlan_sr_reason_code sr_nl_rc)
+					 enum qca_wlan_sr_reason_code sr_nl_rc,
+					 uint8_t srg_max_pd_offset,
+					 uint8_t srg_min_pd_offset,
+					 uint8_t non_srg_max_pd_offset)
 {
 	struct nlattr *attr;
 	QDF_STATUS status = QDF_STATUS_E_FAULT;
 
-	if (sr_nl_rc != QCA_WLAN_SR_REASON_CODE_CONCURRENCY ||
-	    (sr_nl_oper != QCA_WLAN_SR_OPERATION_SR_SUSPEND &&
-	     sr_nl_oper != QCA_WLAN_SR_OPERATION_SR_RESUME)) {
-		hdd_err("SR concurrency operation is invalid");
+	if (((sr_nl_rc != QCA_WLAN_SR_REASON_CODE_CONCURRENCY) &&
+	     (sr_nl_rc != QCA_WLAN_SR_REASON_CODE_ROAMING)) ||
+	    ((sr_nl_oper != QCA_WLAN_SR_OPERATION_SR_SUSPEND) &&
+	     (sr_nl_oper != QCA_WLAN_SR_OPERATION_SR_RESUME))) {
+		hdd_err("SR operation is invalid");
 		status = QDF_STATUS_E_INVAL;
 		goto sr_events_end;
 	}
@@ -322,6 +328,30 @@ static QDF_STATUS hdd_sr_pack_conc_event(struct sk_buff *skb,
 		hdd_err("failed to put attr SR Reascon Code");
 		goto sr_events_end;
 	}
+	if (sr_nl_rc == QCA_WLAN_SR_REASON_CODE_ROAMING &&
+	    sr_nl_oper == QCA_WLAN_SR_OPERATION_SR_RESUME) {
+		if (nla_put_u32(
+			skb,
+			QCA_WLAN_VENDOR_ATTR_SR_PARAMS_SRG_OBSS_PD_MIN_OFFSET,
+			srg_min_pd_offset)) {
+			hdd_err("srg_pd_min_offset put fail");
+			goto sr_events_end;
+		}
+		if (nla_put_u32(
+			skb,
+			QCA_WLAN_VENDOR_ATTR_SR_PARAMS_SRG_OBSS_PD_MAX_OFFSET,
+			srg_max_pd_offset)) {
+			hdd_err("srg_pd_min_offset put fail");
+			goto sr_events_end;
+		}
+		if (nla_put_u32(
+		      skb,
+		      QCA_WLAN_VENDOR_ATTR_SR_PARAMS_NON_SRG_OBSS_PD_MAX_OFFSET,
+		      non_srg_max_pd_offset)) {
+			hdd_err("non_srg_pd_offset put fail");
+			goto sr_events_end;
+		}
+	}
 	status = QDF_STATUS_SUCCESS;
 	nla_nest_end(skb, attr);
 
@@ -339,6 +369,9 @@ static void hdd_sr_osif_events(struct wlan_objmgr_vdev *vdev,
 	struct sk_buff *skb;
 	uint32_t idx = QCA_NL80211_VENDOR_SUBCMD_SR_INDEX;
 	uint32_t len = NLMSG_HDRLEN;
+	uint8_t non_srg_max_pd_offset = 0;
+	uint8_t srg_max_pd_offset = 0;
+	uint8_t srg_min_pd_offset = 0;
 	QDF_STATUS status;
 	enum qca_wlan_sr_operation sr_nl_oper;
 	enum qca_wlan_sr_reason_code sr_nl_rc;
@@ -354,6 +387,9 @@ static void hdd_sr_osif_events(struct wlan_objmgr_vdev *vdev,
 		return;
 	}
 
+	wlan_vdev_mlme_get_srg_pd_offset(vdev, &srg_max_pd_offset,
+					 &srg_min_pd_offset);
+	non_srg_max_pd_offset = wlan_vdev_mlme_get_non_srg_pd_offset(vdev);
 	status = hdd_sr_event_convert_operation(sr_osif_oper, &sr_nl_oper);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Invalid SR Operation: %d", sr_osif_oper);
@@ -370,11 +406,29 @@ static void hdd_sr_osif_events(struct wlan_objmgr_vdev *vdev,
 	switch (sr_nl_oper) {
 	case QCA_WLAN_SR_OPERATION_SR_SUSPEND:
 	case QCA_WLAN_SR_OPERATION_SR_RESUME:
-		if (sr_nl_rc == QCA_WLAN_SR_REASON_CODE_CONCURRENCY) {
+		if (sr_nl_rc == QCA_WLAN_SR_REASON_CODE_CONCURRENCY ||
+		    sr_nl_rc == QCA_WLAN_SR_REASON_CODE_ROAMING) {
 			wiphy = adapter->hdd_ctx->wiphy;
 			wdev = &adapter->wdev;
-			len += nla_total_size(sizeof(uint8_t)) +
-			       nla_total_size(sizeof(uint32_t));
+			/* QCA_WLAN_VENDOR_ATTR_SR_OPERATION */
+			len += nla_total_size(sizeof(uint8_t));
+			/* QCA_WLAN_VENDOR_ATTR_SR_PARAMS_REASON_CODE */
+			len += nla_total_size(sizeof(uint32_t));
+			/* QCA_WLAN_VENDOR_ATTR_SR_PARAMS */
+			len += nla_total_size(0);
+			/*
+			 * In case of resume due to roaming additional config
+			 * params are required to be sent.
+			 */
+			if (sr_nl_rc == QCA_WLAN_SR_REASON_CODE_ROAMING &&
+			    sr_nl_oper == QCA_WLAN_SR_OPERATION_SR_RESUME) {
+				/* SR_PARAMS_SRG_OBSS_PD_MIN_OFFSET */
+				len += nla_total_size(sizeof(int32_t));
+				/* SR_PARAMS_SRG_OBSS_PD_MAX_OFFSET */
+				len += nla_total_size(sizeof(int32_t));
+				/* SR_PARAMS_NON_SRG_OBSS_PD_MAX_OFFSET */
+				len += nla_total_size(sizeof(int32_t));
+			}
 			skb = wlan_cfg80211_vendor_event_alloc(wiphy, wdev,
 							       len, idx,
 							       GFP_KERNEL);
@@ -382,8 +436,10 @@ static void hdd_sr_osif_events(struct wlan_objmgr_vdev *vdev,
 				hdd_err("cfg80211_vendor_event_alloc failed");
 				return;
 			}
-			status = hdd_sr_pack_conc_event(skb, sr_nl_oper,
-							sr_nl_rc);
+			status = hdd_sr_pack_suspend_resume_event(
+					skb, sr_nl_oper, sr_nl_rc,
+					srg_max_pd_offset, srg_min_pd_offset,
+					non_srg_max_pd_offset);
 			if (QDF_IS_STATUS_ERROR(status)) {
 				kfree_skb(skb);
 				return;
@@ -598,7 +654,7 @@ static int __wlan_hdd_cfg80211_sr_operations(struct wiphy *wiphy,
 	struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
 	struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(wdev->netdev);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SR_MAX + 1];
-	struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_SR_PARAMS_MAX + 1];
+	struct nlattr *tb2[QCA_WLAN_VENDOR_ATTR_SR_PARAMS_MAX + 1] = {0};
 	enum qca_wlan_sr_operation sr_oper;
 	struct nlattr *sr_oper_attr;
 	struct nlattr *sr_param_attr;
@@ -695,6 +751,8 @@ static int __wlan_hdd_cfg80211_sr_operations(struct wiphy *wiphy,
 			srg_pd_threshold =
 			nla_get_s32(
 			tb2[QCA_WLAN_VENDOR_ATTR_SR_PARAMS_SRG_PD_THRESHOLD]);
+			wlan_vdev_mlme_set_pd_threshold_present(adapter->vdev,
+								true);
 		}
 
 		if (is_sr_enable &&
@@ -703,6 +761,8 @@ static int __wlan_hdd_cfg80211_sr_operations(struct wiphy *wiphy,
 			nla_get_s32(
 			tb2[QCA_WLAN_VENDOR_ATTR_SR_PARAMS_NON_SRG_PD_THRESHOLD]
 			);
+			wlan_vdev_mlme_set_pd_threshold_present(adapter->vdev,
+								true);
 		}
 		hdd_debug("setting sr enable %d with pd threshold srg: %d non srg: %d",
 			  is_sr_enable, srg_pd_threshold, non_srg_pd_threshold);
@@ -768,7 +828,7 @@ static int __wlan_hdd_cfg80211_sr_operations(struct wiphy *wiphy,
 						 &srg_max_pd_offset,
 						 &srg_min_pd_offset);
 		non_srg_max_pd_offset =
-			wlan_vdev_mlme_get_pd_offset(adapter->vdev);
+			wlan_vdev_mlme_get_non_srg_pd_offset(adapter->vdev);
 		sr_ctrl = wlan_vdev_mlme_get_sr_ctrl(adapter->vdev);
 		nl_buf_len = hdd_get_srp_param_len();
 		skb = cfg80211_vendor_cmd_alloc_reply_skb(hdd_ctx->wiphy,

core/mac/src/pe/include/lim_api.h

@@ -69,6 +69,22 @@
 /*mac->lim.gLimProcessDefdMsgs*/
 #define GET_LIM_PROCESS_DEFD_MESGS(mac) (mac->lim.gLimProcessDefdMsgs)
 
+#ifdef WLAN_FEATURE_SR
+/**
+ * enum sr_status_of_roamed_ap - SR(Spatial Reuse) status of roamed AP
+ * SR_DISALLOW: SR not supported by roamed AP
+ * SR_THRESHOLD_IN_RANGE_OF_PREVIOUS_AP: SR supported by roamed AP
+ * and configured threshold is in range.
+ * SR_THRESHOLD_NOT_IN_RANGE_OF_PREVIOUS_AP: SR supported by roamed AP
+ * and configured threshold is not in range.
+ */
+enum sr_status_of_roamed_ap {
+	SR_DISALLOW,
+	SR_THRESHOLD_IN_RANGE_OF_ROAMED_AP,
+	SR_THRESHOLD_NOT_IN_RANGE_OF_ROAMED_AP,
+};
+#endif
+
 /**
  * lim_post_msg_api() - post normal priority PE message
  * @mac: mac context
@@ -647,12 +663,27 @@ lim_gen_link_probe_rsp_roam(struct mac_context *mac_ctx,
  */
 void lim_update_vdev_sr_elements(struct pe_session *session_entry,
 				 tpDphHashNode sta_ds);
+
+/**
+ * lim_process_srp_ie() - process srp ie during re/association
+ * @tpSirAssocRsp: assoc response
+ * @tpDphHashNode: sta node
+ *
+ * Return: success/failure
+ */
+QDF_STATUS lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds);
 #else
 static inline void
 lim_update_vdev_sr_elements(struct pe_session *session_entry,
 			    tpDphHashNode sta_ds)
 {
 }
+
+static inline
+QDF_STATUS lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds)
+{
+	return QDF_STATUS_SUCCESS;
+}
 #endif
 
 #if defined(WLAN_FEATURE_ROAM_OFFLOAD) && defined(WLAN_FEATURE_11BE_MLO)

core/mac/src/pe/lim/lim_api.c

@@ -86,6 +86,7 @@
 #include "wlan_mlo_mgr_sta.h"
 #include "wlan_mlo_mgr_peer.h"
 #include <wlan_twt_api.h>
+#include "spatial_reuse_api.h"
 
 struct pe_hang_event_fixed_param {
 	uint16_t tlv_header;
@@ -2700,6 +2701,110 @@ static inline void pe_roam_fill_obss_scan_param(struct pe_session *src_session,
 }
 #endif
 
+#ifdef WLAN_FEATURE_SR
+/**
+ * lim_handle_sr_cap() - To handle SR(Spatial Reuse) capability
+ * of roamed AP
+ * @vdev: objmgr vdev
+ *
+ * This function is to check and compare SR cap of previous and
+ * roamed AP and takes decision to send event to userspace.
+ *
+ * Return: None
+ */
+static void lim_handle_sr_cap(struct wlan_objmgr_vdev *vdev)
+{
+	int32_t non_srg_pd_threshold = 0;
+	int32_t srg_pd_threshold = 0;
+	uint8_t non_srg_pd_offset = 0;
+	uint8_t srg_max_pd_offset = 0;
+	uint8_t srg_min_pd_offset = 0;
+	uint8_t sr_ctrl;
+	bool is_pd_threshold_present = false;
+	struct wlan_objmgr_pdev *pdev;
+	enum sr_status_of_roamed_ap sr_status;
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		pe_err("invalid pdev");
+		return;
+	}
+	non_srg_pd_offset = wlan_vdev_mlme_get_non_srg_pd_offset(vdev);
+	wlan_vdev_mlme_get_srg_pd_offset(vdev, &srg_max_pd_offset,
+					 &srg_min_pd_offset);
+	wlan_vdev_mlme_get_current_non_srg_pd_threshold(vdev,
+							&non_srg_pd_threshold);
+	wlan_vdev_mlme_get_current_srg_pd_threshold(vdev,
+						    &srg_pd_threshold);
+
+	sr_ctrl = wlan_vdev_mlme_get_sr_ctrl(vdev);
+	if ((sr_ctrl & NON_SRG_PD_SR_DISALLOWED) &&
+	    (!(sr_ctrl & SRG_INFO_PRESENT))) {
+		sr_status = SR_DISALLOW;
+	} else {
+		if ((!(sr_ctrl & NON_SRG_PD_SR_DISALLOWED) &&
+		     (non_srg_pd_threshold > non_srg_pd_offset +
+		      SR_PD_THRESHOLD_MIN)) ||
+		     ((sr_ctrl & SRG_INFO_PRESENT) &&
+		      ((srg_pd_threshold > srg_max_pd_offset +
+		     SR_PD_THRESHOLD_MIN) ||
+		      (srg_pd_threshold < srg_min_pd_offset +
+		       SR_PD_THRESHOLD_MIN))))
+			sr_status = SR_THRESHOLD_NOT_IN_RANGE_OF_ROAMED_AP;
+		else
+			sr_status = SR_THRESHOLD_IN_RANGE_OF_ROAMED_AP;
+	}
+	pe_debug("sr status of roamed AP %d existing thresholds srg: %d non-srg: %d roamed AP sr offset srg: max %d min %d non-srg: %d",
+		 sr_status, srg_pd_threshold, non_srg_pd_threshold,
+		 srg_max_pd_offset, srg_min_pd_offset, non_srg_pd_offset);
+	switch (sr_status) {
+	case SR_DISALLOW:
+		/** clear thresholds set by previous AP **/
+		wlan_vdev_mlme_set_current_non_srg_pd_threshold(vdev, 0);
+		wlan_vdev_mlme_set_current_srg_pd_threshold(vdev, 0);
+		wlan_spatial_reuse_osif_event(vdev,
+					      SR_OPERATION_SUSPEND,
+					      SR_REASON_CODE_ROAMING);
+	break;
+	case SR_THRESHOLD_NOT_IN_RANGE_OF_ROAMED_AP:
+		wlan_vdev_mlme_get_pd_threshold_present(
+						vdev, &is_pd_threshold_present);
+		/*
+		 * if userspace gives pd threshold then check if its within
+		 * range of roamed AP's min and max thresholds, if not in
+		 * range disable and let userspace decide to re-enable.
+		 * if userspace dosesnt give PD threshold then always enable
+		 * SRG based on AP's recommendation of thresholds.
+		 */
+		if (is_pd_threshold_present) {
+			wlan_vdev_mlme_set_current_non_srg_pd_threshold(vdev,
+									0);
+			wlan_vdev_mlme_set_current_srg_pd_threshold(vdev, 0);
+			wlan_spatial_reuse_osif_event(vdev,
+						      SR_OPERATION_SUSPEND,
+						      SR_REASON_CODE_ROAMING);
+		} else {
+			wlan_sr_setup_req(
+				vdev, pdev, true,
+				srg_max_pd_offset + SR_PD_THRESHOLD_MIN,
+				non_srg_pd_threshold + SR_PD_THRESHOLD_MIN);
+			wlan_spatial_reuse_osif_event(vdev,
+						      SR_OPERATION_RESUME,
+						      SR_REASON_CODE_ROAMING);
+		}
+	break;
+	case SR_THRESHOLD_IN_RANGE_OF_ROAMED_AP:
+		/* Send enable command to fw, as fw disables SR on roaming */
+		wlan_sr_setup_req(vdev, pdev, true, srg_pd_threshold,
+				  non_srg_pd_threshold);
+	break;
+	}
+}
+#else
+static void lim_handle_sr_cap(struct wlan_objmgr_vdev *vdev)
+{}
+#endif
+
 QDF_STATUS
 pe_roam_synch_callback(struct mac_context *mac_ctx,
 		       uint8_t vdev_id,
@@ -2903,7 +3008,6 @@ pe_roam_synch_callback(struct mac_context *mac_ctx,
 
 	lim_copy_and_free_hlp_data_from_session(ft_session_ptr,
 						roam_sync_ind_ptr);
-
 	roam_sync_ind_ptr->aid = ft_session_ptr->limAID;
 	curr_sta_ds->mlmStaContext.mlmState = eLIM_MLM_LINK_ESTABLISHED_STATE;
 	curr_sta_ds->nss = ft_session_ptr->nss;
@@ -2913,6 +3017,7 @@ pe_roam_synch_callback(struct mac_context *mac_ctx,
 	lim_init_tdls_data(mac_ctx, ft_session_ptr);
 	ric_tspec_len = ft_session_ptr->RICDataLen;
 	pe_debug("LFR3: Session RicLength: %d", ft_session_ptr->RICDataLen);
+	lim_handle_sr_cap(ft_session_ptr->vdev);
 #ifdef FEATURE_WLAN_ESE
 	ric_tspec_len += ft_session_ptr->tspecLen;
 	pe_debug("LFR3: tspecLen: %d", ft_session_ptr->tspecLen);
@@ -2954,7 +3059,6 @@ pe_roam_synch_callback(struct mac_context *mac_ctx,
 	ft_session_ptr->limSmeState = eLIM_SME_LINK_EST_STATE;
 	ft_session_ptr->limPrevSmeState = ft_session_ptr->limSmeState;
 	ft_session_ptr->bRoamSynchInProgress = false;
-
 	return QDF_STATUS_SUCCESS;
 }
 #endif
@@ -3943,8 +4047,8 @@ void lim_update_vdev_sr_elements(struct pe_session *session_entry,
 		 srg_max_pd_offset);
 
 	wlan_vdev_mlme_set_sr_ctrl(session_entry->vdev, sr_ctrl);
-	wlan_vdev_mlme_set_pd_offset(session_entry->vdev,
-				     non_srg_max_pd_offset);
+	wlan_vdev_mlme_set_non_srg_pd_offset(session_entry->vdev,
+					     non_srg_max_pd_offset);
 	wlan_vdev_mlme_set_srg_pd_offset(session_entry->vdev, srg_max_pd_offset,
 					 srg_min_pd_offset);
 }

core/mac/src/pe/lim/lim_process_assoc_rsp_frame.c

@@ -313,6 +313,8 @@ void lim_update_assoc_sta_datas(struct mac_context *mac_ctx,
 		 */
 		pe_debug("OMN IE is present in the assoc rsp, update NSS/Ch width");
 	}
+	if (lim_process_srp_ie(assoc_rsp, sta_ds) == QDF_STATUS_SUCCESS)
+		lim_update_vdev_sr_elements(session_entry, sta_ds);
 }
 
 /**
@@ -574,7 +576,7 @@ static inline void lim_process_he_info(tpSirProbeRespBeacon beacon,
 #endif
 
 #ifdef WLAN_FEATURE_SR
-static QDF_STATUS lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds)
+QDF_STATUS lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds)
 {
 	QDF_STATUS status = QDF_STATUS_E_NOSUPPORT;
 
@@ -585,12 +587,6 @@ static QDF_STATUS lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds)
 
 	return status;
 }
-#else
-static inline QDF_STATUS
-lim_process_srp_ie(tpSirAssocRsp ar, tpDphHashNode sta_ds)
-{
-	return QDF_STATUS_SUCCESS;
-}
 #endif
 
 #ifdef WLAN_FEATURE_11BE

core/mac/src/pe/lim/lim_send_sme_rsp_messages.c

@@ -2394,7 +2394,8 @@ lim_update_spatial_reuse(struct pe_session *session)
 	uint8_t vdev_id = session->vdev_id;
 
 	sr_ctrl = wlan_vdev_mlme_get_sr_ctrl(session->vdev);
-	non_srg_pd_max_offset = wlan_vdev_mlme_get_pd_offset(session->vdev);
+	non_srg_pd_max_offset =
+		wlan_vdev_mlme_get_non_srg_pd_offset(session->vdev);
 	if (non_srg_pd_max_offset && sr_ctrl &&
 	    wlan_vdev_mlme_get_he_spr_enabled(session->vdev)) {
 		psoc = wlan_vdev_get_psoc(session->vdev);

core/mac/src/sys/legacy/src/utils/src/parser_api.c

@@ -7163,7 +7163,7 @@ populate_dot11f_sr_info(struct mac_context *mac_ctx,
 	    !(sr_ctrl & WLAN_HE_NON_SRG_OFFSET_PRESENT))
 		return QDF_STATUS_SUCCESS;
 
-	non_srg_pd_offset = wlan_vdev_mlme_get_pd_offset(session->vdev);
+	non_srg_pd_offset = wlan_vdev_mlme_get_non_srg_pd_offset(session->vdev);
 	sr_info->present = 1;
 	sr_info->psr_disallow = 1;
 	sr_info->non_srg_pd_sr_disallow = 0;

core/wma/src/wma_features.c

@@ -763,7 +763,7 @@ QDF_STATUS wma_sr_update(tp_wma_handle wma, uint8_t vdev_id, bool enable)
 		} else {
 			/* VDEV down, disable SR */
 			wlan_vdev_mlme_set_sr_ctrl(vdev, 0);
-			wlan_vdev_mlme_set_pd_offset(vdev, 0);
+			wlan_vdev_mlme_set_non_srg_pd_offset(vdev, 0);
 		}
 
 		wma_debug("SR param val: %x, Enable: %x", val, enable);