usbpd: implement new api to access PD discovery data

API pd_get_am_discovery() sets the lock (task access bit) to keep track
of EC tasks accessing the pd port discovery data. If any of the task
access bits are set,EC host task typec discovery handler will return
EC_RES_BUSY to host, indicating discovery data is modified while copying
port discovery data to the host. Hence the lock/task access bit should
be set only when the port discovery data is modified by any tasks.

Setting of lock/task access is removed from pd_get_am_discovery() and
implemented new api pd_get_am_discovery_and_notify_access() for this.
pd_get_am_discovery() proto type is changed to return 'constant pointer'
which forces developers to use pd_get_am_discovery_and_notify_access()
when they intend to access and modify discovery data.

summary of changes implemented.
- Remove setting of task access bit from pd_get_am_discovery().
- modify pd_get_am_discovery() prototype to return constant pointer.
- implement new api pd_get_am_discovery_and_notify_access()
- Replace calls to pd_get_am_discovery() with new api
  wherever discovery data is accessed and modified.

BRANCH=none
BUG=b:197466819 b:190390784
TEST=Verified 50 cold boot cycling with TBT device attached.
     Device detected in every cycle.

Signed-off-by: Deepti Deshatty <deepti.deshatty@intel.corp-partner.google.com>
Change-Id: I5b6f1f2b91d92ddbe58f3bf994f684abee948c02
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3139858
Reviewed-by: Abe Levkoy <alevkoy@chromium.org>
Commit-Queue: Abe Levkoy <alevkoy@chromium.org>

9 files changed, 92 insertions, 56 deletions

diff --git a/common/usb_pd_alt_mode_dfp.c b/common/usb_pd_alt_mode_dfp.c
index 49fbf4cc65..d7048f4c8e 100644
--- a/common/usb_pd_alt_mode_dfp.c
+++ b/common/usb_pd_alt_mode_dfp.c
@@ -79,7 +79,7 @@ static int pd_allocate_mode(int port, enum tcpci_msg_type type,
 	int i, j;
 	struct svdm_amode_data *modep;
 	int mode_idx = pd_get_mode_idx(port, type, svid);
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 	struct partner_active_modes *active =
 		pd_get_partner_active_modes(port, type);
 	assert(active);
@@ -96,7 +96,7 @@ static int pd_allocate_mode(int port, enum tcpci_msg_type type,
 	/* Allocate ...  if SVID == 0 enter default supported policy */
 	for (i = 0; i < supported_modes_cnt; i++) {
 		for (j = 0; j < disc->svid_cnt; j++) {
-			struct svid_mode_data *svidp = &disc->svids[j];
+			const struct svid_mode_data *svidp = &disc->svids[j];
 
 			/*
 			 * Looking for a match between supported_modes and
@@ -367,7 +367,7 @@ void dfp_consume_identity(int port, enum tcpci_msg_type type, int cnt,
 	}
 
 	ptype = PD_IDH_PTYPE(payload[VDO_I(IDH)]);
-	disc = pd_get_am_discovery(port, type);
+	disc = pd_get_am_discovery_and_notify_access(port, type);
 	identity_size = MIN(sizeof(union disc_ident_ack),
 				   (cnt - 1) * sizeof(uint32_t));
 
@@ -403,7 +403,8 @@ void dfp_consume_svids(int port, enum tcpci_msg_type type, int cnt,
 	uint32_t *ptr = payload + 1;
 	int vdo = 1;
 	uint16_t svid0, svid1;
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	struct pd_discovery *disc =
+			pd_get_am_discovery_and_notify_access(port, type);
 
 	for (i = disc->svid_cnt; i < disc->svid_cnt + 12; i += 2) {
 		if (i >= SVID_DISCOVERY_MAX) {
@@ -446,7 +447,8 @@ void dfp_consume_modes(int port, enum tcpci_msg_type type, int cnt,
 {
 	int svid_idx;
 	struct svid_mode_data *mode_discovery = NULL;
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	struct pd_discovery *disc =
+			pd_get_am_discovery_and_notify_access(port, type);
 	uint16_t response_svid = (uint16_t) PD_VDO_VID(payload[0]);
 
 	for (svid_idx = 0; svid_idx < disc->svid_cnt; ++svid_idx) {
@@ -498,7 +500,8 @@ int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 void pd_set_identity_discovery(int port, enum tcpci_msg_type type,
 			       enum pd_discovery_state disc)
 {
-	struct pd_discovery *pd = pd_get_am_discovery(port, type);
+	struct pd_discovery *pd =
+			pd_get_am_discovery_and_notify_access(port, type);
 
 	pd->identity_discovery = disc;
 }
@@ -506,7 +509,7 @@ void pd_set_identity_discovery(int port, enum tcpci_msg_type type,
 enum pd_discovery_state pd_get_identity_discovery(int port,
 						  enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->identity_discovery;
 }
@@ -547,7 +550,8 @@ uint8_t pd_get_product_type(int port)
 void pd_set_svids_discovery(int port, enum tcpci_msg_type type,
 			       enum pd_discovery_state disc)
 {
-	struct pd_discovery *pd = pd_get_am_discovery(port, type);
+	struct pd_discovery *pd =
+			pd_get_am_discovery_and_notify_access(port, type);
 
 	pd->svids_discovery = disc;
 }
@@ -555,21 +559,21 @@ void pd_set_svids_discovery(int port, enum tcpci_msg_type type,
 enum pd_discovery_state pd_get_svids_discovery(int port,
 		enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svids_discovery;
 }
 
 int pd_get_svid_count(int port, enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svid_cnt;
 }
 
 uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svids[svid_idx].svid;
 }
@@ -577,7 +581,8 @@ uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpci_msg_type type)
 void pd_set_modes_discovery(int port, enum tcpci_msg_type type,
 		uint16_t svid, enum pd_discovery_state disc)
 {
-	struct pd_discovery *pd = pd_get_am_discovery(port, type);
+	struct pd_discovery *pd =
+			pd_get_am_discovery_and_notify_access(port, type);
 	int svid_idx;
 
 	for (svid_idx = 0; svid_idx < pd->svid_cnt; ++svid_idx) {
@@ -610,7 +615,7 @@ int pd_get_mode_vdo_for_svid(int port, enum tcpci_msg_type type,
 		uint16_t svid, uint32_t *vdo_out)
 {
 	int idx;
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 
 	if (type >= DISCOVERY_TYPE_COUNT)
 		return 0;
@@ -627,17 +632,17 @@ int pd_get_mode_vdo_for_svid(int port, enum tcpci_msg_type type,
 	return 0;
 }
 
-struct svid_mode_data *pd_get_next_mode(int port,
+const struct svid_mode_data *pd_get_next_mode(int port,
 		enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
-	struct svid_mode_data *failed_mode_data = NULL;
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct svid_mode_data *failed_mode_data = NULL;
 	bool svid_good_discovery = false;
 	int svid_idx;
 
 	/* Walk through all of the discovery mode entries */
 	for (svid_idx = 0; svid_idx < disc->svid_cnt; ++svid_idx) {
-		struct svid_mode_data *mode_data = &disc->svids[svid_idx];
+		const struct svid_mode_data *mode_data = &disc->svids[svid_idx];
 
 		/* Discovery is needed, so send this one back now */
 		if (mode_data->discovery == PD_DISC_NEEDED)
@@ -662,10 +667,10 @@ struct svid_mode_data *pd_get_next_mode(int port,
 	return NULL;
 }
 
-uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
+const uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
 		enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, type);
+	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svids[svid_idx].mode_vdo;
 }
@@ -710,7 +715,7 @@ static inline bool is_pd_rev3(int port, enum tcpci_msg_type type)
  */
 bool is_vpd_ct_supported(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -719,7 +724,7 @@ bool is_vpd_ct_supported(int port)
 
 uint8_t get_vpd_ct_gnd_impedance(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -728,7 +733,7 @@ uint8_t get_vpd_ct_gnd_impedance(int port)
 
 uint8_t get_vpd_ct_vbus_impedance(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -737,7 +742,7 @@ uint8_t get_vpd_ct_vbus_impedance(int port)
 
 uint8_t get_vpd_ct_current_support(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -746,7 +751,7 @@ uint8_t get_vpd_ct_current_support(int port)
 
 uint8_t get_vpd_ct_max_vbus_voltage(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -755,7 +760,7 @@ uint8_t get_vpd_ct_max_vbus_voltage(int port)
 
 uint8_t get_vpd_ct_vdo_version(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -764,7 +769,7 @@ uint8_t get_vpd_ct_vdo_version(int port)
 
 uint8_t get_vpd_ct_firmware_verion(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -773,7 +778,7 @@ uint8_t get_vpd_ct_firmware_verion(int port)
 
 uint8_t get_vpd_ct_hw_version(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
@@ -789,7 +794,7 @@ uint8_t get_vpd_ct_hw_version(int port)
  */
 enum idh_ptype get_usb_pd_cable_type(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	return disc->identity.idh.product_type;
@@ -797,7 +802,7 @@ enum idh_ptype get_usb_pd_cable_type(int port)
 
 bool is_usb2_cable_support(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	return disc->identity.idh.product_type == IDH_PTYPE_PCABLE ||
@@ -808,7 +813,7 @@ bool is_usb2_cable_support(int port)
 
 bool is_cable_speed_gen2_capable(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	switch (pd_get_rev(port, TCPCI_MSG_SOP_PRIME)) {
@@ -828,7 +833,7 @@ bool is_cable_speed_gen2_capable(int port)
 
 bool is_active_cable_element_retimer(int port)
 {
-	struct pd_discovery *disc =
+	const struct pd_discovery *disc =
 		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	/* Ref: USB PD Spec 2.0 Table 6-29 Active Cable VDO
@@ -878,7 +883,7 @@ void set_tbt_compat_mode_ready(int port)
  */
 static bool is_tbt_cable_superspeed(int port)
 {
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 
 	if (!IS_ENABLED(CONFIG_USB_PD_TBT_COMPAT_MODE) ||
 	    !IS_ENABLED(CONFIG_USB_PD_DECODE_SOP))
@@ -944,7 +949,7 @@ enum tbt_compat_cable_speed get_tbt_cable_speed(int port)
 	 * enter Thunderbolt alternate mode.
 	 */
 	if (!cable_mode_resp.raw_value) {
-		struct pd_discovery *disc;
+		const struct pd_discovery *disc;
 
 		if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE)
 			return TBT_SS_RES_0;
@@ -1066,7 +1071,7 @@ enum usb_rev30_ss get_usb4_cable_speed(int port)
 
 	if ((get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) &&
 	     is_pd_rev3(port, TCPCI_MSG_SOP_PRIME)) {
-		struct pd_discovery *disc =
+		const struct pd_discovery *disc =
 			pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 		union active_cable_vdo1_rev30 a_rev30 =
 			disc->identity.product_t1.a_rev30;
@@ -1087,7 +1092,7 @@ uint32_t get_enter_usb_msg_payload(int port)
 	 * Table 6-47 Enter_USB Data Object
 	 */
 	union enter_usb_data_obj eudo;
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 	union tbt_mode_resp_cable cable_mode_resp;
 
 	if (!IS_ENABLED(CONFIG_USB_PD_USB4))
diff --git a/common/usb_pd_console_cmd.c b/common/usb_pd_console_cmd.c
index 984f9def91..3ad1944494 100644
--- a/common/usb_pd_console_cmd.c
+++ b/common/usb_pd_console_cmd.c
@@ -112,7 +112,7 @@ static int command_cable(int argc, char **argv)
 {
 	int port;
 	char *e;
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 	enum idh_ptype ptype;
 	int cable_rev;
 	union tbt_mode_resp_cable cable_mode_resp;
diff --git a/common/usb_pd_policy.c b/common/usb_pd_policy.c
index 08827abe21..de6fc63a60 100644
--- a/common/usb_pd_policy.c
+++ b/common/usb_pd_policy.c
@@ -373,7 +373,14 @@ static int dfp_discover_svids(uint32_t *payload)
 	return 1;
 }
 
-struct pd_discovery *pd_get_am_discovery(int port, enum tcpci_msg_type type)
+struct pd_discovery *pd_get_am_discovery_and_notify_access(
+				int port, enum tcpci_msg_type type)
+{
+	return (struct pd_discovery *)pd_get_am_discovery(port, type);
+}
+
+const struct pd_discovery *pd_get_am_discovery(int port,
+			enum tcpci_msg_type type)
 {
 	return &discovery[port][type];
 }
@@ -399,7 +406,8 @@ void pd_set_dfp_enter_mode_flag(int port, bool set)
  */
 static int dfp_discover_modes(int port, uint32_t *payload)
 {
-	struct pd_discovery *disc = pd_get_am_discovery(port, TCPCI_MSG_SOP);
+	const struct pd_discovery *disc =
+			pd_get_am_discovery(port, TCPCI_MSG_SOP);
 	uint16_t svid = disc->svids[disc->svid_idx].svid;
 
 	if (disc->svid_idx >= disc->svid_cnt)
diff --git a/common/usbc/tbt_alt_mode.c b/common/usbc/tbt_alt_mode.c
index 0509add1f8..73e2796345 100644
--- a/common/usbc/tbt_alt_mode.c
+++ b/common/usbc/tbt_alt_mode.c
@@ -218,7 +218,7 @@ static void tbt_retry_enter_mode(int port)
 /* Send Exit Mode to SOP''(if supported), or SOP' */
 static void tbt_active_cable_exit_mode(int port)
 {
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 
 	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
@@ -230,7 +230,7 @@ static void tbt_active_cable_exit_mode(int port)
 
 bool tbt_cable_entry_required_for_usb4(int port)
 {
-	struct pd_discovery *disc_sop_prime;
+	const struct pd_discovery *disc_sop_prime;
 	union tbt_mode_resp_cable cable_mode_resp;
 
 	/* Request to enter Thunderbolt mode for the cable prior to entering
@@ -262,7 +262,7 @@ bool tbt_cable_entry_required_for_usb4(int port)
 void intel_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 	const uint8_t vdm_cmd = PD_VDO_CMD(vdm[0]);
 	int opos_sop, opos_sop_prime;
 	union tbt_mode_resp_cable cable_mode_resp;
diff --git a/common/usbc/usb_mode.c b/common/usbc/usb_mode.c
index 1ed207353c..b9dc4973bc 100644
--- a/common/usbc/usb_mode.c
+++ b/common/usbc/usb_mode.c
@@ -176,7 +176,7 @@ bool enter_usb_cable_is_capable(int port)
 		if (get_usb4_cable_speed(port) < USB_R30_SS_U32_U40_GEN1)
 			return false;
 	} else if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) {
-		struct pd_discovery *disc_sop_prime =
+		const struct pd_discovery *disc_sop_prime =
 			pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 		if (pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME) >= VDM_VER20 &&
@@ -222,7 +222,7 @@ bool enter_usb_cable_is_capable(int port)
 
 void enter_usb_accepted(int port, enum tcpci_msg_type type)
 {
-	struct pd_discovery *disc;
+	const struct pd_discovery *disc;
 
 	if (!enter_usb_response_valid(port, type))
 		return;
@@ -269,7 +269,7 @@ void enter_usb_rejected(int port, enum tcpci_msg_type type)
 
 uint32_t enter_usb_setup_next_msg(int port, enum tcpci_msg_type *type)
 {
-	struct pd_discovery *disc_sop_prime;
+	const struct pd_discovery *disc_sop_prime;
 
 	switch (usb4_state[port]) {
 	case USB4_START:
diff --git a/common/usbc/usb_pd_host.c b/common/usbc/usb_pd_host.c
index 514ef82036..4d0fadeec3 100644
--- a/common/usbc/usb_pd_host.c
+++ b/common/usbc/usb_pd_host.c
@@ -44,7 +44,7 @@ static enum ec_status hc_typec_discovery(struct host_cmd_handler_args *args)
 	 */
 	pd_discovery_access_clear(p->port, type);
 
-	disc = pd_get_am_discovery(p->port, type);
+	disc = pd_get_am_discovery_and_notify_access(p->port, type);
 
 	/* Initialize return size to that of discovery with no SVIDs */
 	args->response_size = sizeof(*r);
@@ -89,8 +89,10 @@ static enum ec_status hc_typec_discovery(struct host_cmd_handler_args *args)
 	 * of the copy.  If the data was accessed, return BUSY so the AP will
 	 * try retrieving again and get the updated data.
 	 */
-	if (!pd_discovery_access_validate(p->port, type))
+	if (!pd_discovery_access_validate(p->port, type)) {
+		CPRINTS("[C%d] %s returns EC_RES_BUSY!!\n", p->port, __func__);
 		return EC_RES_BUSY;
+	}
 
 	return EC_RES_SUCCESS;
 }
diff --git a/common/usbc/usb_pe_drp_sm.c b/common/usbc/usb_pe_drp_sm.c
index 59d45b0e28..096f689b0a 100644
--- a/common/usbc/usb_pe_drp_sm.c
+++ b/common/usbc/usb_pe_drp_sm.c
@@ -5762,7 +5762,7 @@ static void pe_init_vdm_modes_request_entry(int port)
 
 static void pe_init_vdm_modes_request_run(int port)
 {
-	struct svid_mode_data *mode_data;
+	const struct svid_mode_data *mode_data;
 	uint16_t requested_svid;
 
 	mode_data = pd_get_next_mode(port, pe[port].tx_type);
@@ -7050,14 +7050,20 @@ __maybe_unused bool pd_discovery_access_validate(int port,
 	return !(task_access[port][type] & ~BIT(task_get_current()));
 }
 
-__maybe_unused struct pd_discovery *pd_get_am_discovery(int port,
+__maybe_unused struct pd_discovery *pd_get_am_discovery_and_notify_access(
+				int port, enum tcpci_msg_type type)
+{
+	atomic_or(&task_access[port][type], BIT(task_get_current()));
+	return (struct pd_discovery *)pd_get_am_discovery(port, type);
+}
+
+__maybe_unused const struct pd_discovery *pd_get_am_discovery(int port,
 			enum tcpci_msg_type type)
 {
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		assert(0);
 	ASSERT(type < DISCOVERY_TYPE_COUNT);
 
-	atomic_or(&task_access[port][type], BIT(task_get_current()));
 	return &pe[port].discovery[type];
 }
 
diff --git a/include/usb_pd.h b/include/usb_pd.h
index e57f4a4d2a..42771c8de5 100644
--- a/include/usb_pd.h
+++ b/include/usb_pd.h
@@ -372,7 +372,7 @@ struct svdm_amode_data {
 	/* VDM object position */
 	int opos;
 	/* mode capabilities specific to SVID amode. */
-	struct svid_mode_data *data;
+	const struct svid_mode_data *data;
 };
 
 enum hpd_event {
@@ -1987,7 +1987,8 @@ int pd_get_mode_vdo_for_svid(int port, enum tcpci_msg_type type,
  *             mode, if any exist and no modes succeeded in discovery;
  *             NULL, otherwise
  */
-struct svid_mode_data *pd_get_next_mode(int port, enum tcpci_msg_type type);
+const struct svid_mode_data *pd_get_next_mode(int port,
+		enum tcpci_msg_type type);
 
 /**
  * Return a pointer to the discover identity response structure for this SOP*
@@ -2053,7 +2054,7 @@ uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpci_msg_type type);
  * @param type     SOP* type to retrieve
  * @return         Pointer to modes of VDO
  */
-uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
+const uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
 		enum tcpci_msg_type type);
 
 /*
@@ -2144,7 +2145,18 @@ bool pd_discovery_access_validate(int port, enum tcpci_msg_type type);
  * @param type Transmit type (SOP, SOP') for discovered information
  * @return     pointer to PD alternate mode discovery results
  */
-struct pd_discovery *pd_get_am_discovery(int port,
+struct pd_discovery *pd_get_am_discovery_and_notify_access(int port,
+		enum tcpci_msg_type type);
+
+/*
+ * Returns the constant pointer to PD alternate mode discovery results
+ * Note: Caller function is expected to only read the discovery results.
+ *
+ * @param port USB-C port number
+ * @param type Transmit type (SOP, SOP') for discovered information
+ * @return     pointer to PD alternate mode discovery results
+ */
+const struct pd_discovery *pd_get_am_discovery(int port,
 		enum tcpci_msg_type type);
 
 /*
diff --git a/zephyr/test/drivers/src/bb_retimer.c b/zephyr/test/drivers/src/bb_retimer.c
index 38111ce4e5..eb48fb0789 100644
--- a/zephyr/test/drivers/src/bb_retimer.c
+++ b/zephyr/test/drivers/src/bb_retimer.c
@@ -90,7 +90,8 @@ static void test_bb_set_state(void)
 		      exp_conn, conn);
 
 	/* Test USB3 gen2 mode */
-	disc = pd_get_am_discovery(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME);
+	disc = pd_get_am_discovery_and_notify_access(
+					USBC_PORT_C1, TCPCI_MSG_SOP_PRIME);
 	disc->identity.product_t1.p_rev20.ss = USB_R20_SS_U31_GEN1_GEN2;
 	prl_set_rev(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME, PD_REV30);
 	zassert_equal(EC_SUCCESS, bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
@@ -210,7 +211,8 @@ static void test_bb_set_dfp_state(void)
 		      exp_conn, conn);
 
 	/* Set active cable type */
-	disc = pd_get_am_discovery(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME);
+	disc = pd_get_am_discovery_and_notify_access(
+					USBC_PORT_C1, TCPCI_MSG_SOP_PRIME);
 	disc->identity.idh.product_type = IDH_PTYPE_ACABLE;
 	disc->identity.product_t2.a2_rev30.active_elem = ACTIVE_RETIMER;
 	prl_set_rev(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME, PD_REV30);
@@ -230,7 +232,8 @@ static void test_bb_set_dfp_state(void)
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 
 	/* Set device VDO */
-	dev_disc = pd_get_am_discovery(USBC_PORT_C1, TCPCI_MSG_SOP);
+	dev_disc = pd_get_am_discovery_and_notify_access(
+						USBC_PORT_C1, TCPCI_MSG_SOP);
 	dev_disc->svid_cnt = 1;
 	dev_disc->svids[0].svid = USB_VID_INTEL;
 	dev_disc->svids[0].discovery = PD_DISC_COMPLETE;