TCPM: Rename enum tcpm_sop_type and its constants

As a followup to CL:3104290, give the TCPCI TRANSMIT and
RX_BUF_FRAME_TYPE types more consistent names. Most of them can be used
for receiving, not just transmitting. Fix lint errors thus revealed.

BUG=b:155476419
TEST=make buildall
BRANCH=none

Signed-off-by: Abe Levkoy <alevkoy@chromium.org>
Change-Id: I399ec479eacc18622fc4d3f55f8bdabf4560fcff
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3125995
Reviewed-by: Keith Short <keithshort@chromium.org>

91 files changed, 779 insertions, 771 deletions

diff --git a/baseboard/brask/usb_pd_policy.c b/baseboard/brask/usb_pd_policy.c
index c603bbed24..33de5ca5eb 100644
--- a/baseboard/brask/usb_pd_policy.c
+++ b/baseboard/brask/usb_pd_policy.c
@@ -132,7 +132,7 @@ static int svdm_tbt_compat_response_identity(int port, uint32_t *payload)
 	payload[VDO_I(CSTAT)] = VDO_CSTAT(0);
 	payload[VDO_I(PRODUCT)] = vdo_product;
 
-	if (pd_get_rev(port, TCPC_TX_SOP) == PD_REV30) {
+	if (pd_get_rev(port, TCPCI_MSG_SOP) == PD_REV30) {
 		/* PD Revision 3.0 */
 		payload[VDO_I(IDH)] = vdo_idh_rev30;
 		payload[VDO_I(PTYPE_UFP1_VDO)] = vdo_ufp1;
diff --git a/baseboard/brya/usb_pd_policy.c b/baseboard/brya/usb_pd_policy.c
index 1637a8bfac..df291bd9c9 100644
--- a/baseboard/brya/usb_pd_policy.c
+++ b/baseboard/brya/usb_pd_policy.c
@@ -132,7 +132,7 @@ static int svdm_tbt_compat_response_identity(int port, uint32_t *payload)
 	payload[VDO_I(CSTAT)] = VDO_CSTAT(0);
 	payload[VDO_I(PRODUCT)] = vdo_product;
 
-	if (pd_get_rev(port, TCPC_TX_SOP) == PD_REV30) {
+	if (pd_get_rev(port, TCPCI_MSG_SOP) == PD_REV30) {
 		/* PD Revision 3.0 */
 		payload[VDO_I(IDH)] = vdo_idh_rev30;
 		payload[VDO_I(PTYPE_UFP1_VDO)] = vdo_ufp1;
diff --git a/baseboard/grunt/usb_pd_policy.c b/baseboard/grunt/usb_pd_policy.c
index f9cfc8c834..6d78680bf5 100644
--- a/baseboard/grunt/usb_pd_policy.c
+++ b/baseboard/grunt/usb_pd_policy.c
@@ -96,7 +96,7 @@ mux_state_t svdm_dp_mux_mode(int port)
 
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	int mf_pref = PD_VDO_DPSTS_MF_PREF(dp_status[port]);
 	int pin_mode = pd_dfp_dp_get_pin_mode(port, dp_status[port]);
 	mux_state_t mux_mode = svdm_dp_mux_mode(port);
diff --git a/baseboard/herobrine/usb_pd_policy.c b/baseboard/herobrine/usb_pd_policy.c
index 87d47c32e2..c17ca0c565 100644
--- a/baseboard/herobrine/usb_pd_policy.c
+++ b/baseboard/herobrine/usb_pd_policy.c
@@ -91,7 +91,7 @@ int pd_snk_is_vbus_provided(int port)
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	uint8_t pin_mode = get_dp_pin_mode(port);
 
 	if (!pin_mode)
diff --git a/baseboard/honeybuns/usb_pd_policy.c b/baseboard/honeybuns/usb_pd_policy.c
index 473003256b..ef2350a03d 100644
--- a/baseboard/honeybuns/usb_pd_policy.c
+++ b/baseboard/honeybuns/usb_pd_policy.c
@@ -458,7 +458,7 @@ static int svdm_response_identity(int port, uint32_t *payload)
 	payload[VDO_INDEX_CSTAT] = VDO_CSTAT(0);
 	payload[VDO_INDEX_PRODUCT] = vdo_product;
 
-	if (pd_get_rev(port, TCPC_TX_SOP) == PD_REV30) {
+	if (pd_get_rev(port, TCPCI_MSG_SOP) == PD_REV30) {
 		/* PD Revision 3.0 */
 		payload[VDO_INDEX_IDH] = vdo_idh_rev30;
 		payload[VDO_INDEX_PTYPE_UFP1_VDO] = vdo_ufp1;
diff --git a/baseboard/kukui/usb_pd_policy.c b/baseboard/kukui/usb_pd_policy.c
index 311b0f2663..92c09525c9 100644
--- a/baseboard/kukui/usb_pd_policy.c
+++ b/baseboard/kukui/usb_pd_policy.c
@@ -183,7 +183,7 @@ __override int svdm_enter_dp_mode(int port, uint32_t mode_caps)
 
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	int status = dp_status[port];
 	int mf_pref = PD_VDO_DPSTS_MF_PREF(dp_status[port]);
 	int pin_mode;
diff --git a/baseboard/trogdor/usb_pd_policy.c b/baseboard/trogdor/usb_pd_policy.c
index fa11b88a38..79726cc5e6 100644
--- a/baseboard/trogdor/usb_pd_policy.c
+++ b/baseboard/trogdor/usb_pd_policy.c
@@ -91,7 +91,7 @@ int pd_snk_is_vbus_provided(int port)
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	uint8_t pin_mode = get_dp_pin_mode(port);
 
 	if (!pin_mode)
diff --git a/baseboard/volteer/usb_pd_policy.c b/baseboard/volteer/usb_pd_policy.c
index f246155867..80615a8e09 100644
--- a/baseboard/volteer/usb_pd_policy.c
+++ b/baseboard/volteer/usb_pd_policy.c
@@ -127,7 +127,7 @@ static int svdm_tbt_compat_response_identity(int port, uint32_t *payload)
 	payload[VDO_I(CSTAT)] = VDO_CSTAT(0);
 	payload[VDO_I(PRODUCT)] = vdo_product;
 
-	if (pd_get_rev(port, TCPC_TX_SOP) == PD_REV30) {
+	if (pd_get_rev(port, TCPCI_MSG_SOP) == PD_REV30) {
 		/* PD Revision 3.0 */
 		payload[VDO_I(IDH)] = vdo_idh_rev30;
 		payload[VDO_I(PTYPE_UFP1_VDO)] = vdo_ufp1;
diff --git a/board/coffeecake/usb_pd_policy.c b/board/coffeecake/usb_pd_policy.c
index 6d9210895a..dc19207a0e 100644
--- a/board/coffeecake/usb_pd_policy.c
+++ b/board/coffeecake/usb_pd_policy.c
@@ -267,9 +267,9 @@ static int svdm_enter_mode(int port, uint32_t *payload)
 	return rv;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
-	if (type != TCPC_TX_SOP)
+	if (type != TCPCI_MSG_SOP)
 		return 0;
 
 	if (svid == USB_SID_DISPLAYPORT)
diff --git a/board/dingdong/usb_pd_policy.c b/board/dingdong/usb_pd_policy.c
index d7af654689..50700f8a62 100644
--- a/board/dingdong/usb_pd_policy.c
+++ b/board/dingdong/usb_pd_policy.c
@@ -220,9 +220,9 @@ static int svdm_enter_mode(int port, uint32_t *payload)
 	return rv;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
-	if (type != TCPC_TX_SOP)
+	if (type != TCPCI_MSG_SOP)
 		return 0;
 
 	if (svid == USB_SID_DISPLAYPORT)
diff --git a/board/hoho/usb_pd_policy.c b/board/hoho/usb_pd_policy.c
index 994989bdd7..2ee83d32aa 100644
--- a/board/hoho/usb_pd_policy.c
+++ b/board/hoho/usb_pd_policy.c
@@ -195,9 +195,9 @@ static int svdm_enter_mode(int port, uint32_t *payload)
 	return rv;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
-	if (type != TCPC_TX_SOP)
+	if (type != TCPCI_MSG_SOP)
 		return 0;
 
 	if (svid == USB_SID_DISPLAYPORT)
diff --git a/board/pdeval-stm32f072/usb_pd_policy.c b/board/pdeval-stm32f072/usb_pd_policy.c
index 45a0aa44ff..2f7941321b 100644
--- a/board/pdeval-stm32f072/usb_pd_policy.c
+++ b/board/pdeval-stm32f072/usb_pd_policy.c
@@ -202,7 +202,7 @@ __override void svdm_safe_dp_mode(int port)
 
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	int pin_mode = pd_dfp_dp_get_pin_mode(port, dp_status[port]);
 	bool unused;
 #if defined(CONFIG_USB_PD_TCPM_MUX) && defined(CONFIG_USB_PD_TCPM_ANX7447)
diff --git a/board/plankton/usb_pd_policy.c b/board/plankton/usb_pd_policy.c
index 769c4b298c..8cb24372a0 100644
--- a/board/plankton/usb_pd_policy.c
+++ b/board/plankton/usb_pd_policy.c
@@ -237,7 +237,7 @@ int svdm_enter_mode(int port, uint32_t *payload)
 	return 1;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
 	return alt_mode;
 }
diff --git a/board/servo_v4/board.c b/board/servo_v4/board.c
index f4723b91f7..8540de710f 100644
--- a/board/servo_v4/board.c
+++ b/board/servo_v4/board.c
@@ -77,7 +77,7 @@ static volatile int hpd_prev_level;
 
 void hpd_irq_deferred(void)
 {
-	int dp_mode = pd_alt_mode(1, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int dp_mode = pd_alt_mode(1, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
 	if (dp_mode) {
 		pd_send_hpd(DUT, hpd_irq);
@@ -89,7 +89,7 @@ DECLARE_DEFERRED(hpd_irq_deferred);
 void hpd_lvl_deferred(void)
 {
 	int level = gpio_get_level(GPIO_DP_HPD);
-	int dp_mode = pd_alt_mode(1, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int dp_mode = pd_alt_mode(1, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
 	if (level != hpd_prev_level) {
 		/* It's a glitch while in deferred or canceled action */
diff --git a/board/servo_v4/usb_pd_policy.c b/board/servo_v4/usb_pd_policy.c
index 82c0cf7f27..00eaa1e628 100644
--- a/board/servo_v4/usb_pd_policy.c
+++ b/board/servo_v4/usb_pd_policy.c
@@ -965,9 +965,9 @@ static int svdm_enter_mode(int port, uint32_t *payload)
 	return 1;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
-	if (type == TCPC_TX_SOP && svid == USB_SID_DISPLAYPORT)
+	if (type == TCPCI_MSG_SOP && svid == USB_SID_DISPLAYPORT)
 		return alt_mode;
 
 	return 0;
diff --git a/board/servo_v4p1/board.c b/board/servo_v4p1/board.c
index 82bc97f091..d8616ce340 100644
--- a/board/servo_v4p1/board.c
+++ b/board/servo_v4p1/board.c
@@ -102,7 +102,7 @@ static volatile int hpd_prev_level;
 
 void hpd_irq_deferred(void)
 {
-	int dp_mode = pd_alt_mode(1, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int dp_mode = pd_alt_mode(1, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
 	if (dp_mode) {
 		pd_send_hpd(DUT, hpd_irq);
@@ -114,7 +114,7 @@ DECLARE_DEFERRED(hpd_irq_deferred);
 void hpd_lvl_deferred(void)
 {
 	int level = gpio_get_level(GPIO_DP_HPD);
-	int dp_mode = pd_alt_mode(1, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int dp_mode = pd_alt_mode(1, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
 	if (level != hpd_prev_level) {
 		/* It's a glitch while in deferred or canceled action */
diff --git a/board/servo_v4p1/usb_pd_policy.c b/board/servo_v4p1/usb_pd_policy.c
index 645d326074..c4d7c239a1 100644
--- a/board/servo_v4p1/usb_pd_policy.c
+++ b/board/servo_v4p1/usb_pd_policy.c
@@ -1044,9 +1044,9 @@ static int svdm_enter_mode(int port, uint32_t *payload)
 	return 1;
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
-	if (type != TCPC_TX_SOP)
+	if (type != TCPCI_MSG_SOP)
 		return 0;
 
 	if (svid == USB_SID_DISPLAYPORT)
diff --git a/chip/stm32/ucpd-stm32gx.c b/chip/stm32/ucpd-stm32gx.c
index 84726d55be..ef6ec92a89 100644
--- a/chip/stm32/ucpd-stm32gx.c
+++ b/chip/stm32/ucpd-stm32gx.c
@@ -105,7 +105,7 @@ union buffer {
 };
 
 struct ucpd_tx_desc {
-	enum tcpm_sop_type type;
+	enum tcpci_msg_type type;
 	int msg_len;
 	int msg_index;
 	union buffer data;
@@ -719,13 +719,13 @@ int stm32gx_ucpd_get_chip_info(int port, int live,
 
 static int stm32gx_ucpd_start_transmit(int port, enum ucpd_tx_msg msg_type)
 {
-	enum tcpm_sop_type type;
+	enum tcpci_msg_type type;
 
 	/* Select the correct tx desciptor */
 	ucpd_tx_active_buffer = &ucpd_tx_buffers[msg_type];
 	type = ucpd_tx_active_buffer->type;
 
-	if (type == TCPC_TX_HARD_RESET) {
+	if (type == TCPCI_MSG_TX_HARD_RESET) {
 				/*
 		 * From RM0440 45.4.4:
 		 * In order to facilitate generation of a Hard Reset, a special
@@ -750,7 +750,7 @@ static int stm32gx_ucpd_start_transmit(int port, enum ucpd_tx_msg msg_type)
 			STM32_UCPD_IMR_HRSTSENTIE;
 		/* Initiate Hard Reset */
 		STM32_UCPD_CR(port) |= STM32_UCPD_CR_TXHRST;
-	} else if (type != TCPC_TX_INVALID) {
+	} else if (type != TCPCI_MSG_INVALID) {
 		int msg_len = 0;
 		int mode;
 
@@ -774,9 +774,9 @@ static int stm32gx_ucpd_start_transmit(int port, enum ucpd_tx_msg msg_type)
 		 * the header is number of 32 bit objects. Also, the length
 		 * field must account for the 2 header bytes.
 		 */
-		if (type == TCPC_TX_BIST_MODE_2) {
+		if (type == TCPCI_MSG_TX_BIST_MODE_2) {
 			mode = STM32_UCPD_CR_TXMODE_BIST;
-		} else if (type == TCPC_TX_CABLE_RESET) {
+		} else if (type == TCPCI_MSG_CABLE_RESET) {
 			mode = STM32_UCPD_CR_TXMODE_CBL_RST;
 		} else {
 			mode = STM32_UCPD_CR_TXMODE_DEF;
@@ -790,7 +790,7 @@ static int stm32gx_ucpd_start_transmit(int port, enum ucpd_tx_msg msg_type)
 		STM32_UCPD_CR(port) |= STM32_UCPD_CR_TXMODE_VAL(mode);
 
 		/* Index into ordset enum for start of packet */
-		if (type <= TCPC_TX_CABLE_RESET )
+		if (type <= TCPCI_MSG_CABLE_RESET)
 			STM32_UCPD_TX_ORDSETR(port) = ucpd_txorderset[type];
 		else
 			STM32_UCPD_TX_ORDSETR(port) =
@@ -1130,7 +1130,7 @@ static void ucpd_send_good_crc(int port, uint16_t rx_header)
 	int msg_id;
 	int rev_id;
 	uint16_t tx_header;
-	enum tcpm_sop_type tx_type;
+	enum tcpci_msg_type tx_type;
 	enum pd_power_role pr = 0;
 	enum pd_data_role dr = 0;
 
@@ -1146,7 +1146,7 @@ static void ucpd_send_good_crc(int port, uint16_t rx_header)
 
 	/*
 	 * Get the rx ordered set code just detected. SOP -> SOP''_Debug are in
-	 * the same order as enum tcpm_sop_type and so can be used
+	 * the same order as enum tcpci_msg_type and so can be used
 	 * directly.
 	 */
 	tx_type = STM32_UCPD_RX_ORDSETR(port) & STM32_UCPD_RXORDSETR_MASK;
@@ -1164,7 +1164,7 @@ static void ucpd_send_good_crc(int port, uint16_t rx_header)
 	/* construct header message */
 	msg_id = PD_HEADER_ID(rx_header);
 	rev_id = PD_HEADER_REV(rx_header);
-	if (tx_type == TCPC_TX_SOP) {
+	if (tx_type == TCPCI_MSG_SOP) {
 		pr = msg_header.pr;
 		dr = msg_header.dr;
 	}
@@ -1180,7 +1180,7 @@ static void ucpd_send_good_crc(int port, uint16_t rx_header)
 }
 
 int stm32gx_ucpd_transmit(int port,
-			  enum tcpm_sop_type type,
+			  enum tcpci_msg_type type,
 			  uint16_t header,
 			  const uint32_t *data)
 {
@@ -1203,7 +1203,7 @@ int stm32gx_ucpd_transmit(int port,
 	 * resets as they are able to interrupt ongoing transmit, and should
 	 * have priority over any pending message.
 	 */
-	if (type == TCPC_TX_HARD_RESET)
+	if (type == TCPCI_MSG_TX_HARD_RESET)
 		task_set_event(TASK_ID_UCPD, UCPD_EVT_HR_REQ);
 	else
 		task_set_event(TASK_ID_UCPD, UCPD_EVT_TCPM_MSG_REQ);
@@ -1319,7 +1319,7 @@ void stm32gx_ucpd1_irq(void)
 		/* Check for errors */
 		if (!(sr & STM32_UCPD_SR_RXERR)) {
 			uint16_t *rx_header = (uint16_t *)ucpd_rx_buffer;
-			enum tcpm_sop_type type;
+			enum tcpci_msg_type type;
 			int good_crc = 0;
 
 			type = STM32_UCPD_RX_ORDSETR(port) &
@@ -1339,7 +1339,7 @@ void stm32gx_ucpd1_irq(void)
 			 * without disabling the ucpd peripheral.
 			 */
 			if (!good_crc && (ucpd_rx_sop_prime_enabled ||
-					  type == TCPC_TX_SOP)) {
+					  type == TCPCI_MSG_SOP)) {
 
 				/*
 				 * If BIST test mode is active, then still need
@@ -1559,7 +1559,7 @@ static int command_ucpd(int argc, char **argv)
 		 * pd_dpm_request(port, DPM_REQUEST_BIST_TX);
 		 */
 	} else if (!strcasecmp(argv[1], "hard")) {
-		stm32gx_ucpd_transmit(port, TCPC_TX_HARD_RESET, 0,
+		stm32gx_ucpd_transmit(port, TCPCI_MSG_TX_HARD_RESET, 0,
 				      &tx_data);
 	} else if (!strcasecmp(argv[1], "pol")) {
 		if (argc < 3)
diff --git a/chip/stm32/ucpd-stm32gx.h b/chip/stm32/ucpd-stm32gx.h
index f7021136ad..d3af41e5bc 100644
--- a/chip/stm32/ucpd-stm32gx.h
+++ b/chip/stm32/ucpd-stm32gx.h
@@ -173,7 +173,7 @@ int stm32gx_ucpd_set_msg_header(int port, int power_role, int data_role);
  * @return EC_SUCCESS
  */
 int stm32gx_ucpd_transmit(int port,
-			enum tcpm_sop_type type,
+			enum tcpci_msg_type type,
 			uint16_t header,
 			  const uint32_t *data);
 
diff --git a/common/mock/tcpc_mock.c b/common/mock/tcpc_mock.c
index b12267401f..7097837268 100644
--- a/common/mock/tcpc_mock.c
+++ b/common/mock/tcpc_mock.c
@@ -141,7 +141,7 @@ static int mock_get_message_raw(int port, uint32_t *payload, int *head)
 	return EC_SUCCESS;
 }
 
-static int mock_transmit(int port, enum tcpm_sop_type type,
+static int mock_transmit(int port, enum tcpci_msg_type type,
 			 uint16_t header, const uint32_t *data)
 {
 	return EC_SUCCESS;
diff --git a/common/mock/tcpci_i2c_mock.c b/common/mock/tcpci_i2c_mock.c
index 2df24586af..8ec7556fca 100644
--- a/common/mock/tcpci_i2c_mock.c
+++ b/common/mock/tcpci_i2c_mock.c
@@ -181,7 +181,7 @@ static bool debug_accessory_indicator_supported(void)
 	return true;
 }
 
-static int verify_transmit(enum tcpm_sop_type want_tx_type,
+static int verify_transmit(enum tcpci_msg_type want_tx_type,
 			   int want_tx_retry,
 			   enum pd_ctrl_msg_type want_ctrl_msg,
 			   enum pd_data_msg_type want_data_msg,
@@ -230,7 +230,7 @@ static int verify_transmit(enum tcpm_sop_type want_tx_type,
 	return EC_ERROR_UNKNOWN;
 }
 
-int verify_tcpci_transmit(enum tcpm_sop_type tx_type,
+int verify_tcpci_transmit(enum tcpci_msg_type tx_type,
 			  enum pd_ctrl_msg_type ctrl_msg,
 			  enum pd_data_msg_type data_msg)
 {
@@ -239,7 +239,7 @@ int verify_tcpci_transmit(enum tcpm_sop_type tx_type,
 			       VERIFY_TIMEOUT);
 }
 
-int verify_tcpci_tx_timeout(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_timeout(enum tcpci_msg_type tx_type,
 			    enum pd_ctrl_msg_type ctrl_msg,
 			    enum pd_data_msg_type data_msg,
 			    int timeout)
@@ -249,7 +249,7 @@ int verify_tcpci_tx_timeout(enum tcpm_sop_type tx_type,
 			       timeout);
 }
 
-int verify_tcpci_tx_retry_count(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_retry_count(enum tcpci_msg_type tx_type,
 				enum pd_ctrl_msg_type ctrl_msg,
 				enum pd_data_msg_type data_msg,
 				int retry_count)
@@ -259,7 +259,7 @@ int verify_tcpci_tx_retry_count(enum tcpm_sop_type tx_type,
 			       VERIFY_TIMEOUT);
 }
 
-int verify_tcpci_tx_with_data(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_with_data(enum tcpci_msg_type tx_type,
 			      enum pd_data_msg_type data_msg,
 			      uint8_t *data,
 			      int data_bytes,
@@ -362,7 +362,7 @@ int verify_tcpci_possible_tx(struct possible_tx possible[],
 	return EC_ERROR_TIMEOUT;
 }
 
-void mock_tcpci_receive(enum tcpm_sop_type sop, uint16_t header,
+void mock_tcpci_receive(enum tcpci_msg_type sop, uint16_t header,
 			uint32_t *payload)
 {
 	int i;
diff --git a/common/mock/usb_pd_dpm_mock.c b/common/mock/usb_pd_dpm_mock.c
index 9bec8358dd..8b6fbaa30e 100644
--- a/common/mock/usb_pd_dpm_mock.c
+++ b/common/mock/usb_pd_dpm_mock.c
@@ -31,12 +31,12 @@ void dpm_init(int port)
 	dpm[port].mode_exit_request = false;
 }
 
-void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dpm_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
 }
 
-void dpm_vdm_naked(int port, enum tcpm_sop_type type, uint16_t svid,
+void dpm_vdm_naked(int port, enum tcpci_msg_type type, uint16_t svid,
 		uint8_t vdm_cmd)
 {
 }
diff --git a/common/mock/usb_pe_sm_mock.c b/common/mock/usb_pe_sm_mock.c
index a237102a74..8d1a25324b 100644
--- a/common/mock/usb_pe_sm_mock.c
+++ b/common/mock/usb_pe_sm_mock.c
@@ -46,7 +46,7 @@ void mock_pe_port_reset(void)
 	}
 }
 
-void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type)
+void pe_report_error(int port, enum pe_error e, enum tcpci_msg_type type)
 {
 	mock_pe_port[port].mock_pe_error = e;
 	mock_pe_port[port].sop = type;
@@ -110,7 +110,7 @@ void pd_set_src_caps(int port, int cnt, uint32_t *src_caps)
 void pd_request_power_swap(int port)
 {}
 
-int pd_get_rev(int port, enum tcpm_sop_type type)
+int pd_get_rev(int port, enum tcpci_msg_type type)
 {
 	return IS_ENABLED(CONFIG_USB_PD_REV30) ? PD_REV30 : PD_REV20;
 }
diff --git a/common/mock/usb_prl_mock.c b/common/mock/usb_prl_mock.c
index ae7874d4ac..d5f4781829 100644
--- a/common/mock/usb_prl_mock.c
+++ b/common/mock/usb_prl_mock.c
@@ -26,11 +26,11 @@ struct extended_msg tx_emsg[CONFIG_USB_PD_PORT_MAX_COUNT];
 struct mock_prl_port_t {
 	enum pd_ctrl_msg_type last_ctrl_msg;
 	enum pd_data_msg_type last_data_msg;
-	enum tcpm_sop_type last_tx_type;
+	enum tcpci_msg_type last_tx_type;
 	bool message_sent;
 	bool message_received;
 	enum pe_error error;
-	enum tcpm_sop_type error_tx_type;
+	enum tcpci_msg_type error_tx_type;
 };
 
 struct mock_prl_port_t mock_prl_port[CONFIG_USB_PD_PORT_MAX_COUNT];
@@ -46,8 +46,8 @@ void mock_prl_reset(void)
 	memset(mock_prl_port, 0, sizeof(mock_prl_port));
 
 	for (port = 0 ; port < CONFIG_USB_PD_PORT_MAX_COUNT ; ++port) {
-		mock_prl_port[port].last_tx_type = TCPC_TX_INVALID;
-		mock_prl_port[port].error_tx_type = TCPC_TX_INVALID;
+		mock_prl_port[port].last_tx_type = TCPCI_MSG_INVALID;
+		mock_prl_port[port].error_tx_type = TCPCI_MSG_INVALID;
 	}
 }
 
@@ -58,10 +58,10 @@ void prl_execute_hard_reset(int port)
 {
 	mock_prl_port[port].last_ctrl_msg = 0;
 	mock_prl_port[port].last_data_msg = 0;
-	mock_prl_port[port].last_tx_type = TCPC_TX_HARD_RESET;
+	mock_prl_port[port].last_tx_type = TCPCI_MSG_TX_HARD_RESET;
 }
 
-enum pd_rev_type prl_get_rev(int port, enum tcpm_sop_type partner)
+enum pd_rev_type prl_get_rev(int port, enum tcpci_msg_type partner)
 {
 	return PD_REV30;
 }
@@ -82,7 +82,7 @@ __overridable bool prl_is_busy(int port)
 void prl_reset_soft(int port)
 {}
 
-void prl_send_ctrl_msg(int port, enum tcpm_sop_type type,
+void prl_send_ctrl_msg(int port, enum tcpci_msg_type type,
 	enum pd_ctrl_msg_type msg)
 {
 	mock_prl_port[port].last_ctrl_msg = msg;
@@ -90,7 +90,7 @@ void prl_send_ctrl_msg(int port, enum tcpm_sop_type type,
 	mock_prl_port[port].last_tx_type = type;
 }
 
-void prl_send_data_msg(int port, enum tcpm_sop_type type,
+void prl_send_data_msg(int port, enum tcpci_msg_type type,
 	enum pd_data_msg_type msg)
 {
 	mock_prl_port[port].last_data_msg = msg;
@@ -98,17 +98,17 @@ void prl_send_data_msg(int port, enum tcpm_sop_type type,
 	mock_prl_port[port].last_tx_type = type;
 }
 
-void prl_send_ext_data_msg(int port, enum tcpm_sop_type type,
+void prl_send_ext_data_msg(int port, enum tcpci_msg_type type,
 	enum pd_ext_msg_type msg)
 {}
 
-void prl_set_rev(int port, enum tcpm_sop_type partner,
+void prl_set_rev(int port, enum tcpci_msg_type partner,
 	enum pd_rev_type rev)
 {}
 
 
 int mock_prl_wait_for_tx_msg(int port,
-			     enum tcpm_sop_type tx_type,
+			     enum tcpci_msg_type tx_type,
 			     enum pd_ctrl_msg_type ctrl_msg,
 			     enum pd_data_msg_type data_msg,
 			     int timeout)
@@ -116,7 +116,7 @@ int mock_prl_wait_for_tx_msg(int port,
 	uint64_t end_time = get_time().val + timeout;
 
 	while (get_time().val < end_time) {
-		if (mock_prl_port[port].last_tx_type != TCPC_TX_INVALID) {
+		if (mock_prl_port[port].last_tx_type != TCPCI_MSG_INVALID) {
 			TEST_EQ(mock_prl_port[port].last_tx_type,
 				tx_type, "%d");
 			TEST_EQ(mock_prl_port[port].last_ctrl_msg,
@@ -153,7 +153,7 @@ void mock_prl_clear_last_sent_msg(int port)
 {
 	mock_prl_port[port].last_data_msg = 0;
 	mock_prl_port[port].last_ctrl_msg = 0;
-	mock_prl_port[port].last_tx_type = TCPC_TX_INVALID;
+	mock_prl_port[port].last_tx_type = TCPCI_MSG_INVALID;
 }
 
 timestamp_t prl_get_tcpc_tx_success_ts(int port)
@@ -171,7 +171,7 @@ void mock_prl_message_received(int port)
 }
 
 void mock_prl_report_error(int port, enum pe_error e,
-			   enum tcpm_sop_type tx_type)
+			   enum tcpci_msg_type tx_type)
 {
 	mock_prl_port[port].error = e;
 	mock_prl_port[port].error_tx_type = tx_type;
@@ -189,12 +189,12 @@ void prl_run(int port, int evt, int en)
 		pe_message_received(port);
 		mock_prl_port[port].message_received = 0;
 	}
-	if (mock_prl_port[port].error_tx_type != TCPC_TX_INVALID) {
+	if (mock_prl_port[port].error_tx_type != TCPCI_MSG_INVALID) {
 		ccprints("pe_error %d", mock_prl_port[port].error);
 		pe_report_error(port,
 				mock_prl_port[port].error,
 				mock_prl_port[port].error_tx_type);
 		mock_prl_port[port].error = 0;
-		mock_prl_port[port].error_tx_type = TCPC_TX_INVALID;
+		mock_prl_port[port].error_tx_type = TCPCI_MSG_INVALID;
 	}
 }
diff --git a/common/mock/usb_tc_sm_mock.c b/common/mock/usb_tc_sm_mock.c
index f2c2ecf5c8..d55def12e2 100644
--- a/common/mock/usb_tc_sm_mock.c
+++ b/common/mock/usb_tc_sm_mock.c
@@ -31,7 +31,7 @@ void mock_tc_port_reset(void)
 		mock_tc_port[port].pd_enable = 0;
 		mock_tc_port[port].msg_tx_id = 0;
 		mock_tc_port[port].msg_rx_id = 0;
-		mock_tc_port[port].sop = TCPC_TX_INVALID;
+		mock_tc_port[port].sop = TCPCI_MSG_INVALID;
 		mock_tc_port[port].lcl_rp = TYPEC_RP_RESERVED;
 		mock_tc_port[port].attached_snk = 0;
 		mock_tc_port[port].attached_src = 0;
diff --git a/common/usb_common.c b/common/usb_common.c
index 0aab746f44..2515caf287 100644
--- a/common/usb_common.c
+++ b/common/usb_common.c
@@ -361,7 +361,7 @@ __overridable bool board_is_dts_port(int port)
 	return true;
 }
 
-int pd_get_retry_count(int port, enum tcpm_sop_type type)
+int pd_get_retry_count(int port, enum tcpci_msg_type type)
 {
 	/* PD 3.0 6.7.7: nRetryCount = 2; PD 2.0 6.6.9: nRetryCount = 3 */
 	return pd_get_rev(port, type) == PD_REV30 ? 2 : 3;
@@ -809,7 +809,7 @@ static void pd_usb_billboard_deferred(void)
 		 * 1. Will we have multiple type-C port UFPs
 		 * 2. Will there be other modes applicable to DFPs besides DP
 		 */
-		if (!pd_alt_mode(0, TCPC_TX_SOP, USB_SID_DISPLAYPORT))
+		if (!pd_alt_mode(0, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT))
 			usb_connect();
 	}
 }
diff --git a/common/usb_pd_alt_mode_dfp.c b/common/usb_pd_alt_mode_dfp.c
index 3c5d133bc4..366647a7b9 100644
--- a/common/usb_pd_alt_mode_dfp.c
+++ b/common/usb_pd_alt_mode_dfp.c
@@ -58,7 +58,7 @@ __overridable const struct svdm_response svdm_rsp = {
 	.modes = NULL,
 };
 
-static int pd_get_mode_idx(int port, enum tcpm_sop_type type,
+static int pd_get_mode_idx(int port, enum tcpci_msg_type type,
 		uint16_t svid)
 {
 	int amode_idx;
@@ -73,7 +73,7 @@ static int pd_get_mode_idx(int port, enum tcpm_sop_type type,
 	return -1;
 }
 
-static int pd_allocate_mode(int port, enum tcpm_sop_type type,
+static int pd_allocate_mode(int port, enum tcpci_msg_type type,
 		uint16_t svid)
 {
 	int i, j;
@@ -183,7 +183,7 @@ void pd_prepare_sysjump(void)
 int pd_dfp_dp_get_pin_mode(int port, uint32_t status)
 {
 	struct svdm_amode_data *modep =
-		pd_get_amode_data(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+		pd_get_amode_data(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	uint32_t mode_caps;
 	uint32_t pin_caps;
 	int mf_pref;
@@ -226,7 +226,7 @@ int pd_dfp_dp_get_pin_mode(int port, uint32_t status)
 }
 
 struct svdm_amode_data *pd_get_amode_data(int port,
-		enum tcpm_sop_type type, uint16_t svid)
+		enum tcpci_msg_type type, uint16_t svid)
 {
 	int idx = pd_get_mode_idx(port, type, svid);
 	struct partner_active_modes *active =
@@ -240,7 +240,7 @@ struct svdm_amode_data *pd_get_amode_data(int port,
  * Enter default mode ( payload[0] == 0 ) or attempt to enter mode via svid &
  * opos
  */
-uint32_t pd_dfp_enter_mode(int port, enum tcpm_sop_type type,
+uint32_t pd_dfp_enter_mode(int port, enum tcpci_msg_type type,
 		uint16_t svid, int opos)
 {
 	int mode_idx = pd_allocate_mode(port, type, svid);
@@ -280,7 +280,7 @@ uint32_t pd_dfp_enter_mode(int port, enum tcpm_sop_type type,
 }
 
 /* TODO(b/170372521) : Incorporate exit mode specific changes to DPM SM */
-int pd_dfp_exit_mode(int port, enum tcpm_sop_type type, uint16_t svid,
+int pd_dfp_exit_mode(int port, enum tcpci_msg_type type, uint16_t svid,
 		int opos)
 {
 	struct svdm_amode_data *modep;
@@ -344,7 +344,7 @@ void dfp_consume_attention(int port, uint32_t *payload)
 	uint16_t svid = PD_VDO_VID(payload[0]);
 	int opos = PD_VDO_OPOS(payload[0]);
 	struct svdm_amode_data *modep =
-		pd_get_amode_data(port, TCPC_TX_SOP, svid);
+		pd_get_amode_data(port, TCPCI_MSG_SOP, svid);
 
 	if (!modep || !validate_mode_request(modep, svid, opos))
 		return;
@@ -353,14 +353,14 @@ void dfp_consume_attention(int port, uint32_t *payload)
 		modep->fx->attention(port, payload);
 }
 
-void dfp_consume_identity(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_identity(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload)
 {
 	int ptype;
 	struct pd_discovery *disc;
 	size_t identity_size;
 
-	if (type == TCPC_TX_SOP_PRIME &&
+	if (type == TCPCI_MSG_SOP_PRIME &&
 	    !IS_ENABLED(CONFIG_USB_PD_DECODE_SOP)) {
 		CPRINTF("ERR:Unexpected cable response\n");
 		return;
@@ -396,7 +396,7 @@ void dfp_consume_identity(int port, enum tcpm_sop_type type, int cnt,
 	pd_set_identity_discovery(port, type, PD_DISC_COMPLETE);
 }
 
-void dfp_consume_svids(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_svids(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload)
 {
 	int i;
@@ -441,7 +441,7 @@ void dfp_consume_svids(int port, enum tcpm_sop_type type, int cnt,
 	pd_set_svids_discovery(port, type, PD_DISC_COMPLETE);
 }
 
-void dfp_consume_modes(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_modes(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload)
 {
 	int svid_idx;
@@ -488,14 +488,14 @@ void dfp_consume_modes(int port, enum tcpm_sop_type type, int cnt,
 			PD_DISC_COMPLETE);
 }
 
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid)
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid)
 {
 	struct svdm_amode_data *modep = pd_get_amode_data(port, type, svid);
 
 	return (modep) ? modep->opos : -1;
 }
 
-void pd_set_identity_discovery(int port, enum tcpm_sop_type type,
+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);
@@ -504,7 +504,7 @@ void pd_set_identity_discovery(int port, enum tcpm_sop_type type,
 }
 
 enum pd_discovery_state pd_get_identity_discovery(int port,
-						  enum tcpm_sop_type type)
+						  enum tcpci_msg_type type)
 {
 	struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
@@ -512,7 +512,7 @@ enum pd_discovery_state pd_get_identity_discovery(int port,
 }
 
 const union disc_ident_ack *pd_get_identity_response(int port,
-					       enum tcpm_sop_type type)
+					       enum tcpci_msg_type type)
 {
 	if (type >= DISCOVERY_TYPE_COUNT)
 		return NULL;
@@ -523,7 +523,7 @@ const union disc_ident_ack *pd_get_identity_response(int port,
 uint16_t pd_get_identity_vid(int port)
 {
 	const union disc_ident_ack *resp = pd_get_identity_response(port,
-								TCPC_TX_SOP);
+								TCPCI_MSG_SOP);
 
 	return resp->idh.usb_vendor_id;
 }
@@ -531,7 +531,7 @@ uint16_t pd_get_identity_vid(int port)
 uint16_t pd_get_identity_pid(int port)
 {
 	const union disc_ident_ack *resp = pd_get_identity_response(port,
-								TCPC_TX_SOP);
+								TCPCI_MSG_SOP);
 
 	return resp->product.product_id;
 }
@@ -539,12 +539,12 @@ uint16_t pd_get_identity_pid(int port)
 uint8_t pd_get_product_type(int port)
 {
 	const union disc_ident_ack *resp = pd_get_identity_response(port,
-								TCPC_TX_SOP);
+								TCPCI_MSG_SOP);
 
 	return resp->idh.product_type;
 }
 
-void pd_set_svids_discovery(int port, enum tcpm_sop_type type,
+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);
@@ -553,28 +553,28 @@ void pd_set_svids_discovery(int port, enum tcpm_sop_type type,
 }
 
 enum pd_discovery_state pd_get_svids_discovery(int port,
-		enum tcpm_sop_type type)
+		enum tcpci_msg_type type)
 {
 	struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svids_discovery;
 }
 
-int pd_get_svid_count(int port, enum tcpm_sop_type type)
+int pd_get_svid_count(int port, enum tcpci_msg_type type)
 {
 	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 tcpm_sop_type type)
+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);
 
 	return disc->svids[svid_idx].svid;
 }
 
-void pd_set_modes_discovery(int port, enum tcpm_sop_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);
@@ -592,7 +592,7 @@ void pd_set_modes_discovery(int port, enum tcpm_sop_type type,
 }
 
 enum pd_discovery_state pd_get_modes_discovery(int port,
-		enum tcpm_sop_type type)
+		enum tcpci_msg_type type)
 {
 	const struct svid_mode_data *mode_data = pd_get_next_mode(port, type);
 
@@ -606,7 +606,7 @@ enum pd_discovery_state pd_get_modes_discovery(int port,
 	return mode_data->discovery;
 }
 
-int pd_get_mode_vdo_for_svid(int port, enum tcpm_sop_type type,
+int pd_get_mode_vdo_for_svid(int port, enum tcpci_msg_type type,
 		uint16_t svid, uint32_t *vdo_out)
 {
 	int idx;
@@ -628,7 +628,7 @@ int pd_get_mode_vdo_for_svid(int port, enum tcpm_sop_type type,
 }
 
 struct svid_mode_data *pd_get_next_mode(int port,
-		enum tcpm_sop_type type)
+		enum tcpci_msg_type type)
 {
 	struct pd_discovery *disc = pd_get_am_discovery(port, type);
 	struct svid_mode_data *failed_mode_data = NULL;
@@ -663,14 +663,14 @@ struct svid_mode_data *pd_get_next_mode(int port,
 }
 
 uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
-		enum tcpm_sop_type type)
+		enum tcpci_msg_type type)
 {
 	struct pd_discovery *disc = pd_get_am_discovery(port, type);
 
 	return disc->svids[svid_idx].mode_vdo;
 }
 
-bool pd_is_mode_discovered_for_svid(int port, enum tcpm_sop_type type,
+bool pd_is_mode_discovered_for_svid(int port, enum tcpci_msg_type type,
 		uint16_t svid)
 {
 	const struct pd_discovery *disc = pd_get_am_discovery(port, type);
@@ -696,7 +696,7 @@ void notify_sysjump_ready(void)
 		task_set_event(sysjump_task_waiting, TASK_EVENT_SYSJUMP_READY);
 }
 
-static inline bool is_pd_rev3(int port, enum tcpm_sop_type type)
+static inline bool is_pd_rev3(int port, enum tcpci_msg_type type)
 {
 	return pd_get_rev(port, type) == PD_REV30;
 }
@@ -711,7 +711,7 @@ static inline bool is_pd_rev3(int port, enum tcpm_sop_type type)
 bool is_vpd_ct_supported(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.ct_support;
@@ -720,7 +720,7 @@ bool is_vpd_ct_supported(int port)
 uint8_t get_vpd_ct_gnd_impedance(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.gnd_impedance;
@@ -729,7 +729,7 @@ uint8_t get_vpd_ct_gnd_impedance(int port)
 uint8_t get_vpd_ct_vbus_impedance(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.vbus_impedance;
@@ -738,7 +738,7 @@ uint8_t get_vpd_ct_vbus_impedance(int port)
 uint8_t get_vpd_ct_current_support(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.ct_current_support;
@@ -747,7 +747,7 @@ uint8_t get_vpd_ct_current_support(int port)
 uint8_t get_vpd_ct_max_vbus_voltage(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.max_vbus_voltage;
@@ -756,7 +756,7 @@ uint8_t get_vpd_ct_max_vbus_voltage(int port)
 uint8_t get_vpd_ct_vdo_version(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.vdo_version;
@@ -765,7 +765,7 @@ uint8_t get_vpd_ct_vdo_version(int port)
 uint8_t get_vpd_ct_firmware_verion(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.firmware_version;
@@ -774,7 +774,7 @@ uint8_t get_vpd_ct_firmware_verion(int port)
 uint8_t get_vpd_ct_hw_version(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	union vpd_vdo vpd = disc->identity.product_t1.vpd;
 
 	return vpd.hw_version;
@@ -790,7 +790,7 @@ uint8_t get_vpd_ct_hw_version(int port)
 enum idh_ptype get_usb_pd_cable_type(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	return disc->identity.idh.product_type;
 }
@@ -798,10 +798,10 @@ enum idh_ptype get_usb_pd_cable_type(int port)
 bool is_usb2_cable_support(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	return disc->identity.idh.product_type == IDH_PTYPE_PCABLE ||
-	       pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME) < VDM_VER20 ||
+	       pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME) < VDM_VER20 ||
 	       disc->identity.product_t2.a2_rev30.usb_20_support ==
 							USB2_SUPPORTED;
 }
@@ -809,9 +809,9 @@ bool is_usb2_cable_support(int port)
 bool is_cable_speed_gen2_capable(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
-	switch (pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME)) {
+	switch (pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME)) {
 	case PD_REV20:
 		return disc->identity.product_t1.p_rev20.ss ==
 						USB_R20_SS_U31_GEN1_GEN2;
@@ -829,12 +829,12 @@ bool is_cable_speed_gen2_capable(int port)
 bool is_active_cable_element_retimer(int port)
 {
 	struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	/* Ref: USB PD Spec 2.0 Table 6-29 Active Cable VDO
 	 * Revision 2 Active cables do not have Active element support.
 	 */
-	return is_pd_rev3(port, TCPC_TX_SOP_PRIME) &&
+	return is_pd_rev3(port, TCPCI_MSG_SOP_PRIME) &&
 		disc->identity.idh.product_type == IDH_PTYPE_ACABLE &&
 		disc->identity.product_t2.a2_rev30.active_elem ==
 							ACTIVE_RETIMER;
@@ -848,7 +848,7 @@ bool is_active_cable_element_retimer(int port)
  * ############################################################################
  */
 
-uint32_t pd_get_tbt_mode_vdo(int port, enum tcpm_sop_type type)
+uint32_t pd_get_tbt_mode_vdo(int port, enum tcpci_msg_type type)
 {
 	uint32_t tbt_mode_vdo[PDO_MODES];
 
@@ -884,7 +884,7 @@ static bool is_tbt_cable_superspeed(int port)
 	    !IS_ENABLED(CONFIG_USB_PD_DECODE_SOP))
 		return false;
 
-	disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	/* Product type is Active cable, hence don't check for speed */
 	if (disc->identity.idh.product_type == IDH_PTYPE_ACABLE)
@@ -894,7 +894,7 @@ static bool is_tbt_cable_superspeed(int port)
 		return false;
 
 	if (IS_ENABLED(CONFIG_USB_PD_REV30) &&
-	   is_pd_rev3(port, TCPC_TX_SOP_PRIME))
+	   is_pd_rev3(port, TCPCI_MSG_SOP_PRIME))
 		return  disc->identity.product_t1.p_rev30.ss ==
 						USB_R30_SS_U32_U40_GEN1 ||
 			disc->identity.product_t1.p_rev30.ss ==
@@ -932,7 +932,7 @@ enum tbt_compat_cable_speed get_tbt_cable_speed(int port)
 		return TBT_SS_RES_0;
 
 	cable_mode_resp.raw_value =
-		pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+		pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 	max_tbt_speed = board_get_max_tbt_speed(port);
 
 	/*
@@ -949,7 +949,7 @@ enum tbt_compat_cable_speed get_tbt_cable_speed(int port)
 		if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE)
 			return TBT_SS_RES_0;
 
-		disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 		cable_tbt_speed =
 		   usb_rev30_to_tbt_speed(disc->identity.product_t1.p_rev30.ss);
 	} else {
@@ -960,15 +960,15 @@ enum tbt_compat_cable_speed get_tbt_cable_speed(int port)
 		max_tbt_speed : cable_tbt_speed;
 }
 
-int enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
+int enter_tbt_compat_mode(int port, enum tcpci_msg_type sop,
 			uint32_t *payload)
 {
 	union tbt_dev_mode_enter_cmd enter_dev_mode = { .raw_value = 0 };
 	union tbt_mode_resp_device dev_mode_resp;
 	union tbt_mode_resp_cable cable_mode_resp;
-	enum tcpm_sop_type enter_mode_sop =
-					sop == TCPC_TX_SOP_PRIME_PRIME ?
-						TCPC_TX_SOP_PRIME : sop;
+	enum tcpci_msg_type enter_mode_sop =
+					sop == TCPCI_MSG_SOP_PRIME_PRIME ?
+						TCPCI_MSG_SOP_PRIME : sop;
 
 	/* Table F-12 TBT3 Cable Enter Mode Command */
 	/*
@@ -988,13 +988,13 @@ int enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
 	usb_mux_set_safe_mode(port);
 
 	/* For TBT3 Cable Enter Mode Command, number of Objects is 1 */
-	if ((sop == TCPC_TX_SOP_PRIME) ||
-	    (sop == TCPC_TX_SOP_PRIME_PRIME))
+	if ((sop == TCPCI_MSG_SOP_PRIME) ||
+	    (sop == TCPCI_MSG_SOP_PRIME_PRIME))
 		return 1;
 
-	dev_mode_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP);
+	dev_mode_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP);
 	cable_mode_resp.raw_value =
-			pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+			pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 	/* Table F-13 TBT3 Device Enter Mode Command */
 	enter_dev_mode.vendor_spec_b1 = dev_mode_resp.vendor_spec_b1;
@@ -1021,7 +1021,7 @@ int enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
 enum tbt_compat_rounded_support get_tbt_rounded_support(int port)
 {
 	union tbt_mode_resp_cable cable_mode_resp = {
-		.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME) };
+		.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME) };
 
 	/* tbt_rounded_support is zero when uninitialized */
 	return cable_mode_resp.tbt_rounded;
@@ -1065,9 +1065,9 @@ enum usb_rev30_ss get_usb4_cable_speed(int port)
 		USB_R30_SS_U40_GEN3 : USB_R30_SS_U32_U40_GEN2;
 
 	if ((get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) &&
-	     is_pd_rev3(port, TCPC_TX_SOP_PRIME)) {
+	     is_pd_rev3(port, TCPCI_MSG_SOP_PRIME)) {
 		struct pd_discovery *disc =
-			pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+			pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 		union active_cable_vdo1_rev30 a_rev30 =
 			disc->identity.product_t1.a_rev30;
 
@@ -1093,14 +1093,14 @@ uint32_t get_enter_usb_msg_payload(int port)
 	if (!IS_ENABLED(CONFIG_USB_PD_USB4))
 		return 0;
 
-	disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	eudo.mode = USB_PD_40;
 	eudo.usb4_drd_cap = IS_ENABLED(CONFIG_USB_PD_USB4_DRD);
 	eudo.usb3_drd_cap = IS_ENABLED(CONFIG_USB_PD_USB32_DRD);
 	eudo.cable_speed = get_usb4_cable_speed(port);
 
 	if (disc->identity.idh.product_type == IDH_PTYPE_ACABLE) {
-		if (is_pd_rev3(port, TCPC_TX_SOP_PRIME)) {
+		if (is_pd_rev3(port, TCPCI_MSG_SOP_PRIME)) {
 			enum retimer_active_element active_element =
 				disc->identity.product_t2.a2_rev30.active_elem;
 			eudo.cable_type = active_element == ACTIVE_RETIMER ?
@@ -1108,7 +1108,7 @@ uint32_t get_enter_usb_msg_payload(int port)
 				CABLE_TYPE_ACTIVE_REDRIVER;
 		} else {
 			cable_mode_resp.raw_value =
-				pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+				pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 			eudo.cable_type =
 				cable_mode_resp.retimer_type  == USB_RETIMER ?
@@ -1117,7 +1117,7 @@ uint32_t get_enter_usb_msg_payload(int port)
 		}
 	} else {
 		cable_mode_resp.raw_value =
-			pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+			pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 		eudo.cable_type =
 			cable_mode_resp.tbt_active_passive == TBT_CABLE_ACTIVE ?
@@ -1212,7 +1212,7 @@ __overridable int svdm_enter_dp_mode(int port, uint32_t mode_caps)
 
 __overridable int svdm_dp_status(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
 	payload[0] = VDO(USB_SID_DISPLAYPORT, 1,
 			 CMD_DP_STATUS | VDO_OPOS(opos));
@@ -1256,7 +1256,7 @@ static mux_state_t svdm_dp_get_mux_mode(int port)
 
 __overridable int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	uint8_t pin_mode = get_dp_pin_mode(port);
 	mux_state_t mux_mode = svdm_dp_get_mux_mode(port);
 	/* Default dp_port_mf_allow is true */
diff --git a/common/usb_pd_console_cmd.c b/common/usb_pd_console_cmd.c
index 9746904a1d..984f9def91 100644
--- a/common/usb_pd_console_cmd.c
+++ b/common/usb_pd_console_cmd.c
@@ -18,17 +18,17 @@ static void dump_pe(int port)
 	struct svdm_amode_data *modep;
 	uint32_t mode_caps;
 	const union disc_ident_ack *resp;
-	enum tcpm_sop_type type;
+	enum tcpci_msg_type type;
 	/* TODO(b/152417597): Output SOP' discovery results */
 	const struct pd_discovery *disc =
-		pd_get_am_discovery(port, TCPC_TX_SOP);
+		pd_get_am_discovery(port, TCPCI_MSG_SOP);
 
 	static const char * const idh_ptype_names[]  = {
 		"UNDEF", "Hub", "Periph", "PCable", "ACable", "AMA",
 		"RSV6", "RSV7"};
 	static const char * const tx_names[] = {"SOP", "SOP'", "SOP''"};
 
-	for (type = TCPC_TX_SOP; type < DISCOVERY_TYPE_COUNT; type++) {
+	for (type = TCPCI_MSG_SOP; type < DISCOVERY_TYPE_COUNT; type++) {
 		resp = pd_get_identity_response(port, type);
 		if (pd_get_identity_discovery(port, type) != PD_DISC_COMPLETE) {
 			ccprintf("No %s identity discovered yet.\n",
@@ -52,20 +52,20 @@ static void dump_pe(int port)
 		ccprintf("\n");
 	}
 
-	if (pd_get_svid_count(port, TCPC_TX_SOP) < 1) {
+	if (pd_get_svid_count(port, TCPCI_MSG_SOP) < 1) {
 		ccprintf("No SVIDS discovered yet.\n");
 		return;
 	}
 
 	/* TODO(b/152418267): Display discovered SVIDs and modes for SOP' */
-	for (i = 0; i < pd_get_svid_count(port, TCPC_TX_SOP); i++) {
+	for (i = 0; i < pd_get_svid_count(port, TCPCI_MSG_SOP); i++) {
 		ccprintf("SVID[%d]: %04x MODES:", i, disc->svids[i].svid);
 		for (j = 0; j < disc->svids[j].mode_cnt; j++)
 			ccprintf(" [%d] %08x", j + 1,
 					disc->svids[i].mode_vdo[j]);
 		ccprintf("\n");
 
-		modep = pd_get_amode_data(port, TCPC_TX_SOP,
+		modep = pd_get_amode_data(port, TCPCI_MSG_SOP,
 				disc->svids[i].svid);
 		if (modep) {
 			mode_caps = modep->data->mode_vdo[modep->opos - 1];
@@ -134,10 +134,10 @@ static int command_cable(int argc, char **argv)
 	}
 	ccprintf("%s\n", cable_type[ptype]);
 
-	cable_rev = pd_get_rev(port, TCPC_TX_SOP_PRIME);
-	disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+	cable_rev = pd_get_rev(port, TCPCI_MSG_SOP_PRIME);
+	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 	cable_mode_resp.raw_value =
-		pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+		pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 
 	/* Cable revision */
diff --git a/common/usb_pd_host_cmd.c b/common/usb_pd_host_cmd.c
index c800c20478..4261e8c1f0 100644
--- a/common/usb_pd_host_cmd.c
+++ b/common/usb_pd_host_cmd.c
@@ -118,7 +118,7 @@ static enum ec_status hc_remote_pd_set_amode(struct host_cmd_handler_args *args)
 
 	switch (p->cmd) {
 	case PD_EXIT_MODE:
-		if (pd_dfp_exit_mode(p->port, TCPC_TX_SOP, p->svid, p->opos))
+		if (pd_dfp_exit_mode(p->port, TCPCI_MSG_SOP, p->svid, p->opos))
 			pd_send_vdm(p->port, p->svid,
 				    CMD_EXIT_MODE | VDO_OPOS(p->opos), NULL, 0);
 		else {
@@ -127,7 +127,7 @@ static enum ec_status hc_remote_pd_set_amode(struct host_cmd_handler_args *args)
 		}
 		break;
 	case PD_ENTER_MODE:
-		if (pd_dfp_enter_mode(p->port, TCPC_TX_SOP, p->svid, p->opos))
+		if (pd_dfp_enter_mode(p->port, TCPCI_MSG_SOP, p->svid, p->opos))
 			pd_send_vdm(p->port, p->svid, CMD_ENTER_MODE |
 				    VDO_OPOS(p->opos), NULL, 0);
 		break;
@@ -173,20 +173,20 @@ static enum ec_status hc_remote_pd_get_amode(struct host_cmd_handler_args *args)
 
 	/* no more to send */
 	/* TODO(b/148528713): Use TCPMv2's separate storage for SOP'. */
-	if (p->svid_idx >= pd_get_svid_count(p->port, TCPC_TX_SOP)) {
+	if (p->svid_idx >= pd_get_svid_count(p->port, TCPCI_MSG_SOP)) {
 		r->svid = 0;
 		args->response_size = sizeof(r->svid);
 		return EC_RES_SUCCESS;
 	}
 
-	r->svid = pd_get_svid(p->port, p->svid_idx, TCPC_TX_SOP);
+	r->svid = pd_get_svid(p->port, p->svid_idx, TCPCI_MSG_SOP);
 	r->opos = 0;
-	memcpy(r->vdo, pd_get_mode_vdo(p->port, p->svid_idx, TCPC_TX_SOP),
+	memcpy(r->vdo, pd_get_mode_vdo(p->port, p->svid_idx, TCPCI_MSG_SOP),
 		sizeof(uint32_t) * PDO_MODES);
-	modep = pd_get_amode_data(p->port, TCPC_TX_SOP, r->svid);
+	modep = pd_get_amode_data(p->port, TCPCI_MSG_SOP, r->svid);
 
 	if (modep)
-		r->opos = pd_alt_mode(p->port, TCPC_TX_SOP, r->svid);
+		r->opos = pd_alt_mode(p->port, TCPCI_MSG_SOP, r->svid);
 
 	args->response_size = sizeof(*r);
 	return EC_RES_SUCCESS;
@@ -253,8 +253,8 @@ static uint8_t get_pd_control_flags(int port)
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		return 0;
 
-	cable_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
-	device_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP);
+	cable_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
+	device_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP);
 
 	/*
 	 * Ref: USB Type-C Cable and Connector Specification
diff --git a/common/usb_pd_policy.c b/common/usb_pd_policy.c
index e91b99393b..959feb4728 100644
--- a/common/usb_pd_policy.c
+++ b/common/usb_pd_policy.c
@@ -247,7 +247,7 @@ static inline bool is_limit_tbt_cable_speed(int port)
 	return !!(cable[port].flags & CABLE_FLAGS_TBT_COMPAT_LIMIT_SPEED);
 }
 
-static bool is_intel_svid(int port, enum tcpm_sop_type type)
+static bool is_intel_svid(int port, enum tcpci_msg_type type)
 {
 	int i;
 
@@ -314,7 +314,7 @@ static inline void disable_usb4_mode(int port)
 static bool is_cable_ready_to_enter_usb4(int port, int cnt)
 {
 	/* TODO: USB4 enter mode for Active cables */
-	struct pd_discovery *disc = &discovery[port][TCPC_TX_SOP_PRIME];
+	struct pd_discovery *disc = &discovery[port][TCPCI_MSG_SOP_PRIME];
 	if (IS_ENABLED(CONFIG_USB_PD_USB4) &&
 	    (get_usb_pd_cable_type(port) == IDH_PTYPE_PCABLE) &&
 	    is_vdo_present(cnt, VDO_INDEX_PTYPE_CABLE1)) {
@@ -369,13 +369,13 @@ static int dfp_discover_svids(uint32_t *payload)
 	return 1;
 }
 
-struct pd_discovery *pd_get_am_discovery(int port, enum tcpm_sop_type type)
+struct pd_discovery *pd_get_am_discovery(int port, enum tcpci_msg_type type)
 {
 	return &discovery[port][type];
 }
 
 struct partner_active_modes *
-pd_get_partner_active_modes(int port, enum tcpm_sop_type type)
+pd_get_partner_active_modes(int port, enum tcpci_msg_type type)
 {
 	assert(type < AMODE_TYPE_COUNT);
 	return &partner_amodes[port][type];
@@ -395,7 +395,7 @@ 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, TCPC_TX_SOP);
+	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)
@@ -425,10 +425,10 @@ static bool is_usb4_vdo(int port, int cnt, uint32_t *payload)
 
 static int process_am_discover_ident_sop(int port, int cnt, uint32_t head,
 					 uint32_t *payload,
-					 enum tcpm_sop_type *rtype)
+					 enum tcpci_msg_type *rtype)
 {
 	pd_dfp_discovery_init(port);
-	dfp_consume_identity(port, TCPC_TX_SOP, cnt, payload);
+	dfp_consume_identity(port, TCPCI_MSG_SOP, cnt, payload);
 
 	if (IS_ENABLED(CONFIG_USB_PD_DECODE_SOP) && is_sop_prime_ready(port) &&
 	    board_is_tbt_usb4_port(port)) {
@@ -448,7 +448,7 @@ static int process_am_discover_ident_sop(int port, int cnt, uint32_t head,
 
 		if (is_modal(port, cnt, payload) ||
 		    is_usb4_vdo(port, cnt, payload)) {
-			*rtype = TCPC_TX_SOP_PRIME;
+			*rtype = TCPCI_MSG_SOP_PRIME;
 			return dfp_discover_ident(payload);
 		}
 	}
@@ -459,7 +459,7 @@ static int process_am_discover_ident_sop(int port, int cnt, uint32_t head,
 static int process_am_discover_ident_sop_prime(int port, int cnt, uint32_t head,
 					       uint32_t *payload)
 {
-	dfp_consume_identity(port, TCPC_TX_SOP_PRIME, cnt, payload);
+	dfp_consume_identity(port, TCPCI_MSG_SOP_PRIME, cnt, payload);
 	cable[port].rev = PD_HEADER_REV(head);
 
 	/*
@@ -491,13 +491,13 @@ static int process_am_discover_ident_sop_prime(int port, int cnt, uint32_t head,
 }
 
 static int process_am_discover_svids(int port, int cnt, uint32_t *payload,
-				     enum tcpm_sop_type sop,
-				     enum tcpm_sop_type *rtype)
+				     enum tcpci_msg_type sop,
+				     enum tcpci_msg_type *rtype)
 {
 	/*
 	 * The pd_discovery structure stores SOP and SOP' discovery results
 	 * separately, but TCPMv1 depends on one-dimensional storage of SVIDs
-	 * and modes. Therefore, always use TCPC_TX_SOP in TCPMv1.
+	 * and modes. Therefore, always use TCPCI_MSG_SOP in TCPMv1.
 	 */
 	dfp_consume_svids(port, sop, cnt, payload);
 
@@ -527,12 +527,12 @@ static int process_am_discover_svids(int port, int cnt, uint32_t *payload,
 				return 0;
 			}
 
-			if (sop == TCPC_TX_SOP_PRIME)
+			if (sop == TCPCI_MSG_SOP_PRIME)
 				limit_tbt_cable_speed(port);
 			else
 				disable_tbt_compat_mode(port);
-		} else if (sop == TCPC_TX_SOP) {
-			*rtype = TCPC_TX_SOP_PRIME;
+		} else if (sop == TCPCI_MSG_SOP) {
+			*rtype = TCPCI_MSG_SOP_PRIME;
 			return dfp_discover_svids(payload);
 		}
 	}
@@ -541,21 +541,21 @@ static int process_am_discover_svids(int port, int cnt, uint32_t *payload,
 }
 
 static int process_tbt_compat_discover_modes(int port,
-					     enum tcpm_sop_type sop,
+					     enum tcpci_msg_type sop,
 					     uint32_t *payload,
-					     enum tcpm_sop_type *rtype)
+					     enum tcpci_msg_type *rtype)
 {
 	int rsize;
 
 	/* Initialize transmit type to SOP */
-	*rtype = TCPC_TX_SOP;
+	*rtype = TCPCI_MSG_SOP;
 
 	/*
 	 * For active cables, Enter mode: SOP', SOP'', SOP
 	 * Ref: USB Type-C Cable and Connector Specification, figure F-1: TBT3
 	 * Discovery Flow and Section F.2.7 TBT3 Cable Enter Mode Command.
 	 */
-	if (sop == TCPC_TX_SOP_PRIME) {
+	if (sop == TCPCI_MSG_SOP_PRIME) {
 		/* Store Discover Mode SOP' response */
 		cable[port].cable_mode_resp.raw_value = payload[1];
 
@@ -580,7 +580,7 @@ static int process_tbt_compat_discover_modes(int port,
 		 * otherwise send TBT3 Device Enter Mode (SOP).
 		 */
 		if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE)
-			*rtype = TCPC_TX_SOP_PRIME;
+			*rtype = TCPCI_MSG_SOP_PRIME;
 
 		rsize = enter_tbt_compat_mode(port, *rtype, payload);
 	} else {
@@ -596,31 +596,31 @@ static int process_tbt_compat_discover_modes(int port,
 			rsize = enter_tbt_compat_mode(port, *rtype, payload);
 		} else {
 			/* Discover modes for SOP' */
-			discovery[port][TCPC_TX_SOP].svid_idx--;
+			discovery[port][TCPCI_MSG_SOP].svid_idx--;
 			rsize = dfp_discover_modes(port, payload);
-			*rtype = TCPC_TX_SOP_PRIME;
+			*rtype = TCPCI_MSG_SOP_PRIME;
 		}
 	}
 
 	return rsize;
 }
 
-static int obj_cnt_enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
+static int obj_cnt_enter_tbt_compat_mode(int port, enum tcpci_msg_type sop,
 					 uint32_t *payload,
-					 enum tcpm_sop_type *rtype)
+					 enum tcpci_msg_type *rtype)
 {
-	struct pd_discovery *disc = &discovery[port][TCPC_TX_SOP_PRIME];
+	struct pd_discovery *disc = &discovery[port][TCPCI_MSG_SOP_PRIME];
 
 	/* Enter mode SOP' for active cables */
-	if (sop == TCPC_TX_SOP_PRIME) {
+	if (sop == TCPCI_MSG_SOP_PRIME) {
 		/* Check if the cable has a SOP'' controller */
 		if (disc->identity.product_t1.a_rev20.sop_p_p)
-			*rtype = TCPC_TX_SOP_PRIME_PRIME;
+			*rtype = TCPCI_MSG_SOP_PRIME_PRIME;
 		return enter_tbt_compat_mode(port, *rtype, payload);
 	}
 
 	/* Enter Mode SOP'' for active cables with SOP'' controller */
-	if (sop == TCPC_TX_SOP_PRIME_PRIME)
+	if (sop == TCPCI_MSG_SOP_PRIME_PRIME)
 		return enter_tbt_compat_mode(port, *rtype, payload);
 
 	/* Update Mux state to Thunderbolt-compatible mode. */
@@ -631,7 +631,7 @@ static int obj_cnt_enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
 #endif /* CONFIG_USB_PD_ALT_MODE_DFP */
 
 int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
-	    uint32_t head, enum tcpm_sop_type *rtype)
+	    uint32_t head, enum tcpci_msg_type *rtype)
 {
 	int cmd = PD_VDO_CMD(payload[0]);
 	int cmd_type = PD_VDO_CMDT(payload[0]);
@@ -640,11 +640,11 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 	int rsize = 1; /* VDM header at a minimum */
 
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
-	enum tcpm_sop_type sop = PD_HEADER_GET_SOP(head);
+	enum tcpci_msg_type sop = PD_HEADER_GET_SOP(head);
 #endif
 
 	/* Transmit SOP messages by default */
-	*rtype = TCPC_TX_SOP;
+	*rtype = TCPCI_MSG_SOP;
 
 	payload[0] &= ~VDO_CMDT_MASK;
 	*rpayload = payload;
@@ -700,19 +700,20 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 			payload[0] |= VDO_CMDT(CMDT_RSP_BUSY);
 			rsize = 1;
 		}
-		payload[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		payload[0] |=
+			VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 	} else if (cmd_type == CMDT_RSP_ACK) {
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 		struct svdm_amode_data *modep;
 
-		modep = pd_get_amode_data(port, TCPC_TX_SOP,
+		modep = pd_get_amode_data(port, TCPCI_MSG_SOP,
 					  PD_VDO_VID(payload[0]));
 #endif
 		switch (cmd) {
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 		case CMD_DISCOVER_IDENT:
 			/* Received a SOP' Discover Ident msg */
-			if (sop == TCPC_TX_SOP_PRIME) {
+			if (sop == TCPCI_MSG_SOP_PRIME) {
 				rsize = process_am_discover_ident_sop_prime(
 					port, cnt, head, payload);
 				/* Received a SOP Discover Ident Message */
@@ -744,7 +745,7 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 				 */
 				disable_tbt_compat_mode(port);
 				payload[0] = pd_dfp_enter_mode(
-					port, TCPC_TX_SOP, 0, 0);
+					port, TCPCI_MSG_SOP, 0, 0);
 				if (payload[0])
 					rsize = 1;
 			}
@@ -761,8 +762,8 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 				rsize = 0;
 			} else {
 				if (!modep->opos)
-					pd_dfp_enter_mode(port, TCPC_TX_SOP, 0,
-							  0);
+					pd_dfp_enter_mode(port, TCPCI_MSG_SOP,
+							0, 0);
 
 				if (modep->opos) {
 					rsize = modep->fx->status(port,
@@ -801,7 +802,8 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 		}
 
 		payload[0] |= VDO_CMDT(CMDT_INIT);
-		payload[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		payload[0] |=
+			VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 	} else if (cmd_type == CMDT_RSP_BUSY) {
 		switch (cmd) {
@@ -825,7 +827,7 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 	} else if (cmd_type == CMDT_RSP_NAK) {
 		/* Passive cable Nacked for Discover SVID */
 		if (cmd == CMD_DISCOVER_SVID && is_tbt_compat_enabled(port) &&
-		    sop == TCPC_TX_SOP_PRIME &&
+		    sop == TCPCI_MSG_SOP_PRIME &&
 		    get_usb_pd_cable_type(port) == IDH_PTYPE_PCABLE) {
 			limit_tbt_cable_speed(port);
 			rsize = dfp_discover_modes(port, payload);
@@ -844,7 +846,7 @@ int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
 #else
 
 int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
-	    uint32_t head, enum tcpm_sop_type *rtype)
+	    uint32_t head, enum tcpci_msg_type *rtype)
 {
 	return 0;
 }
diff --git a/common/usb_pd_protocol.c b/common/usb_pd_protocol.c
index e20fa11aee..378960c91e 100644
--- a/common/usb_pd_protocol.c
+++ b/common/usb_pd_protocol.c
@@ -268,7 +268,7 @@ static struct pd_protocol {
 	/* next Vendor Defined Message to send */
 	uint32_t vdo_data[VDO_MAX_SIZE];
 	/* type of transmit message (SOP/SOP'/SOP'') */
-	enum tcpm_sop_type xmit_type;
+	enum tcpci_msg_type xmit_type;
 	uint8_t vdo_count;
 	/* VDO to retry if UFP responder replied busy. */
 	uint32_t vdo_retry;
@@ -345,13 +345,13 @@ static inline void set_state_timeout(int port,
 	pd[port].timeout_state = timeout_state;
 }
 
-int pd_get_rev(int port, enum tcpm_sop_type type)
+int pd_get_rev(int port, enum tcpci_msg_type type)
 {
 #ifdef CONFIG_USB_PD_REV30
 	/* TCPMv1 Only stores PD revision for SOP and SOP' types */
 	ASSERT(type < NUM_SOP_STAR_TYPES - 1);
 
-	if (type == TCPC_TX_SOP_PRIME)
+	if (type == TCPCI_MSG_SOP_PRIME)
 		return get_usb_pd_cable_revision(port);
 
 	return pd[port].rev;
@@ -360,10 +360,10 @@ int pd_get_rev(int port, enum tcpm_sop_type type)
 #endif
 }
 
-int pd_get_vdo_ver(int port, enum tcpm_sop_type type)
+int pd_get_vdo_ver(int port, enum tcpci_msg_type type)
 {
 #ifdef CONFIG_USB_PD_REV30
-	if (type == TCPC_TX_SOP_PRIME)
+	if (type == TCPCI_MSG_SOP_PRIME)
 		return vdo_ver[get_usb_pd_cable_revision(port)];
 
 	return vdo_ver[pd[port].rev];
@@ -681,15 +681,15 @@ static bool consume_sop_repeat_message(int port, uint8_t msg_id)
 static bool consume_repeat_message(int port, uint32_t msg_header)
 {
 	uint8_t msg_id = PD_HEADER_ID(msg_header);
-	enum tcpm_sop_type sop = PD_HEADER_GET_SOP(msg_header);
+	enum tcpci_msg_type sop = PD_HEADER_GET_SOP(msg_header);
 
 	/* If repeat message ignore, except softreset control request. */
 	if (PD_HEADER_TYPE(msg_header) == PD_CTRL_SOFT_RESET &&
 	    PD_HEADER_CNT(msg_header) == 0) {
 		return false;
-	} else if (sop == TCPC_TX_SOP_PRIME) {
+	} else if (sop == TCPCI_MSG_SOP_PRIME) {
 		return consume_sop_prime_repeat_msg(port, msg_id);
-	} else if (sop == TCPC_TX_SOP_PRIME_PRIME) {
+	} else if (sop == TCPCI_MSG_SOP_PRIME_PRIME) {
 		return consume_sop_prime_prime_repeat_msg(port, msg_id);
 	} else {
 		return consume_sop_repeat_message(port, msg_id);
@@ -835,7 +835,7 @@ static inline void set_state(int port, enum pd_states next_state)
 		charge_manager_update_dualrole(port, CAP_UNKNOWN);
 #endif
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
-		if (pd_dfp_exit_mode(port, TCPC_TX_SOP, 0, 0))
+		if (pd_dfp_exit_mode(port, TCPCI_MSG_SOP, 0, 0))
 			usb_mux_set_safe_mode(port);
 #endif
 		/*
@@ -908,7 +908,7 @@ void pd_transmit_complete(int port, int status)
 	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX);
 }
 
-static int pd_transmit(int port, enum tcpm_sop_type type,
+static int pd_transmit(int port, enum tcpci_msg_type type,
 		       uint16_t header, const uint32_t *data, enum ams_seq ams)
 {
 	int evt;
@@ -961,7 +961,7 @@ static int pd_transmit(int port, enum tcpm_sop_type type,
 			 */
 			sink_can_xmit(port, SINK_TX_NG);
 			sink_ng = 1;
-		} else if (type != TCPC_TX_HARD_RESET) {
+		} else if (type != TCPCI_MSG_TX_HARD_RESET) {
 			enum tcpc_cc_voltage_status cc1, cc2;
 
 			tcpm_get_cc(port, &cc1, &cc2);
@@ -1004,7 +1004,7 @@ static int send_control(int port, int type)
 	int bit_len;
 	uint16_t header = PD_HEADER(type, pd[port].power_role,
 				pd[port].data_role, pd[port].msg_id, 0,
-				pd_get_rev(port, TCPC_TX_SOP), 0);
+				pd_get_rev(port, TCPCI_MSG_SOP), 0);
 	/*
 	 * For PD 3.0, collision avoidance logic needs to know if this message
 	 * will begin a new Atomic Message Sequence (AMS)
@@ -1013,7 +1013,7 @@ static int send_control(int port, int type)
 			    ? AMS_START : AMS_RESPONSE;
 
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, NULL, ams);
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, NULL, ams);
 	if (debug_level >= 2)
 		CPRINTF("C%d CTRL[%d]>%d\n", port, type, bit_len);
 
@@ -1042,13 +1042,13 @@ static int send_source_cap(int port, enum ams_seq ams)
 		/* No source capabilities defined, sink only */
 		header = PD_HEADER(PD_CTRL_REJECT, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id, 0,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 	else
 		header = PD_HEADER(PD_DATA_SOURCE_CAP, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id, src_pdo_cnt,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, src_pdo, ams);
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, src_pdo, ams);
 	if (debug_level >= 2)
 		CPRINTF("C%d srcCAP>%d\n", port, bit_len);
 
@@ -1135,7 +1135,7 @@ static int send_battery_cap(int port, uint32_t *payload)
 		}
 	}
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, (uint32_t *)msg,
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, (uint32_t *)msg,
 			      AMS_RESPONSE);
 	if (debug_level >= 2)
 		CPRINTF("C%d batCap>%d\n", port, bit_len);
@@ -1203,7 +1203,7 @@ static int send_battery_status(int port,  uint32_t *payload)
 		msg = BSDO_CAP(BSDO_CAP_UNKNOWN);
 	}
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, &msg, AMS_RESPONSE);
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, &msg, AMS_RESPONSE);
 	if (debug_level >= 2)
 		CPRINTF("C%d batStat>%d\n", port, bit_len);
 
@@ -1217,9 +1217,9 @@ static void send_sink_cap(int port)
 	int bit_len;
 	uint16_t header = PD_HEADER(PD_DATA_SINK_CAP, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id, pd_snk_pdo_cnt,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, pd_snk_pdo,
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, pd_snk_pdo,
 			      AMS_RESPONSE);
 	if (debug_level >= 2)
 		CPRINTF("C%d snkCAP>%d\n", port, bit_len);
@@ -1230,10 +1230,10 @@ static int send_request(int port, uint32_t rdo)
 	int bit_len;
 	uint16_t header = PD_HEADER(PD_DATA_REQUEST, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id, 1,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 
 	/* Note: ams will need to be AMS_START if used for PPS keep alive */
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, &rdo, AMS_RESPONSE);
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, &rdo, AMS_RESPONSE);
 	if (debug_level >= 2)
 		CPRINTF("C%d REQ>%d\n", port, bit_len);
 
@@ -1250,9 +1250,9 @@ static int send_bist_cmd(int port)
 	int bit_len;
 	uint16_t header = PD_HEADER(PD_DATA_BIST, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id, 1,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 
-	bit_len = pd_transmit(port, TCPC_TX_SOP, header, &bdo, AMS_START);
+	bit_len = pd_transmit(port, TCPCI_MSG_SOP, header, &bdo, AMS_START);
 	CPRINTF("C%d BIST>%d\n", port, bit_len);
 
 	return bit_len;
@@ -1260,7 +1260,7 @@ static int send_bist_cmd(int port)
 #endif
 
 static void queue_vdm(int port, uint32_t *header, const uint32_t *data,
-			     int data_cnt, enum tcpm_sop_type type)
+			     int data_cnt, enum tcpci_msg_type type)
 {
 	pd[port].vdo_count = data_cnt + 1;
 	pd[port].vdo_data[0] = header[0];
@@ -1276,7 +1276,7 @@ static void handle_vdm_request(int port, int cnt, uint32_t *payload,
 {
 	int rlen = 0;
 	uint32_t *rdata;
-	enum tcpm_sop_type rtype = TCPC_TX_SOP;
+	enum tcpci_msg_type rtype = TCPCI_MSG_SOP;
 
 	if (pd[port].vdm_state == VDM_STATE_BUSY) {
 		/* If UFP responded busy retry after timeout */
@@ -1371,7 +1371,7 @@ void pd_execute_hard_reset(int port)
 	invalidate_last_message_id(port);
 	tcpm_set_rx_enable(port, 0);
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
-	if (pd_dfp_exit_mode(port, TCPC_TX_SOP, 0, 0))
+	if (pd_dfp_exit_mode(port, TCPCI_MSG_SOP, 0, 0))
 		usb_mux_set_safe_mode(port);
 #endif
 
@@ -1637,7 +1637,7 @@ static void handle_data_request(int port, uint32_t head,
 			/* currently only support sending bist carrier mode 2 */
 			if ((payload[0] >> 28) == 5) {
 				/* bist data object mode is 2 */
-				pd_transmit(port, TCPC_TX_BIST_MODE_2, 0,
+				pd_transmit(port, TCPCI_MSG_TX_BIST_MODE_2, 0,
 					    NULL, AMS_RESPONSE);
 				/* Set to appropriate port disconnected state */
 				set_state(port, DUAL_ROLE_IF_ELSE(port,
@@ -2125,7 +2125,7 @@ void pd_send_vdm(int port, uint32_t vid, int cmd, const uint32_t *data,
 #ifdef CONFIG_USB_PD_REV30
 	pd[port].vdo_data[0] |= VDO_SVDM_VERS(vdo_ver[pd[port].rev]);
 #endif
-	queue_vdm(port, pd[port].vdo_data, data, count, TCPC_TX_SOP);
+	queue_vdm(port, pd[port].vdo_data, data, count, TCPCI_MSG_SOP);
 
 	task_wake(PD_PORT_TO_TASK_ID(port));
 }
@@ -2179,7 +2179,7 @@ static void exit_tbt_mode_sop_prime(int port)
 	if (!IS_ENABLED(CONFIG_USB_PD_TBT_COMPAT_MODE))
 		return;
 
-	opos = pd_alt_mode(port, TCPC_TX_SOP, USB_VID_INTEL);
+	opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_VID_INTEL);
 	if (opos <= 0)
 		return;
 
@@ -2187,9 +2187,9 @@ static void exit_tbt_mode_sop_prime(int port)
 	/*
 	 * Note: TCPMv2 contemplates separate discovery structures for each SOP
 	 * type. TCPMv1 only uses one discovery structure, so all accesses
-	 * specify TCPC_TX_SOP.
+	 * specify TCPCI_MSG_SOP.
 	 */
-	if (pd_dfp_exit_mode(port, TCPC_TX_SOP, USB_VID_INTEL, opos))
+	if (pd_dfp_exit_mode(port, TCPCI_MSG_SOP, USB_VID_INTEL, opos))
 		usb_mux_set_safe_mode(port);
 	else
 		return;
@@ -2197,12 +2197,12 @@ static void exit_tbt_mode_sop_prime(int port)
 	header = PD_HEADER(PD_DATA_VENDOR_DEF, pd[port].power_role,
 			pd[port].data_role, pd[port].msg_id,
 			(int)pd[port].vdo_count,
-			pd_get_rev(port, TCPC_TX_SOP), 0);
+			pd_get_rev(port, TCPCI_MSG_SOP), 0);
 
 	pd[port].vdo_data[0] = VDO(USB_VID_INTEL, 1,
 				   CMD_EXIT_MODE | VDO_OPOS(opos));
 
-	pd_transmit(port, TCPC_TX_SOP_PRIME, header, pd[port].vdo_data,
+	pd_transmit(port, TCPCI_MSG_SOP_PRIME, header, pd[port].vdo_data,
 		    AMS_START);
 
 	usb_mux_set(port, USB_PD_MUX_USB_ENABLED, USB_SWITCH_CONNECT,
@@ -2213,7 +2213,7 @@ static void pd_vdm_send_state_machine(int port)
 {
 	int res;
 	uint16_t header;
-	enum tcpm_sop_type msg_type = pd[port].xmit_type;
+	enum tcpci_msg_type msg_type = pd[port].xmit_type;
 
 	switch (pd[port].vdm_state) {
 	case VDM_STATE_READY:
@@ -2241,8 +2241,8 @@ static void pd_vdm_send_state_machine(int port)
 		 * data role swap takes place during source and sink
 		 * negotiation and in case of failure, a soft reset is issued.
 		 */
-		if ((msg_type == TCPC_TX_SOP_PRIME) ||
-		    (msg_type == TCPC_TX_SOP_PRIME_PRIME)) {
+		if ((msg_type == TCPCI_MSG_SOP_PRIME) ||
+		    (msg_type == TCPCI_MSG_SOP_PRIME_PRIME)) {
 			/* Prepare SOP'/SOP'' header and send VDM */
 			header = PD_HEADER(
 				PD_DATA_VENDOR_DEF,
@@ -2250,7 +2250,7 @@ static void pd_vdm_send_state_machine(int port)
 				0,
 				pd[port].msg_id,
 				(int)pd[port].vdo_count,
-				pd_get_rev(port, TCPC_TX_SOP),
+				pd_get_rev(port, TCPCI_MSG_SOP),
 				0);
 			res = pd_transmit(port, msg_type, header,
 					  pd[port].vdo_data, AMS_START);
@@ -2275,17 +2275,17 @@ static void pd_vdm_send_state_machine(int port)
 						   pd[port].msg_id,
 						   (int)pd[port].vdo_count,
 						   pd_get_rev
-							(port, TCPC_TX_SOP),
+							(port, TCPCI_MSG_SOP),
 						   0);
 
-				if ((msg_type == TCPC_TX_SOP_PRIME_PRIME) &&
+				if ((msg_type == TCPCI_MSG_SOP_PRIME_PRIME) &&
 				     IS_ENABLED(CONFIG_USBC_SS_MUX)) {
 					exit_tbt_mode_sop_prime(port);
-				} else if (msg_type == TCPC_TX_SOP_PRIME) {
+				} else if (msg_type == TCPCI_MSG_SOP_PRIME) {
 					pd[port].vdo_data[0] = VDO(USB_SID_PD,
 						1, CMD_DISCOVER_SVID);
 				}
-				res = pd_transmit(port, TCPC_TX_SOP, header,
+				res = pd_transmit(port, TCPCI_MSG_SOP, header,
 						  pd[port].vdo_data, AMS_START);
 				reset_pd_cable(port);
 			}
@@ -2296,8 +2296,8 @@ static void pd_vdm_send_state_machine(int port)
 					   pd[port].data_role,
 					   pd[port].msg_id,
 					   (int)pd[port].vdo_count,
-					   pd_get_rev(port, TCPC_TX_SOP), 0);
-			res = pd_transmit(port, TCPC_TX_SOP, header,
+					   pd_get_rev(port, TCPCI_MSG_SOP), 0);
+			res = pd_transmit(port, TCPCI_MSG_SOP, header,
 					  pd[port].vdo_data, AMS_START);
 		}
 
@@ -2391,12 +2391,11 @@ __maybe_unused static void exit_supported_alt_mode(int port)
 		return;
 
 	for (i = 0; i < supported_modes_cnt; i++) {
-		int opos = pd_alt_mode(port, TCPC_TX_SOP,
+		int opos = pd_alt_mode(port, TCPCI_MSG_SOP,
 				supported_modes[i].svid);
 
-		if (opos > 0 &&
-		    pd_dfp_exit_mode(
-			    port, TCPC_TX_SOP, supported_modes[i].svid, opos)) {
+		if (opos > 0 && pd_dfp_exit_mode(port, TCPCI_MSG_SOP,
+					supported_modes[i].svid, opos)) {
 			CPRINTS("C%d Exiting ALT mode with SVID = 0x%x", port,
 				supported_modes[i].svid);
 			usb_mux_set_safe_mode(port);
@@ -2821,7 +2820,8 @@ static void pd_send_enter_usb(int port, int *timeout)
 		PD_REV30,
 		0);
 
-	res = pd_transmit(port, TCPC_TX_SOP, header, &usb4_payload, AMS_START);
+	res = pd_transmit(port, TCPCI_MSG_SOP, header, &usb4_payload,
+			AMS_START);
 	if (res < 0) {
 		*timeout = 10*MSEC;
 		/*
@@ -3071,7 +3071,7 @@ void pd_task(void *u)
 			/* cut the power */
 			pd_execute_hard_reset(port);
 			/* notify the other side of the issue */
-			pd_transmit(port, TCPC_TX_HARD_RESET, 0, NULL,
+			pd_transmit(port, TCPCI_MSG_TX_HARD_RESET, 0, NULL,
 				    AMS_START);
 		}
 
@@ -4569,7 +4569,7 @@ void pd_task(void *u)
 			if (hard_reset_sent)
 				break;
 
-			if (pd_transmit(port, TCPC_TX_HARD_RESET, 0, NULL,
+			if (pd_transmit(port, TCPCI_MSG_TX_HARD_RESET, 0, NULL,
 				AMS_START) < 0) {
 				/*
 				 * likely a non-idle channel
@@ -4639,7 +4639,7 @@ void pd_task(void *u)
 						PD_STATE_SRC_DISCONNECTED));
 			break;
 		case PD_STATE_BIST_TX:
-			pd_transmit(port, TCPC_TX_BIST_MODE_2, 0, NULL,
+			pd_transmit(port, TCPCI_MSG_TX_BIST_MODE_2, 0, NULL,
 				    AMS_START);
 			/* Delay at least enough to finish sending BIST */
 			timeout = PD_T_BIST_TRANSMIT + 20*MSEC;
@@ -4997,7 +4997,7 @@ int pd_is_port_enabled(int port)
 void pd_send_hpd(int port, enum hpd_event hpd)
 {
 	uint32_t data[1];
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	if (!opos)
 		return;
 
diff --git a/common/usb_pd_tcpc.c b/common/usb_pd_tcpc.c
index fd933d655e..1aaee29abc 100644
--- a/common/usb_pd_tcpc.c
+++ b/common/usb_pd_tcpc.c
@@ -259,7 +259,7 @@ static struct pd_port_controller {
 	int rx_buf_head, rx_buf_tail;
 
 	/* Next transmit */
-	enum tcpm_sop_type tx_type;
+	enum tcpci_msg_type tx_type;
 	uint16_t tx_head;
 	uint32_t tx_payload[7];
 	const uint32_t *tx_data;
@@ -721,11 +721,11 @@ int pd_analyze_rx(int port, uint32_t *payload)
 #ifdef CONFIG_USB_PD_DECODE_SOP
 	/* Encode message address */
 	if (val == PD_SOP) {
-		phs.head |= PD_HEADER_SOP(TCPC_TX_SOP);
+		phs.head |= PD_HEADER_SOP(TCPCI_MSG_SOP);
 	} else if (val == PD_SOP_PRIME) {
-		phs.head |= PD_HEADER_SOP(TCPC_TX_SOP_PRIME);
+		phs.head |= PD_HEADER_SOP(TCPCI_MSG_SOP_PRIME);
 	} else if (val == PD_SOP_PRIME_PRIME) {
-		phs.head |= PD_HEADER_SOP(TCPC_TX_SOP_PRIME_PRIME);
+		phs.head |= PD_HEADER_SOP(TCPCI_MSG_SOP_PRIME_PRIME);
 	} else {
 		msg = "SOP*";
 		goto packet_err;
@@ -868,19 +868,19 @@ int tcpc_run(int port, int evt)
 	if ((evt & PD_EVENT_TX) && pd[port].rx_enabled) {
 		switch (pd[port].tx_type) {
 #if defined(CONFIG_USB_VPD) || defined(CONFIG_USB_CTVPD)
-		case TCPC_TX_SOP_PRIME:
+		case TCPCI_MSG_SOP_PRIME:
 #else
-		case TCPC_TX_SOP:
+		case TCPCI_MSG_SOP:
 #endif
 			res = send_validate_message(port,
 					pd[port].tx_head,
 					pd[port].tx_data);
 			break;
-		case TCPC_TX_BIST_MODE_2:
+		case TCPCI_MSG_TX_BIST_MODE_2:
 			bist_mode_2_tx(port);
 			res = 0;
 			break;
-		case TCPC_TX_HARD_RESET:
+		case TCPCI_MSG_TX_HARD_RESET:
 			res = send_hard_reset(port);
 			break;
 		default:
@@ -1128,7 +1128,7 @@ int tcpc_set_rx_enable(int port, int enable)
 	return EC_SUCCESS;
 }
 
-int tcpc_transmit(int port, enum tcpm_sop_type type, uint16_t header,
+int tcpc_transmit(int port, enum tcpci_msg_type type, uint16_t header,
 		  const uint32_t *data)
 {
 	/* Store data to transmit and wake task to send it */
diff --git a/common/usbc/dp_alt_mode.c b/common/usbc/dp_alt_mode.c
index 1f62d5fb71..9a3493c6e1 100644
--- a/common/usbc/dp_alt_mode.c
+++ b/common/usbc/dp_alt_mode.c
@@ -73,7 +73,7 @@ static void dp_entry_failed(int port)
 	dp_state[port] = DP_INACTIVE;
 }
 
-static bool dp_response_valid(int port, enum tcpm_sop_type type,
+static bool dp_response_valid(int port, enum tcpci_msg_type type,
 			     char *cmdt, int vdm_cmd)
 {
 	enum dp_states st = dp_state[port];
@@ -82,11 +82,11 @@ static bool dp_response_valid(int port, enum tcpm_sop_type type,
 	 * Check for an unexpected response.
 	 * If DP is inactive, ignore the command.
 	 */
-	if (type != TCPC_TX_SOP ||
+	if (type != TCPCI_MSG_SOP ||
 	    (st != DP_INACTIVE && state_vdm_cmd[st] != vdm_cmd)) {
 		CPRINTS("C%d: Received unexpected DP VDM %s (cmd %d) from"
 			" %s in state %d", port, cmdt, vdm_cmd,
-			type == TCPC_TX_SOP ? "port partner" : "cable plug",
+			type == TCPCI_MSG_SOP ? "port partner" : "cable plug",
 			st);
 		dp_entry_failed(port);
 		return false;
@@ -96,9 +96,9 @@ static bool dp_response_valid(int port, enum tcpm_sop_type type,
 
 static void dp_exit_to_usb_mode(int port)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 
-	pd_dfp_exit_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT, opos);
+	pd_dfp_exit_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT, opos);
 	set_usb_mux_with_current_data_role(port);
 
 	CPRINTS("C%d: Exited DP mode", port);
@@ -111,7 +111,7 @@ static void dp_exit_to_usb_mode(int port)
 		? DP_START : DP_INACTIVE;
 }
 
-void dp_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dp_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
 	const struct svdm_amode_data *modep =
@@ -171,7 +171,7 @@ void dp_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 	}
 }
 
-void dp_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd)
+void dp_vdm_naked(int port, enum tcpci_msg_type type, uint8_t vdm_cmd)
 {
 	if (!dp_response_valid(port, type, "NAK", vdm_cmd))
 		return;
@@ -210,7 +210,7 @@ void dp_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd)
 int dp_setup_next_vdm(int port, int vdo_count, uint32_t *vdm)
 {
 	const struct svdm_amode_data *modep = pd_get_amode_data(port,
-			TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+			TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	int vdo_count_ret;
 
 	if (vdo_count < VDO_MAX_SIZE)
@@ -220,13 +220,13 @@ int dp_setup_next_vdm(int port, int vdo_count, uint32_t *vdm)
 	case DP_START:
 	case DP_ENTER_RETRY:
 		/* Enter the first supported mode for DisplayPort. */
-		vdm[0] = pd_dfp_enter_mode(port, TCPC_TX_SOP,
+		vdm[0] = pd_dfp_enter_mode(port, TCPCI_MSG_SOP,
 				USB_SID_DISPLAYPORT, 0);
 		if (vdm[0] == 0)
 			return -1;
 		/* CMDT_INIT is 0, so this is a no-op */
 		vdm[0] |= VDO_CMDT(CMDT_INIT);
-		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 		vdo_count_ret = 1;
 		if (dp_state[port] == DP_START)
 			CPRINTS("C%d: Attempting to enter DP mode", port);
@@ -240,7 +240,7 @@ int dp_setup_next_vdm(int port, int vdo_count, uint32_t *vdm)
 			return -1;
 		vdm[0] |= PD_VDO_OPOS(modep->opos);
 		vdm[0] |= VDO_CMDT(CMDT_INIT);
-		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 		break;
 	case DP_STATUS_ACKED:
 		if (!(modep && modep->opos))
@@ -250,7 +250,7 @@ int dp_setup_next_vdm(int port, int vdo_count, uint32_t *vdm)
 		if (vdo_count_ret == 0)
 			return -1;
 		vdm[0] |= VDO_CMDT(CMDT_INIT);
-		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 		break;
 	case DP_ENTER_NAKED:
 	case DP_ACTIVE:
@@ -275,7 +275,7 @@ int dp_setup_next_vdm(int port, int vdo_count, uint32_t *vdm)
 
 		vdm[0] |= VDO_OPOS(modep->opos);
 		vdm[0] |= VDO_CMDT(CMDT_INIT);
-		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+		vdm[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 		vdo_count_ret = 1;
 		break;
 	case DP_INACTIVE:
diff --git a/common/usbc/tbt_alt_mode.c b/common/usbc/tbt_alt_mode.c
index b54848053c..0509add1f8 100644
--- a/common/usbc/tbt_alt_mode.c
+++ b/common/usbc/tbt_alt_mode.c
@@ -172,7 +172,7 @@ void tbt_exit_mode_request(int port)
 	 */
 	if (tbt_state[port] == TBT_ENTER_SOP) {
 		cable_mode_resp.raw_value =
-			pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+			pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 		/*
 		 * For Linear re-driver cables, the port enters USB4 mode
@@ -185,12 +185,12 @@ void tbt_exit_mode_request(int port)
 	}
 }
 
-static bool tbt_response_valid(int port, enum tcpm_sop_type type,
+static bool tbt_response_valid(int port, enum tcpci_msg_type type,
 				char *cmdt, int vdm_cmd)
 {
 	enum tbt_states st = tbt_state[port];
 	union tbt_mode_resp_cable cable_mode_resp = {
-		.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME) };
+		.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME) };
 
 	/*
 	 * Check for an unexpected response.
@@ -201,7 +201,7 @@ static bool tbt_response_valid(int port, enum tcpm_sop_type type,
 	if ((st != TBT_INACTIVE && state_vdm_cmd[st] != vdm_cmd) ||
 	    (get_usb_pd_cable_type(port) == IDH_PTYPE_PCABLE &&
 	     cable_mode_resp.tbt_active_passive == TBT_CABLE_PASSIVE &&
-	     type != TCPC_TX_SOP)) {
+	     type != TCPCI_MSG_SOP)) {
 		tbt_exit_done(port);
 		return false;
 	}
@@ -220,7 +220,7 @@ static void tbt_active_cable_exit_mode(int port)
 {
 	struct pd_discovery *disc;
 
-	disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	if (disc->identity.product_t1.a_rev20.sop_p_p)
 		tbt_state[port] = TBT_EXIT_SOP_PRIME_PRIME;
@@ -244,14 +244,14 @@ bool tbt_cable_entry_required_for_usb4(int port)
 		return false;
 
 	cable_mode_resp.raw_value =
-			pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+			pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 	if (cable_mode_resp.tbt_active_passive == TBT_CABLE_ACTIVE)
 		return true;
 
 	if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) {
-		disc_sop_prime = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
-		if (pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME) < VDM_VER20 ||
+		disc_sop_prime = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
+		if (pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME) < VDM_VER20 ||
 		    disc_sop_prime->identity.product_t1.a_rev30.vdo_ver <
 							VDO_VERSION_1_3)
 			return true;
@@ -259,7 +259,7 @@ bool tbt_cable_entry_required_for_usb4(int port)
 	return false;
 }
 
-void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void intel_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
 	struct pd_discovery *disc;
@@ -270,13 +270,13 @@ void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 	if (!tbt_response_valid(port, type, "ACK", vdm_cmd))
 		return;
 
-	disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+	disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
 	switch (tbt_state[port]) {
 	case TBT_ENTER_SOP_PRIME:
 		tbt_prints("enter mode SOP'", port);
 		cable_mode_resp.raw_value =
-				pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+				pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 		/* For LRD cables, Enter mode SOP' -> Enter mode SOP */
 		if (disc->identity.product_t1.a_rev20.sop_p_p &&
 		    cable_mode_resp.tbt_active_passive != TBT_CABLE_ACTIVE) {
@@ -301,10 +301,10 @@ void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 		break;
 	case TBT_ACTIVE:
 		tbt_prints("exit mode SOP", port);
-		opos_sop = pd_alt_mode(port, TCPC_TX_SOP, USB_VID_INTEL);
+		opos_sop = pd_alt_mode(port, TCPCI_MSG_SOP, USB_VID_INTEL);
 
 		/* Clear Thunderbolt related signals */
-		pd_dfp_exit_mode(port, TCPC_TX_SOP, USB_VID_INTEL, opos_sop);
+		pd_dfp_exit_mode(port, TCPCI_MSG_SOP, USB_VID_INTEL, opos_sop);
 		set_usb_mux_with_current_data_role(port);
 		if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) {
 			tbt_active_cable_exit_mode(port);
@@ -340,12 +340,12 @@ void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 			 */
 			tbt_exit_done(port);
 			opos_sop_prime =
-				pd_alt_mode(port, TCPC_TX_SOP_PRIME,
+				pd_alt_mode(port, TCPCI_MSG_SOP_PRIME,
 					    USB_VID_INTEL);
 
 			/* Clear Thunderbolt related signals */
-			pd_dfp_exit_mode(port, TCPC_TX_SOP_PRIME, USB_VID_INTEL,
-				     opos_sop_prime);
+			pd_dfp_exit_mode(port, TCPCI_MSG_SOP_PRIME,
+					USB_VID_INTEL, opos_sop_prime);
 			set_usb_mux_with_current_data_role(port);
 		} else {
 			tbt_retry_enter_mode(port);
@@ -367,7 +367,7 @@ void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 	}
 }
 
-void intel_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd)
+void intel_vdm_naked(int port, enum tcpci_msg_type type, uint8_t vdm_cmd)
 {
 	if (!tbt_response_valid(port, type, "NAK", vdm_cmd))
 		return;
@@ -437,7 +437,7 @@ void intel_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd)
 static bool tbt_mode_is_supported(int port, int vdo_count)
 {
 	const struct pd_discovery *disc =
-			pd_get_am_discovery(port, TCPC_TX_SOP);
+			pd_get_am_discovery(port, TCPCI_MSG_SOP);
 
 	if (!disc->identity.idh.modal_support)
 		return false;
@@ -452,20 +452,20 @@ static bool tbt_mode_is_supported(int port, int vdo_count)
 	 */
 	if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE &&
 		!pd_is_mode_discovered_for_svid(
-			port, TCPC_TX_SOP_PRIME, USB_VID_INTEL))
+			port, TCPCI_MSG_SOP_PRIME, USB_VID_INTEL))
 		return false;
 
 	return true;
 }
 
 int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
-		enum tcpm_sop_type *tx_type)
+		enum tcpci_msg_type *tx_type)
 {
 	struct svdm_amode_data *modep;
 	int vdo_count_ret = 0;
 	union tbt_mode_resp_cable cable_mode_resp;
 
-	*tx_type = TCPC_TX_SOP;
+	*tx_type = TCPCI_MSG_SOP;
 
 	if (vdo_count < VDO_MAX_SIZE)
 		return -1;
@@ -481,36 +481,36 @@ int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
 			tbt_prints("retry to enter mode", port);
 
 		cable_mode_resp.raw_value =
-			pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME);
+			pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME);
 
 		/* Active cable and LRD cables send Enter Mode SOP' first */
 		if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE ||
 		    cable_mode_resp.tbt_active_passive == TBT_CABLE_ACTIVE) {
 			vdo_count_ret = enter_tbt_compat_mode(port,
-						TCPC_TX_SOP_PRIME, vdm);
-			*tx_type = TCPC_TX_SOP_PRIME;
+						TCPCI_MSG_SOP_PRIME, vdm);
+			*tx_type = TCPCI_MSG_SOP_PRIME;
 			tbt_state[port] = TBT_ENTER_SOP_PRIME;
 		} else {
 			/* Passive cable send Enter Mode SOP */
 			vdo_count_ret =
-				enter_tbt_compat_mode(port, TCPC_TX_SOP, vdm);
+				enter_tbt_compat_mode(port, TCPCI_MSG_SOP, vdm);
 			tbt_state[port] = TBT_ENTER_SOP;
 		}
 		break;
 	case TBT_ENTER_SOP_PRIME:
 		vdo_count_ret =
-			enter_tbt_compat_mode(port, TCPC_TX_SOP_PRIME, vdm);
-		*tx_type = TCPC_TX_SOP_PRIME;
+			enter_tbt_compat_mode(port, TCPCI_MSG_SOP_PRIME, vdm);
+		*tx_type = TCPCI_MSG_SOP_PRIME;
 		break;
 	case TBT_ENTER_SOP_PRIME_PRIME:
 		vdo_count_ret =
 			enter_tbt_compat_mode(
-				port, TCPC_TX_SOP_PRIME_PRIME, vdm);
-		*tx_type = TCPC_TX_SOP_PRIME_PRIME;
+				port, TCPCI_MSG_SOP_PRIME_PRIME, vdm);
+		*tx_type = TCPCI_MSG_SOP_PRIME_PRIME;
 		break;
 	case TBT_ENTER_SOP:
 		vdo_count_ret =
-			enter_tbt_compat_mode(port, TCPC_TX_SOP, vdm);
+			enter_tbt_compat_mode(port, TCPCI_MSG_SOP, vdm);
 		break;
 	case TBT_EXIT_SOP:
 	case TBT_ACTIVE:
@@ -521,7 +521,7 @@ int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
 		 * is restarted while Thunderbolt mode is active.
 		 */
 		modep = pd_get_amode_data(port,
-					  TCPC_TX_SOP, USB_VID_INTEL);
+					  TCPCI_MSG_SOP, USB_VID_INTEL);
 		if (!(modep && modep->opos))
 			return -1;
 
@@ -531,12 +531,12 @@ int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
 			VDO_OPOS(modep->opos) |
 			VDO_CMDT(CMDT_INIT) |
 			VDO_SVDM_VERS(
-				pd_get_vdo_ver(port, TCPC_TX_SOP));
+				pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 		vdo_count_ret = 1;
 		break;
 	case TBT_EXIT_SOP_PRIME_PRIME:
 		modep = pd_get_amode_data(port,
-			TCPC_TX_SOP_PRIME, USB_VID_INTEL);
+			TCPCI_MSG_SOP_PRIME, USB_VID_INTEL);
 		if (!(modep && modep->opos))
 			return -1;
 
@@ -546,13 +546,13 @@ int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
 			VDO_OPOS(modep->opos) |
 			VDO_CMDT(CMDT_INIT) |
 			VDO_SVDM_VERS(pd_get_vdo_ver(port,
-				TCPC_TX_SOP_PRIME_PRIME));
+				TCPCI_MSG_SOP_PRIME_PRIME));
 		vdo_count_ret = 1;
-		*tx_type = TCPC_TX_SOP_PRIME_PRIME;
+		*tx_type = TCPCI_MSG_SOP_PRIME_PRIME;
 		break;
 	case TBT_EXIT_SOP_PRIME:
 		modep = pd_get_amode_data(port,
-				TCPC_TX_SOP_PRIME, USB_VID_INTEL);
+				TCPCI_MSG_SOP_PRIME, USB_VID_INTEL);
 		if (!(modep && modep->opos))
 			return -1;
 
@@ -561,9 +561,10 @@ int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
 		vdm[0] = VDO(USB_VID_INTEL, 1, CMD_EXIT_MODE) |
 			VDO_OPOS(modep->opos) |
 			VDO_CMDT(CMDT_INIT) |
-			VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME));
+			VDO_SVDM_VERS(pd_get_vdo_ver(port,
+						TCPCI_MSG_SOP_PRIME));
 		vdo_count_ret = 1;
-		*tx_type = TCPC_TX_SOP_PRIME;
+		*tx_type = TCPCI_MSG_SOP_PRIME;
 		break;
 	case TBT_INACTIVE:
 		/* Thunderbolt mode is inactive */
diff --git a/common/usbc/usb_mode.c b/common/usbc/usb_mode.c
index 3829d5463f..1620ed4e1f 100644
--- a/common/usbc/usb_mode.c
+++ b/common/usbc/usb_mode.c
@@ -143,13 +143,13 @@ void enter_usb_failed(int port)
 	usb4_state[port] = USB4_INACTIVE;
 }
 
-static bool enter_usb_response_valid(int port, enum tcpm_sop_type type)
+static bool enter_usb_response_valid(int port, enum tcpci_msg_type type)
 {
 	/*
 	 * Check for an unexpected response.
 	 */
 	if (get_usb_pd_cable_type(port) == IDH_PTYPE_PCABLE &&
-	     type != TCPC_TX_SOP) {
+	     type != TCPCI_MSG_SOP) {
 		enter_usb_failed(port);
 		return false;
 	}
@@ -159,7 +159,7 @@ static bool enter_usb_response_valid(int port, enum tcpm_sop_type type)
 bool enter_usb_port_partner_is_capable(int port)
 {
 	const struct pd_discovery *disc =
-			pd_get_am_discovery(port, TCPC_TX_SOP);
+			pd_get_am_discovery(port, TCPCI_MSG_SOP);
 
 	if (usb4_state[port] == USB4_INACTIVE)
 		return false;
@@ -177,9 +177,9 @@ bool enter_usb_cable_is_capable(int port)
 			return false;
 	} else if (get_usb_pd_cable_type(port) == IDH_PTYPE_ACABLE) {
 		struct pd_discovery *disc_sop_prime =
-			pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+			pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 
-		if (pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME) >= VDM_VER20 &&
+		if (pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME) >= VDM_VER20 &&
 		    disc_sop_prime->identity.product_t1.a_rev30.vdo_ver >=
 							VDO_VERSION_1_3) {
 			union active_cable_vdo2_rev30 a2_rev30 =
@@ -200,14 +200,14 @@ bool enter_usb_cable_is_capable(int port)
 		 */
 		} else {
 			const struct pd_discovery *disc =
-				pd_get_am_discovery(port, TCPC_TX_SOP);
+				pd_get_am_discovery(port, TCPCI_MSG_SOP);
 			union tbt_mode_resp_cable cable_mode_resp = {
 				.raw_value = pd_get_tbt_mode_vdo(port,
-							TCPC_TX_SOP_PRIME) };
+							TCPCI_MSG_SOP_PRIME) };
 
 			if (!disc->identity.idh.modal_support ||
 			   !pd_is_mode_discovered_for_svid(port,
-					TCPC_TX_SOP_PRIME, USB_VID_INTEL) ||
+					TCPCI_MSG_SOP_PRIME, USB_VID_INTEL) ||
 			    cable_mode_resp.tbt_rounded !=
 					TBT_GEN3_GEN4_ROUNDED_NON_ROUNDED)
 				return false;
@@ -216,7 +216,7 @@ bool enter_usb_cable_is_capable(int port)
 	return true;
 }
 
-void enter_usb_accepted(int port, enum tcpm_sop_type type)
+void enter_usb_accepted(int port, enum tcpci_msg_type type)
 {
 	struct pd_discovery *disc;
 
@@ -225,7 +225,7 @@ void enter_usb_accepted(int port, enum tcpm_sop_type type)
 
 	switch (usb4_state[port]) {
 	case USB4_ENTER_SOP_PRIME:
-		disc = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		disc = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 		if (disc->identity.product_t1.a_rev20.sop_p_p)
 			usb4_state[port] = USB4_ENTER_SOP_PRIME_PRIME;
 		else
@@ -254,7 +254,7 @@ void enter_usb_accepted(int port, enum tcpm_sop_type type)
 	}
 }
 
-void enter_usb_rejected(int port, enum tcpm_sop_type type)
+void enter_usb_rejected(int port, enum tcpci_msg_type type)
 {
 	if (!enter_usb_response_valid(port, type) ||
 	    usb4_state[port] == USB4_ACTIVE)
@@ -263,13 +263,13 @@ void enter_usb_rejected(int port, enum tcpm_sop_type type)
 	enter_usb_failed(port);
 }
 
-uint32_t enter_usb_setup_next_msg(int port, enum tcpm_sop_type *type)
+uint32_t enter_usb_setup_next_msg(int port, enum tcpci_msg_type *type)
 {
 	struct pd_discovery *disc_sop_prime;
 
 	switch (usb4_state[port]) {
 	case USB4_START:
-		disc_sop_prime = pd_get_am_discovery(port, TCPC_TX_SOP_PRIME);
+		disc_sop_prime = pd_get_am_discovery(port, TCPCI_MSG_SOP_PRIME);
 		/*
 		 * Ref: Tiger Lake Platform PD Controller Interface Requirements
 		 * for Integrated USBC, section A.2.2: USB4 as DFP.
@@ -279,24 +279,24 @@ uint32_t enter_usb_setup_next_msg(int port, enum tcpm_sop_type *type)
 		 */
 		usb_mux_set_safe_mode(port);
 
-		if (pd_get_vdo_ver(port, TCPC_TX_SOP_PRIME) < VDM_VER20 ||
+		if (pd_get_vdo_ver(port, TCPCI_MSG_SOP_PRIME) < VDM_VER20 ||
 		    disc_sop_prime->identity.product_t1.a_rev30.vdo_ver <
 							VDO_VERSION_1_3 ||
 		    get_usb_pd_cable_type(port) == IDH_PTYPE_PCABLE) {
 			usb4_state[port] = USB4_ENTER_SOP;
 		} else {
 			usb4_state[port] = USB4_ENTER_SOP_PRIME;
-			*type = TCPC_TX_SOP_PRIME;
+			*type = TCPCI_MSG_SOP_PRIME;
 		}
 		break;
 	case USB4_ENTER_SOP_PRIME:
-		*type = TCPC_TX_SOP_PRIME;
+		*type = TCPCI_MSG_SOP_PRIME;
 		break;
 	case USB4_ENTER_SOP_PRIME_PRIME:
-		*type = TCPC_TX_SOP_PRIME_PRIME;
+		*type = TCPCI_MSG_SOP_PRIME_PRIME;
 		break;
 	case USB4_ENTER_SOP:
-		*type = TCPC_TX_SOP;
+		*type = TCPCI_MSG_SOP;
 		break;
 	case USB4_ACTIVE:
 		return -1;
diff --git a/common/usbc/usb_pd_dp_ufp.c b/common/usbc/usb_pd_dp_ufp.c
index 31a3069bb9..0009b5c710 100644
--- a/common/usbc/usb_pd_dp_ufp.c
+++ b/common/usbc/usb_pd_dp_ufp.c
@@ -104,7 +104,7 @@ static void hpd_to_dp_attention(void)
 	 * Construct DP Attention message. This consists of the VDM header and
 	 * the DP_STATUS VDO.
 	 */
-	svdm_header = VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP)) |
+	svdm_header = VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP)) |
 			       VDO_OPOS(opos) | CMD_ATTENTION;
 	vdm[0] = VDO(USB_SID_DISPLAYPORT, 1, svdm_header);
 
diff --git a/common/usbc/usb_pd_dpm.c b/common/usbc/usb_pd_dpm.c
index 4fbd496ad4..eb2dfc52c0 100644
--- a/common/usbc/usb_pd_dpm.c
+++ b/common/usbc/usb_pd_dpm.c
@@ -181,7 +181,7 @@ static bool dpm_mode_entry_requested(int port, enum typec_mode mode)
 	}
 }
 
-void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dpm_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
 	const uint16_t svid = PD_VDO_VID(vdm[0]);
@@ -203,7 +203,7 @@ void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
 	}
 }
 
-void dpm_vdm_naked(int port, enum tcpm_sop_type type, uint16_t svid,
+void dpm_vdm_naked(int port, enum tcpci_msg_type type, uint16_t svid,
 		uint8_t vdm_cmd)
 {
 	switch (svid) {
@@ -231,7 +231,7 @@ static void dpm_attempt_mode_entry(int port)
 {
 	int vdo_count = 0;
 	uint32_t vdm[VDO_MAX_SIZE];
-	enum tcpm_sop_type tx_type = TCPC_TX_SOP;
+	enum tcpci_msg_type tx_type = TCPCI_MSG_SOP;
 	bool enter_mode_requested =
 		IS_ENABLED(CONFIG_USB_PD_REQUIRE_AP_MODE_ENTRY) ?  false : true;
 
@@ -264,8 +264,8 @@ static void dpm_attempt_mode_entry(int port)
 	 * If discovery has not occurred for modes, do not attempt to switch
 	 * to alt mode.
 	 */
-	if (pd_get_svids_discovery(port, TCPC_TX_SOP) != PD_DISC_COMPLETE ||
-	    pd_get_modes_discovery(port, TCPC_TX_SOP) != PD_DISC_COMPLETE)
+	if (pd_get_svids_discovery(port, TCPCI_MSG_SOP) != PD_DISC_COMPLETE ||
+	    pd_get_modes_discovery(port, TCPCI_MSG_SOP) != PD_DISC_COMPLETE)
 		return;
 
 	if (dp_entry_is_done(port) ||
@@ -297,8 +297,9 @@ static void dpm_attempt_mode_entry(int port)
 
 	/* If not, check if they support Thunderbolt alt mode. */
 	if (IS_ENABLED(CONFIG_USB_PD_TBT_COMPAT_MODE) &&
-	    board_is_tbt_usb4_port(port) &&
-	    pd_is_mode_discovered_for_svid(port, TCPC_TX_SOP, USB_VID_INTEL) &&
+			board_is_tbt_usb4_port(port) &&
+			pd_is_mode_discovered_for_svid(port, TCPCI_MSG_SOP,
+				USB_VID_INTEL) &&
 			dpm_mode_entry_requested(port, TYPEC_MODE_TBT)) {
 		enter_mode_requested = true;
 		vdo_count = tbt_setup_next_vdm(port,
@@ -307,7 +308,7 @@ static void dpm_attempt_mode_entry(int port)
 
 	/* If not, check if they support DisplayPort alt mode. */
 	if (vdo_count == 0 && !DPM_CHK_FLAG(port, DPM_FLAG_MODE_ENTRY_DONE) &&
-	    pd_is_mode_discovered_for_svid(port, TCPC_TX_SOP,
+	    pd_is_mode_discovered_for_svid(port, TCPCI_MSG_SOP,
 				USB_SID_DISPLAYPORT) &&
 	    dpm_mode_entry_requested(port, TYPEC_MODE_DP)) {
 		enter_mode_requested = true;
@@ -356,7 +357,7 @@ static void dpm_attempt_mode_exit(int port)
 {
 	uint32_t vdm = 0;
 	int vdo_count = 0;
-	enum tcpm_sop_type tx_type = TCPC_TX_SOP;
+	enum tcpci_msg_type tx_type = TCPCI_MSG_SOP;
 
 	if (IS_ENABLED(CONFIG_USB_PD_USB4) &&
 	    enter_usb_entry_is_done(port)) {
@@ -394,7 +395,7 @@ static void dpm_attempt_mode_exit(int port)
 static void dpm_send_attention_vdm(int port)
 {
 	/* Set up VDM ATTEN msg that was passed in previously */
-	if (pd_setup_vdm_request(port, TCPC_TX_SOP, dpm[port].vdm_attention,
+	if (pd_setup_vdm_request(port, TCPCI_MSG_SOP, dpm[port].vdm_attention,
 				 dpm[port].vdm_cnt) == true)
 		/* Trigger PE to start a VDM command run */
 		pd_dpm_request(port, DPM_REQUEST_VDM);
@@ -601,7 +602,7 @@ void dpm_evaluate_sink_fixed_pdo(int port, uint32_t vsafe5v_pdo)
 			return;
 
 		/* FRS is only supported in PD 3.0 and higher */
-		if (pd_get_rev(port, TCPC_TX_SOP) == PD_REV20)
+		if (pd_get_rev(port, TCPCI_MSG_SOP) == PD_REV20)
 			return;
 
 		if ((vsafe5v_pdo & PDO_FIXED_DUAL_ROLE) && frs_current) {
diff --git a/common/usbc/usb_pd_host.c b/common/usbc/usb_pd_host.c
index e4d044097b..514ef82036 100644
--- a/common/usbc/usb_pd_host.c
+++ b/common/usbc/usb_pd_host.c
@@ -24,7 +24,7 @@ static enum ec_status hc_typec_discovery(struct host_cmd_handler_args *args)
 	const struct ec_params_typec_discovery *p = args->params;
 	struct ec_response_typec_discovery *r = args->response;
 	const struct pd_discovery *disc;
-	enum tcpm_sop_type type;
+	enum tcpci_msg_type type;
 
 	/* Confirm the number of HC VDOs matches our stored VDOs */
 	BUILD_ASSERT(sizeof(r->discovery_vdo) == sizeof(union disc_ident_ack));
@@ -36,7 +36,7 @@ static enum ec_status hc_typec_discovery(struct host_cmd_handler_args *args)
 		return EC_RES_INVALID_PARAM;
 
 	type = p->partner_type == TYPEC_PARTNER_SOP ?
-		TCPC_TX_SOP : TCPC_TX_SOP_PRIME;
+		TCPCI_MSG_SOP : TCPCI_MSG_SOP_PRIME;
 
 	/*
 	 * Clear out access mask so we can track if tasks have touched data
@@ -156,10 +156,12 @@ static enum ec_status hc_typec_status(struct host_cmd_handler_args *args)
 	r->events = pd_get_events(p->port);
 
 	r->sop_revision = r->sop_connected ?
-		PD_STATUS_REV_SET_MAJOR(pd_get_rev(p->port, TCPC_TX_SOP)) : 0;
-	r->sop_prime_revision = pd_get_identity_discovery(p->port,
-					TCPC_TX_SOP_PRIME) == PD_DISC_COMPLETE ?
-		PD_STATUS_REV_SET_MAJOR(pd_get_rev(p->port, TCPC_TX_SOP_PRIME))
+		PD_STATUS_REV_SET_MAJOR(pd_get_rev(p->port, TCPCI_MSG_SOP)) : 0;
+	r->sop_prime_revision =
+		pd_get_identity_discovery(p->port, TCPCI_MSG_SOP_PRIME) ==
+		PD_DISC_COMPLETE ?
+		PD_STATUS_REV_SET_MAJOR(pd_get_rev(p->port,
+					TCPCI_MSG_SOP_PRIME))
 		: 0;
 
 	r->source_cap_count = pd_get_src_cap_cnt(p->port);
diff --git a/common/usbc/usb_pe_ctvpd_sm.c b/common/usbc/usb_pe_ctvpd_sm.c
index eb7d8a0aa7..346a57a461 100644
--- a/common/usbc/usb_pe_ctvpd_sm.c
+++ b/common/usbc/usb_pe_ctvpd_sm.c
@@ -111,7 +111,7 @@ void pe_got_hard_reset(int port)
 	/* No implementation needed by this policy engine */
 }
 
-void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type)
+void pe_report_error(int port, enum pe_error e, enum tcpci_msg_type type)
 {
 	/* No implementation needed by this policy engine */
 }
@@ -210,11 +210,11 @@ static void pe_request_run(const int port)
 		tx_emsg[port].len = 20;
 
 		/* Set to highest revision supported by both ports. */
-		prl_set_rev(port, TCPC_TX_SOP_PRIME,
+		prl_set_rev(port, TCPCI_MSG_SOP_PRIME,
 					(PD_HEADER_REV(header) > PD_REV30) ?
 					PD_REV30 : PD_HEADER_REV(header));
 		/* Send the ACK */
-		prl_send_data_msg(port, TCPC_TX_SOP_PRIME,
+		prl_send_data_msg(port, TCPCI_MSG_SOP_PRIME,
 					PD_DATA_VENDOR_DEF);
 	}
 }
diff --git a/common/usbc/usb_pe_drp_sm.c b/common/usbc/usb_pe_drp_sm.c
index 3f770a9fb7..f3faa1eabb 100644
--- a/common/usbc/usb_pe_drp_sm.c
+++ b/common/usbc/usb_pe_drp_sm.c
@@ -575,7 +575,7 @@ static struct policy_engine {
 	uint32_t events;
 
 	/* port address where soft resets are sent */
-	enum tcpm_sop_type soft_reset_sop;
+	enum tcpci_msg_type soft_reset_sop;
 
 	/* Current limit / voltage based on the last request message */
 	uint32_t curr_limit;
@@ -590,7 +590,7 @@ static struct policy_engine {
 	struct partner_active_modes partner_amodes[AMODE_TYPE_COUNT];
 
 	/* Partner type to send */
-	enum tcpm_sop_type tx_type;
+	enum tcpci_msg_type tx_type;
 
 	/* VDM - used to send information to shared VDM Request state */
 	uint32_t vdm_cnt;
@@ -670,12 +670,12 @@ static const uint8_t vdo_ver[] = {
 	[PD_REV30] = VDM_VER20,
 };
 
-int pd_get_rev(int port, enum tcpm_sop_type type)
+int pd_get_rev(int port, enum tcpci_msg_type type)
 {
 	return prl_get_rev(port, type);
 }
 
-int pd_get_vdo_ver(int port, enum tcpm_sop_type type)
+int pd_get_vdo_ver(int port, enum tcpci_msg_type type)
 {
 	enum pd_rev_type rev = prl_get_rev(port, type);
 
@@ -693,7 +693,7 @@ static void pe_set_ready_state(int port)
 		set_state_pe(port, PE_SNK_READY);
 }
 
-static inline void send_data_msg(int port, enum tcpm_sop_type type,
+static inline void send_data_msg(int port, enum tcpci_msg_type type,
 				 enum pd_data_msg_type msg)
 {
 	/* Clear any previous TX status before sending a new message */
@@ -702,14 +702,14 @@ static inline void send_data_msg(int port, enum tcpm_sop_type type,
 }
 
 static __maybe_unused inline void send_ext_data_msg(
-	int port, enum tcpm_sop_type type, enum pd_ext_msg_type msg)
+	int port, enum tcpci_msg_type type, enum pd_ext_msg_type msg)
 {
 	/* Clear any previous TX status before sending a new message */
 	PE_CLR_FLAG(port, PE_FLAGS_TX_COMPLETE);
 	prl_send_ext_data_msg(port, type, msg);
 }
 
-static inline void send_ctrl_msg(int port, enum tcpm_sop_type type,
+static inline void send_ctrl_msg(int port, enum tcpci_msg_type type,
 				 enum pd_ctrl_msg_type msg)
 {
 	/* Clear any previous TX status before sending a new message */
@@ -723,18 +723,18 @@ static void set_cable_rev(int port)
 	 * If port partner runs PD 2.0, cable communication must
 	 * also be PD 2.0
 	 */
-	if (prl_get_rev(port, TCPC_TX_SOP) == PD_REV20) {
+	if (prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV20) {
 	/*
 	 * If the cable supports PD 3.0, but the port partner supports PD 2.0,
 	 * redo the cable discover with PD 2.0
 	 */
-		if (prl_get_rev(port, TCPC_TX_SOP_PRIME) == PD_REV30 &&
-		    pd_get_identity_discovery(port, TCPC_TX_SOP_PRIME) ==
+		if (prl_get_rev(port, TCPCI_MSG_SOP_PRIME) == PD_REV30 &&
+		    pd_get_identity_discovery(port, TCPCI_MSG_SOP_PRIME) ==
 					PD_DISC_COMPLETE) {
-			pd_set_identity_discovery(port, TCPC_TX_SOP_PRIME,
+			pd_set_identity_discovery(port, TCPCI_MSG_SOP_PRIME,
 					PD_DISC_NEEDED);
 		}
-		prl_set_rev(port, TCPC_TX_SOP_PRIME, PD_REV20);
+		prl_set_rev(port, TCPCI_MSG_SOP_PRIME, PD_REV20);
 	}
 }
 
@@ -750,7 +750,7 @@ static void pe_init(int port)
 	pe[port].dpm_curr_request = 0;
 	pd_timer_disable_range(port, PE_TIMER_RANGE);
 	pe[port].data_role = pd_get_data_role(port);
-	pe[port].tx_type = TCPC_TX_INVALID;
+	pe[port].tx_type = TCPCI_MSG_INVALID;
 	pe[port].events = 0;
 
 	tc_pd_connection(port, 0);
@@ -1034,7 +1034,7 @@ static bool pe_can_send_sop_prime(int port)
 {
 	if (IS_ENABLED(CONFIG_USBC_VCONN)) {
 		if (PE_CHK_FLAG(port, PE_FLAGS_EXPLICIT_CONTRACT)) {
-			if (prl_get_rev(port, TCPC_TX_SOP) == PD_REV20)
+			if (prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV20)
 				return tc_is_vconn_src(port) &&
 					pe[port].data_role == PD_ROLE_DFP;
 			else
@@ -1064,7 +1064,7 @@ static bool pe_can_send_sop_prime(int port)
 static bool pe_can_send_sop_vdm(int port, int vdm_cmd)
 {
 	if (PE_CHK_FLAG(port, PE_FLAGS_EXPLICIT_CONTRACT)) {
-		if (prl_get_rev(port, TCPC_TX_SOP) == PD_REV20) {
+		if (prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV20) {
 			if (pe[port].data_role == PD_ROLE_UFP &&
 			    vdm_cmd != CMD_ATTENTION) {
 				return false;
@@ -1082,7 +1082,7 @@ static bool pe_can_send_sop_vdm(int port, int vdm_cmd)
 	return false;
 }
 
-static void pe_send_soft_reset(const int port, enum tcpm_sop_type type)
+static void pe_send_soft_reset(const int port, enum tcpci_msg_type type)
 {
 	pe[port].soft_reset_sop = type;
 	set_state_pe(port, PE_SEND_SOFT_RESET);
@@ -1117,7 +1117,7 @@ static bool pe_check_outgoing_discard(int port)
 	 */
 	if (PE_CHK_FLAG(port, PE_FLAGS_MSG_DISCARDED) &&
 				PE_CHK_FLAG(port, PE_FLAGS_MSG_RECEIVED)) {
-		enum tcpm_sop_type sop =
+		enum tcpci_msg_type sop =
 				PD_HEADER_GET_SOP(rx_emsg[port].header);
 
 		PE_CLR_FLAG(port, PE_FLAGS_MSG_DISCARDED);
@@ -1130,7 +1130,7 @@ static bool pe_check_outgoing_discard(int port)
 	return false;
 }
 
-void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type)
+void pe_report_error(int port, enum pe_error e, enum tcpci_msg_type type)
 {
 	/* This should only be called from the PD task */
 	assert(port == TASK_ID_TO_PD_PORT(task_get_current()));
@@ -1199,7 +1199,7 @@ void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type)
 				!PE_CHK_FLAG(port, PE_FLAGS_INTERRUPTIBLE_AMS))
 			|| e == ERR_TCH_XMIT
 			|| (!PE_CHK_FLAG(port, PE_FLAGS_EXPLICIT_CONTRACT) &&
-				type == TCPC_TX_SOP)) {
+				type == TCPCI_MSG_SOP)) {
 		pe_send_soft_reset(port, type);
 	}
 	/*
@@ -1316,10 +1316,11 @@ void pd_send_vdm(int port, uint32_t vid, int cmd, const uint32_t *data,
 						int count)
 {
 	/* Copy VDM Header */
-	pe[port].vdm_data[0] = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ?
-				1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION),
-				VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP))
-				| cmd);
+	pe[port].vdm_data[0] =
+		VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ?  1 :
+				(PD_VDO_CMD(cmd) <= CMD_ATTENTION),
+			VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP)) |
+				cmd);
 
 	/*
 	 * Copy VDOs after the VDM Header. Note that the count refers to VDO
@@ -1334,7 +1335,7 @@ void pd_send_vdm(int port, uint32_t vid, int cmd, const uint32_t *data,
 	 * that this function is likely called from outside the PD task.
 	 * (b/180465870)
 	 */
-	pe[port].tx_type = TCPC_TX_SOP;
+	pe[port].tx_type = TCPCI_MSG_SOP;
 	pd_dpm_request(port, DPM_REQUEST_VDM);
 
 	task_wake(PD_PORT_TO_TASK_ID(port));
@@ -1475,7 +1476,7 @@ static bool common_src_snk_dpm_requests(int port)
 					DPM_REQUEST_SOFT_RESET_SEND)) {
 		pe_set_dpm_curr_request(port, DPM_REQUEST_SOFT_RESET_SEND);
 		/* Currently only support sending soft reset to SOP */
-		pe_send_soft_reset(port, TCPC_TX_SOP);
+		pe_send_soft_reset(port, TCPCI_MSG_SOP);
 		return true;
 	} else if (PE_CHK_DPM_REQUEST(port,
 					DPM_REQUEST_PORT_DISCOVERY)) {
@@ -1516,7 +1517,7 @@ static bool common_src_snk_dpm_requests(int port)
 				      DPM_REQUEST_SOP_PRIME_SOFT_RESET_SEND)) {
 		pe_set_dpm_curr_request(port,
 			DPM_REQUEST_SOP_PRIME_SOFT_RESET_SEND);
-		pe[port].tx_type = TCPC_TX_SOP_PRIME;
+		pe[port].tx_type = TCPCI_MSG_SOP_PRIME;
 		set_state_pe(port, PE_VCS_CBL_SEND_SOFT_RESET);
 		return true;
 	}
@@ -1704,13 +1705,13 @@ static void send_source_cap(int port)
 
 	if (src_pdo_cnt == 0) {
 		/* No source capabilities defined, sink only */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 	}
 
 	tx_emsg[port].len = src_pdo_cnt * 4;
 	memcpy(tx_emsg[port].buf, (uint8_t *)src_pdo, tx_emsg[port].len);
 
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_SOURCE_CAP);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_SOURCE_CAP);
 }
 
 /*
@@ -1730,7 +1731,7 @@ static void pe_send_request_msg(int port)
 	if ((get_usb_pd_cable_type(port) == IDH_PTYPE_VPD) &&
 						is_vpd_ct_supported(port)) {
 		union vpd_vdo vpd = pd_get_am_discovery(port,
-				TCPC_TX_SOP_PRIME)->identity.product_t1.vpd;
+				TCPCI_MSG_SOP_PRIME)->identity.product_t1.vpd;
 
 		/* The raw vpd_vdo is passed to pd_build_request */
 		vpd_vdo = vpd.raw_value;
@@ -1752,7 +1753,7 @@ static void pe_send_request_msg(int port)
 	tx_emsg[port].len = 4;
 
 	memcpy(tx_emsg[port].buf, (uint8_t *)&rdo, tx_emsg[port].len);
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_REQUEST);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_REQUEST);
 }
 
 static void pe_update_src_pdo_flags(int port, int pdo_cnt, uint32_t *pdos)
@@ -1871,38 +1872,38 @@ __maybe_unused static bool pe_attempt_port_discovery(int port)
 	 * discovery spacing or BUSY spacing runs out.
 	 */
 	if (pd_timer_is_expired(port, PE_TIMER_DISCOVER_IDENTITY)) {
-		if (pd_get_identity_discovery(port, TCPC_TX_SOP_PRIME) ==
+		if (pd_get_identity_discovery(port, TCPCI_MSG_SOP_PRIME) ==
 				PD_DISC_NEEDED) {
-			pe[port].tx_type = TCPC_TX_SOP_PRIME;
+			pe[port].tx_type = TCPCI_MSG_SOP_PRIME;
 			set_state_pe(port, PE_VDM_IDENTITY_REQUEST_CBL);
 			return true;
-		} else if (pd_get_identity_discovery(port, TCPC_TX_SOP) ==
+		} else if (pd_get_identity_discovery(port, TCPCI_MSG_SOP) ==
 				PD_DISC_NEEDED &&
 				pe_can_send_sop_vdm(port, CMD_DISCOVER_IDENT)) {
-			pe[port].tx_type = TCPC_TX_SOP;
+			pe[port].tx_type = TCPCI_MSG_SOP;
 			set_state_pe(port,
 				     PE_INIT_PORT_VDM_IDENTITY_REQUEST);
 			return true;
-		} else if (pd_get_svids_discovery(port, TCPC_TX_SOP) ==
+		} else if (pd_get_svids_discovery(port, TCPCI_MSG_SOP) ==
 				PD_DISC_NEEDED &&
 				pe_can_send_sop_vdm(port, CMD_DISCOVER_SVID)) {
-			pe[port].tx_type = TCPC_TX_SOP;
+			pe[port].tx_type = TCPCI_MSG_SOP;
 			set_state_pe(port, PE_INIT_VDM_SVIDS_REQUEST);
 			return true;
-		} else if (pd_get_modes_discovery(port, TCPC_TX_SOP) ==
+		} else if (pd_get_modes_discovery(port, TCPCI_MSG_SOP) ==
 				PD_DISC_NEEDED &&
 				pe_can_send_sop_vdm(port, CMD_DISCOVER_MODES)) {
-			pe[port].tx_type = TCPC_TX_SOP;
+			pe[port].tx_type = TCPCI_MSG_SOP;
 			set_state_pe(port, PE_INIT_VDM_MODES_REQUEST);
 			return true;
-		} else if (pd_get_svids_discovery(port, TCPC_TX_SOP_PRIME)
+		} else if (pd_get_svids_discovery(port, TCPCI_MSG_SOP_PRIME)
 				== PD_DISC_NEEDED) {
-			pe[port].tx_type = TCPC_TX_SOP_PRIME;
+			pe[port].tx_type = TCPCI_MSG_SOP_PRIME;
 			set_state_pe(port, PE_INIT_VDM_SVIDS_REQUEST);
 			return true;
-		} else if (pd_get_modes_discovery(port, TCPC_TX_SOP_PRIME) ==
+		} else if (pd_get_modes_discovery(port, TCPCI_MSG_SOP_PRIME) ==
 				PD_DISC_NEEDED) {
-			pe[port].tx_type = TCPC_TX_SOP_PRIME;
+			pe[port].tx_type = TCPCI_MSG_SOP_PRIME;
 			set_state_pe(port, PE_INIT_VDM_MODES_REQUEST);
 			return true;
 		}
@@ -1911,7 +1912,7 @@ __maybe_unused static bool pe_attempt_port_discovery(int port)
 	return false;
 }
 
-bool pd_setup_vdm_request(int port, enum tcpm_sop_type tx_type,
+bool pd_setup_vdm_request(int port, enum tcpci_msg_type tx_type,
 		uint32_t *vdm, uint32_t vdo_cnt)
 {
 	if (vdo_cnt < VDO_HDR_SIZE || vdo_cnt > VDO_MAX_SIZE)
@@ -1985,7 +1986,7 @@ static void pe_update_wait_and_add_jitter_timer(int port)
 	 * we start our interrogation.  Add some jitter of up to
 	 * ~345ms to prevent multiple collisions.
 	 */
-	if (prl_get_rev(port, TCPC_TX_SOP) == PD_REV20 &&
+	if (prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV20 &&
 	    PE_CHK_FLAG(port, PE_FLAGS_FIRST_MSG) &&
 	    pd_timer_is_disabled(port, PE_TIMER_WAIT_AND_ADD_JITTER)) {
 		pd_timer_enable(port, PE_TIMER_WAIT_AND_ADD_JITTER,
@@ -2244,12 +2245,13 @@ static void pe_src_discovery_run(int port)
 	 * contract, we use it here to ensure we space any potential BUSY
 	 * requests properly.
 	 */
-	if (pd_get_identity_discovery(port, TCPC_TX_SOP_PRIME) == PD_DISC_NEEDED
+	if (pd_get_identity_discovery(port, TCPCI_MSG_SOP_PRIME) ==
+				PD_DISC_NEEDED
 			&& pd_timer_is_expired(port, PE_TIMER_DISCOVER_IDENTITY)
 			&& pe_can_send_sop_prime(port)
 			&& (pe[port].discover_identity_counter <
 				N_DISCOVER_IDENTITY_PRECONTRACT_LIMIT)) {
-		pe[port].tx_type = TCPC_TX_SOP_PRIME;
+		pe[port].tx_type = TCPCI_MSG_SOP_PRIME;
 		set_state_pe(port, PE_VDM_IDENTITY_REQUEST_CBL);
 		return;
 	}
@@ -2301,7 +2303,7 @@ static void pe_src_send_capabilities_run(int port)
 		set_state_pe(port, PE_SRC_READY);
 		return;
 	} else if (msg_check == PE_MSG_DISCARDED) {
-		pe_send_soft_reset(port, TCPC_TX_SOP);
+		pe_send_soft_reset(port, TCPCI_MSG_SOP);
 		return;
 	}
 
@@ -2345,7 +2347,7 @@ static void pe_src_send_capabilities_run(int port)
 			 * Set to highest revision supported by both
 			 * ports.
 			 */
-			prl_set_rev(port, TCPC_TX_SOP,
+			prl_set_rev(port, TCPCI_MSG_SOP,
 			MIN(PD_REVISION, PD_HEADER_REV(rx_emsg[port].header)));
 
 			set_cable_rev(port);
@@ -2391,7 +2393,7 @@ static void pe_src_send_capabilities_run(int port)
 		if (!PE_CHK_FLAG(port, PE_FLAGS_PD_CONNECTION))
 			set_state_pe(port, PE_SRC_DISCOVERY);
 		else
-			pe_send_soft_reset(port, TCPC_TX_SOP);
+			pe_send_soft_reset(port, TCPCI_MSG_SOP);
 		return;
 	}
 
@@ -2475,9 +2477,9 @@ static void pe_src_transition_supply_entry(int port)
 	/* Send a GotoMin Message or otherwise an Accept Message */
 	if (PE_CHK_FLAG(port, PE_FLAGS_ACCEPT)) {
 		PE_CLR_FLAG(port, PE_FLAGS_ACCEPT);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	} else {
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_GOTO_MIN);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_GOTO_MIN);
 	}
 }
 
@@ -2548,7 +2550,7 @@ static void pe_src_transition_supply_run(int port)
 		pd_timer_disable(port, PE_TIMER_SRC_TRANSITION);
 		/* Transition power supply and send PS_RDY. */
 		pd_transition_voltage(pe[port].requested_idx);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PS_RDY);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PS_RDY);
 		PE_SET_FLAG(port, PE_FLAGS_PS_READY);
 	}
 
@@ -2804,7 +2806,7 @@ static void pe_src_capability_response_entry(int port)
 
 	/* NOTE: Wait messaging should be implemented. */
 
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 }
 
 static void pe_src_capability_response_run(int port)
@@ -3130,7 +3132,7 @@ static void pe_snk_evaluate_capability_entry(int port)
 	pe[port].hard_reset_counter = 0;
 
 	/* Set to highest revision supported by both ports. */
-	prl_set_rev(port, TCPC_TX_SOP,
+	prl_set_rev(port, TCPCI_MSG_SOP,
 			MIN(PD_REVISION, PD_HEADER_REV(rx_emsg[port].header)));
 
 	set_cable_rev(port);
@@ -3179,7 +3181,7 @@ static void pe_snk_select_capability_run(int port)
 {
 	uint8_t type;
 	uint8_t cnt;
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 	enum pe_msg_check msg_check;
 
 	/*
@@ -3199,7 +3201,7 @@ static void pe_snk_select_capability_run(int port)
 		 * 2) SE_SNK_READY: goes back to SNK Ready
 		 */
 		if (get_last_state_pe(port) == PE_SNK_EVALUATE_CAPABILITY)
-			pe_send_soft_reset(port, TCPC_TX_SOP);
+			pe_send_soft_reset(port, TCPCI_MSG_SOP);
 		else
 			set_state_pe(port, PE_SNK_READY);
 		return;
@@ -3730,7 +3732,7 @@ static void pe_snk_get_source_cap_entry(int port)
 
 	/* Send a Get_Source_Cap Message */
 	tx_emsg[port].len = 0;
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP);
 }
 
 static void pe_snk_get_source_cap_run(int port)
@@ -3857,7 +3859,7 @@ static void pe_soft_reset_entry(int port)
 {
 	print_current_state(port);
 
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 }
 
 static void  pe_soft_reset_run(int port)
@@ -3893,10 +3895,10 @@ static void pe_send_not_supported_entry(int port)
 	print_current_state(port);
 
 	/* Request the Protocol Layer to send a Not_Supported Message. */
-	if (prl_get_rev(port, TCPC_TX_SOP) > PD_REV20)
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_NOT_SUPPORTED);
+	if (prl_get_rev(port, TCPCI_MSG_SOP) > PD_REV20)
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_NOT_SUPPORTED);
 	else
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 }
 
 static void pe_send_not_supported_run(int port)
@@ -3954,7 +3956,7 @@ __maybe_unused static void pe_chunk_received_exit(int port)
 static void pe_src_ping_entry(int port)
 {
 	print_current_state(port);
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PING);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PING);
 }
 
 static void pe_src_ping_run(int port)
@@ -4090,7 +4092,7 @@ static void pe_give_battery_cap_entry(int port)
 	/* Extended Battery Cap data is 9 bytes */
 	tx_emsg[port].len = 9;
 
-	send_ext_data_msg(port, TCPC_TX_SOP, PD_EXT_BATTERY_CAP);
+	send_ext_data_msg(port, TCPCI_MSG_SOP, PD_EXT_BATTERY_CAP);
 }
 
 static void pe_give_battery_cap_run(int port)
@@ -4181,7 +4183,7 @@ static void pe_give_battery_status_entry(int port)
 	/* Battery Status data is 4 bytes */
 	tx_emsg[port].len = 4;
 
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_BATTERY_STATUS);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_BATTERY_STATUS);
 }
 
 static void pe_give_battery_status_run(int port)
@@ -4207,7 +4209,7 @@ static void pe_send_alert_entry(int port)
 		pe_set_ready_state(port);
 
 	/* Request the Protocol Layer to send Alert Message. */
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_ALERT);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_ALERT);
 }
 
 static void pe_send_alert_run(int port)
@@ -4233,13 +4235,13 @@ static void pe_drs_evaluate_swap_entry(int port)
 		 * PE_DRS_UFP_DFP_Evaluate_Swap and
 		 * PE_DRS_DFP_UFP_Evaluate_Swap states embedded here.
 		 */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	} else {
 		/*
 		 * PE_DRS_UFP_DFP_Reject_Swap and PE_DRS_DFP_UFP_Reject_Swap
 		 * states embedded here.
 		 */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 	}
 }
 
@@ -4308,7 +4310,7 @@ static void pe_drs_send_swap_entry(int port)
 	 * states embedded here.
 	 */
 	/* Request the Protocol Layer to send a DR_Swap Message */
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_DR_SWAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_DR_SWAP);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -4377,12 +4379,12 @@ static void pe_prs_src_snk_evaluate_swap_entry(int port)
 
 	if (!pd_check_power_swap(port)) {
 		/* PE_PRS_SRC_SNK_Reject_PR_Swap state embedded here */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 	} else {
 		tc_request_power_swap(port);
 		/* PE_PRS_SRC_SNK_Accept_Swap state embedded here */
 		PE_SET_FLAG(port, PE_FLAGS_ACCEPT);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	}
 }
 
@@ -4477,7 +4479,7 @@ static void pe_prs_src_snk_assert_rd_run(int port)
 static void pe_prs_src_snk_wait_source_on_entry(int port)
 {
 	print_current_state(port);
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PS_RDY);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PS_RDY);
 }
 
 static void pe_prs_src_snk_wait_source_on_run(int port)
@@ -4550,7 +4552,7 @@ static void pe_prs_src_snk_send_swap_entry(int port)
 	pd_timer_disable(port, PE_TIMER_PR_SWAP_WAIT);
 
 	/* Request the Protocol Layer to send a PR_Swap Message. */
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PR_SWAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PR_SWAP);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -4638,12 +4640,12 @@ static void pe_prs_snk_src_evaluate_swap_entry(int port)
 
 	if (!pd_check_power_swap(port)) {
 		/* PE_PRS_SNK_SRC_Reject_Swap state embedded here */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 	} else {
 		tc_request_power_swap(port);
 		/* PE_PRS_SNK_SRC_Accept_Swap state embedded here */
 		PE_SET_FLAG(port, PE_FLAGS_ACCEPT);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	}
 }
 
@@ -4799,7 +4801,7 @@ static void pe_prs_snk_src_source_on_run(int port)
 
 		/* update pe power role */
 		pe[port].power_role = pd_get_power_role(port);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PS_RDY);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PS_RDY);
 		/* reset timer so PD_CTRL_PS_RDY isn't sent again */
 		pd_timer_disable(port, PE_TIMER_PS_SOURCE);
 	}
@@ -4850,12 +4852,12 @@ static void pe_prs_snk_src_send_swap_entry(int port)
 	 */
 	if (IS_ENABLED(CONFIG_USB_PD_REV30)) {
 		send_ctrl_msg(port,
-			TCPC_TX_SOP,
+			TCPCI_MSG_SOP,
 			pe_in_frs_mode(port)
 				? PD_CTRL_FR_SWAP
 				: PD_CTRL_PR_SWAP);
 	} else {
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PR_SWAP);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PR_SWAP);
 	}
 	pe_sender_response_msg_entry(port);
 }
@@ -5044,7 +5046,7 @@ static void pe_bist_tx_entry(int port)
 		 * The UUT Shall exit the Continuous BIST Mode within
 		 * tBISTContMode of this Continuous BIST Mode being enabled.
 		 */
-		send_ctrl_msg(port, TCPC_TX_BIST_MODE_2, 0);
+		send_ctrl_msg(port, TCPCI_MSG_TX_BIST_MODE_2, 0);
 		pd_timer_enable(port, PE_TIMER_BIST_CONT_MODE,
 				PD_T_BIST_CONT_MODE);
 	} else if (mode == BIST_TEST_DATA) {
@@ -5105,7 +5107,7 @@ static void pe_snk_give_sink_cap_entry(int port)
 	/* Send a Sink_Capabilities Message */
 	tx_emsg[port].len = pd_snk_pdo_cnt * 4;
 	memcpy(tx_emsg[port].buf, (uint8_t *)pd_snk_pdo, tx_emsg[port].len);
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_SINK_CAP);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_SINK_CAP);
 }
 
 static void pe_snk_give_sink_cap_run(int port)
@@ -5157,7 +5159,7 @@ static void pe_handle_custom_vdm_request_entry(int port)
 		memcpy(tx_emsg[port].buf, (uint8_t *)rdata, tx_emsg[port].len);
 		send_data_msg(port, sop, PD_DATA_VENDOR_DEF);
 	} else {
-		if (prl_get_rev(port, TCPC_TX_SOP) > PD_REV20) {
+		if (prl_get_rev(port, TCPCI_MSG_SOP) > PD_REV20) {
 			set_state_pe(port, PE_SEND_NOT_SUPPORTED);
 		} else {
 			PE_CLR_FLAG(port, PE_FLAGS_INTERRUPTIBLE_AMS);
@@ -5261,7 +5263,7 @@ static enum vdm_response_result parse_vdm_response_common(int port)
  */
 static void pe_vdm_send_request_entry(int port)
 {
-	if (pe[port].tx_type == TCPC_TX_INVALID) {
+	if (pe[port].tx_type == TCPCI_MSG_INVALID) {
 		if (IS_ENABLED(USB_PD_DEBUG_LABELS))
 			CPRINTS("C%d: %s: Tx type expected to be set, "
 				"returning",
@@ -5270,8 +5272,8 @@ static void pe_vdm_send_request_entry(int port)
 		return;
 	}
 
-	if ((pe[port].tx_type == TCPC_TX_SOP_PRIME ||
-	     pe[port].tx_type == TCPC_TX_SOP_PRIME_PRIME) &&
+	if ((pe[port].tx_type == TCPCI_MSG_SOP_PRIME ||
+	     pe[port].tx_type == TCPCI_MSG_SOP_PRIME_PRIME) &&
 	    !tc_is_vconn_src(port) && port_discovery_vconn_swap_policy(port,
 		PE_FLAGS_VCONN_SWAP_TO_ON)) {
 		if (port_try_vconn_swap(port))
@@ -5311,7 +5313,7 @@ static void pe_vdm_send_request_run(int port)
 	 */
 	if (pd_timer_is_expired(port, PE_TIMER_VDM_RESPONSE)) {
 		CPRINTF("VDM %s Response Timeout\n",
-				pe[port].tx_type == TCPC_TX_SOP ?
+				pe[port].tx_type == TCPCI_MSG_SOP ?
 				"Port" : "Cable");
 		/*
 		 * Flag timeout so child state can mark appropriate discovery
@@ -5332,7 +5334,7 @@ static void pe_vdm_send_request_exit(int port)
 	PE_CLR_FLAG(port, PE_FLAGS_INTERRUPTIBLE_AMS);
 
 	/* Invalidate TX type so it must be set before next call */
-	pe[port].tx_type = TCPC_TX_INVALID;
+	pe[port].tx_type = TCPCI_MSG_INVALID;
 
 	pd_timer_disable(port, PE_TIMER_VDM_RESPONSE);
 }
@@ -5434,7 +5436,7 @@ static void pe_vdm_identity_request_cbl_run(int port)
 		 * PD Spec Table 6-2: Revision Interoperability during an
 		 * Explicit Contract
 		 */
-		if (prl_get_rev(port, TCPC_TX_SOP) != PD_REV20)
+		if (prl_get_rev(port, TCPCI_MSG_SOP) != PD_REV20)
 			prl_set_rev(port, sop,
 					PD_HEADER_REV(rx_emsg[port].header));
 		break;
@@ -5464,7 +5466,7 @@ static void pe_vdm_identity_request_cbl_exit(int port)
 	 */
 	if (PE_CHK_FLAG(port, PE_FLAGS_VDM_REQUEST_TIMEOUT)) {
 		PE_CLR_FLAG(port, PE_FLAGS_VDM_REQUEST_TIMEOUT);
-		prl_set_rev(port, TCPC_TX_SOP_PRIME, PD_REV20);
+		prl_set_rev(port, TCPCI_MSG_SOP_PRIME, PD_REV20);
 	}
 
 	/*
@@ -5486,7 +5488,7 @@ static void pe_vdm_identity_request_cbl_exit(int port)
 		 * all retries are exhausted in case the cable is
 		 * non-compliant about GoodCRC-ing higher revisions
 		 */
-		prl_set_rev(port, TCPC_TX_SOP_PRIME, PD_REV20);
+		prl_set_rev(port, TCPCI_MSG_SOP_PRIME, PD_REV20);
 
 	/*
 	 * Set discover identity timer unless BUSY case already did so.
@@ -5510,7 +5512,7 @@ static void pe_vdm_identity_request_cbl_exit(int port)
 	/* Do not attempt further discovery if identity discovery failed. */
 	if (pd_get_identity_discovery(port, pe[port].tx_type) == PD_DISC_FAIL) {
 		pd_set_svids_discovery(port, pe[port].tx_type, PD_DISC_FAIL);
-		pd_notify_event(port, pe[port].tx_type == TCPC_TX_SOP ?
+		pd_notify_event(port, pe[port].tx_type == TCPCI_MSG_SOP ?
 				PD_STATUS_EVENT_SOP_DISC_DONE :
 				PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 	}
@@ -5597,7 +5599,7 @@ static void pe_init_port_vdm_identity_request_exit(int port)
 	/* Do not attempt further discovery if identity discovery failed. */
 	if (pd_get_identity_discovery(port, pe[port].tx_type) == PD_DISC_FAIL) {
 		pd_set_svids_discovery(port, pe[port].tx_type, PD_DISC_FAIL);
-		pd_notify_event(port, pe[port].tx_type == TCPC_TX_SOP ?
+		pd_notify_event(port, pe[port].tx_type == TCPCI_MSG_SOP ?
 				PD_STATUS_EVENT_SOP_DISC_DONE :
 				PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 	}
@@ -5614,7 +5616,7 @@ static void pe_init_vdm_svids_request_entry(int port)
 
 	print_current_state(port);
 
-	if (pe[port].tx_type == TCPC_TX_SOP_PRIME &&
+	if (pe[port].tx_type == TCPCI_MSG_SOP_PRIME &&
 	    !pe_can_send_sop_prime(port)) {
 		/*
 		 * The parent state already tried to enable SOP' traffic. If it
@@ -5690,7 +5692,7 @@ static void pe_init_vdm_svids_request_exit(int port)
 
 	/* If SVID discovery failed, discovery is done at this point */
 	if (pd_get_svids_discovery(port, pe[port].tx_type) == PD_DISC_FAIL)
-		pd_notify_event(port, pe[port].tx_type == TCPC_TX_SOP ?
+		pd_notify_event(port, pe[port].tx_type == TCPCI_MSG_SOP ?
 				PD_STATUS_EVENT_SOP_DISC_DONE :
 				PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 }
@@ -5716,7 +5718,7 @@ static void pe_init_vdm_modes_request_entry(int port)
 
 	print_current_state(port);
 
-	if (pe[port].tx_type == TCPC_TX_SOP_PRIME &&
+	if (pe[port].tx_type == TCPCI_MSG_SOP_PRIME &&
 	    !pe_can_send_sop_prime(port)) {
 		/*
 		 * The parent state already tried to enable SOP' traffic. If it
@@ -5800,7 +5802,7 @@ static void pe_init_vdm_modes_request_exit(int port)
 {
 	if (pd_get_modes_discovery(port, pe[port].tx_type) != PD_DISC_NEEDED)
 		/* Mode discovery done, notify the AP */
-		pd_notify_event(port, pe[port].tx_type == TCPC_TX_SOP ?
+		pd_notify_event(port, pe[port].tx_type == TCPCI_MSG_SOP ?
 				PD_STATUS_EVENT_SOP_DISC_DONE :
 				PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 
@@ -5816,8 +5818,8 @@ static void pe_vdm_request_dpm_entry(int port)
 {
 	print_current_state(port);
 
-	if ((pe[port].tx_type == TCPC_TX_SOP_PRIME ||
-	     pe[port].tx_type == TCPC_TX_SOP_PRIME_PRIME) &&
+	if ((pe[port].tx_type == TCPCI_MSG_SOP_PRIME ||
+	     pe[port].tx_type == TCPCI_MSG_SOP_PRIME_PRIME) &&
 	     !pe_can_send_sop_prime(port)) {
 		/*
 		 * The parent state already tried to enable SOP' traffic. If it
@@ -5908,7 +5910,7 @@ static void pe_vdm_request_dpm_run(int port)
 		 */
 		dpm_vdm_acked(port, sop, cnt, payload);
 
-		if (sop == TCPC_TX_SOP && svid == USB_SID_DISPLAYPORT &&
+		if (sop == TCPCI_MSG_SOP && svid == USB_SID_DISPLAYPORT &&
 				vdm_cmd == CMD_DP_CONFIG) {
 			PE_SET_FLAG(port, PE_FLAGS_VDM_SETUP_DONE);
 		}
@@ -5943,7 +5945,7 @@ static void pe_vdm_request_dpm_exit(int port)
 	 * current VDM request will be resumed.
 	 */
 	if (!PE_CHK_FLAG(port, PE_FLAGS_VDM_REQUEST_CONTINUE))
-		pe[port].tx_type = TCPC_TX_INVALID;
+		pe[port].tx_type = TCPCI_MSG_INVALID;
 }
 
 /**
@@ -6004,7 +6006,7 @@ static void pe_vdm_response_entry(int port)
 	tx_payload[0] &= ~VDO_SVDM_VERS(0x3);
 
 	/* Add SVDM structured version being used */
-	tx_payload[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPC_TX_SOP));
+	tx_payload[0] |= VDO_SVDM_VERS(pd_get_vdo_ver(port, TCPCI_MSG_SOP));
 
 	/* Use VDM command to select the response handler function */
 	switch (vdo_cmd) {
@@ -6050,7 +6052,7 @@ static void pe_vdm_response_entry(int port)
 	 * reply to any SVDM command with a NAK. If the SVDM was an Attention
 	 * command, it does not have a response, and exits the function above.
 	 */
-	if (func && (prl_get_rev(port, TCPC_TX_SOP) != PD_REV20 ||
+	if (func && (prl_get_rev(port, TCPCI_MSG_SOP) != PD_REV20 ||
 		     pe[port].data_role == PD_ROLE_UFP)) {
 		/*
 		 * Execute SVDM response function selected above and set the
@@ -6083,7 +6085,7 @@ static void pe_vdm_response_entry(int port)
 		 * ECNs 2020-12-10 Table 6-64 Response to an incoming
 		 * VDM or TD.PD.VNDI3.E3 VDM Identity steps)
 		 */
-		if (prl_get_rev(port, TCPC_TX_SOP) == PD_REV30) {
+		if (prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV30) {
 			set_state_pe(port, PE_SEND_NOT_SUPPORTED);
 			return;
 		}
@@ -6093,7 +6095,7 @@ static void pe_vdm_response_entry(int port)
 
 	/* Send response message. Note len is in bytes, not VDO objects */
 	tx_emsg[port].len = (vdo_len * sizeof(uint32_t));
-	send_data_msg(port, TCPC_TX_SOP, PD_DATA_VENDOR_DEF);
+	send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_VENDOR_DEF);
 }
 
 static void pe_vdm_response_run(int port)
@@ -6143,14 +6145,14 @@ static void pe_enter_usb_entry(int port)
 		return;
 	}
 
-	if ((pe[port].tx_type == TCPC_TX_SOP_PRIME ||
-	     pe[port].tx_type == TCPC_TX_SOP_PRIME_PRIME) &&
+	if ((pe[port].tx_type == TCPCI_MSG_SOP_PRIME ||
+	     pe[port].tx_type == TCPCI_MSG_SOP_PRIME_PRIME) &&
 	     !tc_is_vconn_src(port)) {
 		if (port_try_vconn_swap(port))
 			return;
 	}
 
-	pe[port].tx_type = TCPC_TX_SOP;
+	pe[port].tx_type = TCPCI_MSG_SOP;
 	usb4_payload = enter_usb_setup_next_msg(port, &pe[port].tx_type);
 
 	if (!usb4_payload) {
@@ -6260,18 +6262,18 @@ static void pe_vcs_evaluate_swap_entry(int port)
 	/* DPM rejects a VCONN Swap and port is not a VCONN source*/
 	if (!tc_check_vconn_swap(port) && tc_is_vconn_src(port) < 1) {
 		/* NOTE: PE_VCS_Reject_Swap State embedded here */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_REJECT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_REJECT);
 	}
 	/* Port is not ready to perform a VCONN swap */
 	else if (tc_is_vconn_src(port) < 0) {
 		/* NOTE: PE_VCS_Reject_Swap State embedded here */
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_WAIT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_WAIT);
 	}
 	/* Port is ready to perform a VCONN swap */
 	else {
 		/* NOTE: PE_VCS_Accept_Swap State embedded here */
 		PE_SET_FLAG(port, PE_FLAGS_ACCEPT);
-		send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+		send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	}
 }
 
@@ -6311,7 +6313,7 @@ static void pe_vcs_send_swap_entry(int port)
 	print_current_state(port);
 
 	/* Send a VCONN_Swap Message */
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_VCONN_SWAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_VCONN_SWAP);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -6319,7 +6321,7 @@ static void pe_vcs_send_swap_run(int port)
 {
 	uint8_t type;
 	uint8_t cnt;
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 	enum pe_msg_check msg_check;
 
 	/*
@@ -6565,7 +6567,7 @@ static void pe_vcs_send_ps_rdy_swap_entry(int port)
 
 	/* Check for any interruptions to this non-interruptible AMS */
 	if (PE_CHK_FLAG(port, PE_FLAGS_MSG_RECEIVED)) {
-		enum tcpm_sop_type sop =
+		enum tcpci_msg_type sop =
 				PD_HEADER_GET_SOP(rx_emsg[port].header);
 
 		PE_CLR_FLAG(port, PE_FLAGS_MSG_RECEIVED);
@@ -6576,7 +6578,7 @@ static void pe_vcs_send_ps_rdy_swap_entry(int port)
 	}
 
 	/* Send a PS_RDY Message */
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_PS_RDY);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_PS_RDY);
 }
 
 static void pe_vcs_send_ps_rdy_swap_run(int port)
@@ -6606,7 +6608,7 @@ static void pe_vcs_send_ps_rdy_swap_run(int port)
 	if (PE_CHK_FLAG(port, PE_FLAGS_PROTOCOL_ERROR)) {
 		PE_CLR_FLAG(port, PE_FLAGS_PROTOCOL_ERROR);
 		/* PS_RDY didn't send, soft reset */
-		pe_send_soft_reset(port, TCPC_TX_SOP);
+		pe_send_soft_reset(port, TCPCI_MSG_SOP);
 	}
 }
 
@@ -6681,7 +6683,7 @@ static void pe_vcs_cbl_send_soft_reset_entry(int port)
 		return;
 	}
 
-	send_ctrl_msg(port, TCPC_TX_SOP_PRIME, PD_CTRL_SOFT_RESET);
+	send_ctrl_msg(port, TCPCI_MSG_SOP_PRIME, PD_CTRL_SOFT_RESET);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -6705,8 +6707,8 @@ static void pe_vcs_cbl_send_soft_reset_run(int port)
 		 * PD Spec Table 6-2: Revision Interoperability during an
 		 * Explicit Contract
 		 */
-		if (prl_get_rev(port, TCPC_TX_SOP) != PD_REV20)
-			prl_set_rev(port, TCPC_TX_SOP_PRIME,
+		if (prl_get_rev(port, TCPCI_MSG_SOP) != PD_REV20)
+			prl_set_rev(port, TCPCI_MSG_SOP_PRIME,
 					PD_HEADER_REV(rx_emsg[port].header));
 	}
 
@@ -6752,7 +6754,7 @@ static void pe_dr_get_sink_cap_entry(int port)
 	print_current_state(port);
 
 	/* Send a Get Sink Cap Message */
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_GET_SINK_CAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_GET_SINK_CAP);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -6762,7 +6764,7 @@ static void pe_dr_get_sink_cap_run(int port)
 	int cnt;
 	int ext;
 	enum pe_msg_check msg_check;
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 
 	/*
 	 * Check the state of the message sent
@@ -6787,7 +6789,7 @@ static void pe_dr_get_sink_cap_run(int port)
 		ext = PD_HEADER_EXT(rx_emsg[port].header);
 		sop = PD_HEADER_GET_SOP(rx_emsg[port].header);
 
-		if (ext == 0 && sop == TCPC_TX_SOP) {
+		if (ext == 0 && sop == TCPCI_MSG_SOP) {
 			if ((cnt > 0) && (type == PD_DATA_SINK_CAP)) {
 				uint32_t *payload =
 					(uint32_t *)rx_emsg[port].buf;
@@ -6851,7 +6853,7 @@ static void pe_dr_snk_give_source_cap_run(int port)
 		PE_CLR_FLAG(port, PE_FLAGS_TX_COMPLETE);
 		set_state_pe(port, PE_SNK_READY);
 	} else if (PE_CHK_FLAG(port, PE_FLAGS_MSG_DISCARDED)) {
-		pe_send_soft_reset(port, TCPC_TX_SOP);
+		pe_send_soft_reset(port, TCPCI_MSG_SOP);
 	}
 }
 
@@ -6864,7 +6866,7 @@ static void pe_dr_src_get_source_cap_entry(int port)
 
 	/* Send a Get_Source_Cap Message */
 	tx_emsg[port].len = 0;
-	send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP);
+	send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP);
 	pe_sender_response_msg_entry(port);
 }
 
@@ -6988,8 +6990,8 @@ void pd_dfp_discovery_init(int port)
 	PE_CLR_FLAG(port, PE_FLAGS_VDM_SETUP_DONE |
 			  PE_FLAGS_MODAL_OPERATION);
 
-	atomic_or(&task_access[port][TCPC_TX_SOP], BIT(task_get_current()));
-	atomic_or(&task_access[port][TCPC_TX_SOP_PRIME],
+	atomic_or(&task_access[port][TCPCI_MSG_SOP], BIT(task_get_current()));
+	atomic_or(&task_access[port][TCPCI_MSG_SOP_PRIME],
 		  BIT(task_get_current()));
 
 	memset(pe[port].discovery, 0, sizeof(pe[port].discovery));
@@ -7010,7 +7012,7 @@ void pd_dfp_discovery_init(int port)
 }
 
 __maybe_unused void pd_discovery_access_clear(int port,
-			enum tcpm_sop_type type)
+			enum tcpci_msg_type type)
 {
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		assert(0);
@@ -7019,7 +7021,7 @@ __maybe_unused void pd_discovery_access_clear(int port,
 }
 
 __maybe_unused bool pd_discovery_access_validate(int port,
-			enum tcpm_sop_type type)
+			enum tcpci_msg_type type)
 {
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		assert(0);
@@ -7028,7 +7030,7 @@ __maybe_unused bool pd_discovery_access_validate(int port,
 }
 
 __maybe_unused struct pd_discovery *pd_get_am_discovery(int port,
-			enum tcpm_sop_type type)
+			enum tcpci_msg_type type)
 {
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		assert(0);
@@ -7039,7 +7041,7 @@ __maybe_unused struct pd_discovery *pd_get_am_discovery(int port,
 }
 
 __maybe_unused struct partner_active_modes *pd_get_partner_active_modes(
-			int port, enum tcpm_sop_type type)
+			int port, enum tcpci_msg_type type)
 {
 	if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
 		assert(0);
diff --git a/common/usbc/usb_prl_sm.c b/common/usbc/usb_prl_sm.c
index 0fcc9ba663..a58a579775 100644
--- a/common/usbc/usb_prl_sm.c
+++ b/common/usbc/usb_prl_sm.c
@@ -312,7 +312,7 @@ static struct tx_chunked {
 /* Message Reception State Machine Object */
 static struct protocol_layer_rx {
 	/* received message type */
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 	/* message ids for all valid port partners */
 	int msg_id[NUM_SOP_STAR_TYPES];
 } prl_rx[CONFIG_USB_PD_PORT_MAX_COUNT];
@@ -324,7 +324,7 @@ static struct protocol_layer_tx {
 	/* state machine flags */
 	uint32_t flags;
 	/* last message type we transmitted */
-	enum tcpm_sop_type last_xmit_type;
+	enum tcpci_msg_type last_xmit_type;
 	/* message id counters for all 6 port partners */
 	uint32_t msg_id_counter[NUM_SOP_STAR_TYPES];
 	/* transmit status */
@@ -344,7 +344,7 @@ static struct pd_message {
 	/* message status flags */
 	uint32_t flags;
 	/* SOP* */
-	enum tcpm_sop_type xmit_type;
+	enum tcpci_msg_type xmit_type;
 	/* type of message */
 	uint8_t msg_type;
 	/* PD revision */
@@ -566,7 +566,7 @@ static void prl_init(int port)
 	prl_tx[port].flags = 0;
 	if (IS_ENABLED(CONFIG_USB_PD_REV30))
 		typec_select_src_collision_rp(port, SINK_TX_OK);
-	prl_tx[port].last_xmit_type = TCPC_TX_SOP;
+	prl_tx[port].last_xmit_type = TCPCI_MSG_SOP;
 	prl_tx[port].xmit_status = TCPC_TX_UNSET;
 
 	if (IS_ENABLED(CONFIG_USB_PD_REV30)) {
@@ -627,7 +627,7 @@ void prl_hard_reset_complete(int port)
 }
 
 void prl_send_ctrl_msg(int port,
-		      enum tcpm_sop_type type,
+		      enum tcpci_msg_type type,
 		      enum pd_ctrl_msg_type msg)
 {
 	pdmsg[port].xmit_type = type;
@@ -647,7 +647,7 @@ void prl_send_ctrl_msg(int port,
 }
 
 void prl_send_data_msg(int port,
-		      enum tcpm_sop_type type,
+		      enum tcpci_msg_type type,
 		      enum pd_data_msg_type msg)
 {
 	pdmsg[port].xmit_type = type;
@@ -667,7 +667,7 @@ void prl_send_data_msg(int port,
 
 #ifdef CONFIG_USB_PD_EXTENDED_MESSAGES
 void prl_send_ext_data_msg(int port,
-			  enum tcpm_sop_type type,
+			  enum tcpci_msg_type type,
 			  enum pd_ext_msg_type msg)
 {
 	pdmsg[port].xmit_type = type;
@@ -686,11 +686,11 @@ void prl_set_default_pd_revision(int port)
 	 * partner doesn't support this revision, the Protocol Engine will
 	 * lower this value to the revision supported by the partner.
 	 */
-	pdmsg[port].rev[TCPC_TX_SOP] = PD_REVISION;
-	pdmsg[port].rev[TCPC_TX_SOP_PRIME] = PD_REVISION;
-	pdmsg[port].rev[TCPC_TX_SOP_PRIME_PRIME] = PD_REVISION;
-	pdmsg[port].rev[TCPC_TX_SOP_DEBUG_PRIME] = PD_REVISION;
-	pdmsg[port].rev[TCPC_TX_SOP_DEBUG_PRIME_PRIME] = PD_REVISION;
+	pdmsg[port].rev[TCPCI_MSG_SOP] = PD_REVISION;
+	pdmsg[port].rev[TCPCI_MSG_SOP_PRIME] = PD_REVISION;
+	pdmsg[port].rev[TCPCI_MSG_SOP_PRIME_PRIME] = PD_REVISION;
+	pdmsg[port].rev[TCPCI_MSG_SOP_DEBUG_PRIME] = PD_REVISION;
+	pdmsg[port].rev[TCPCI_MSG_SOP_DEBUG_PRIME_PRIME] = PD_REVISION;
 }
 
 void prl_reset_soft(int port)
@@ -772,7 +772,7 @@ void prl_run(int port, int evt, int en)
 	}
 }
 
-void prl_set_rev(int port, enum tcpm_sop_type type,
+void prl_set_rev(int port, enum tcpci_msg_type type,
 						enum pd_rev_type rev)
 {
 	/* We only store revisions for SOP* types. */
@@ -781,7 +781,7 @@ void prl_set_rev(int port, enum tcpm_sop_type type,
 	pdmsg[port].rev[type] = rev;
 }
 
-enum pd_rev_type prl_get_rev(int port, enum tcpm_sop_type type)
+enum pd_rev_type prl_get_rev(int port, enum tcpci_msg_type type)
 {
 	/* We only store revisions for SOP* types. */
 	ASSERT(type < NUM_SOP_STAR_TYPES);
@@ -838,7 +838,7 @@ static __maybe_unused int pdmsg_xmit_type_is_rev30(const int port)
 static bool is_sop_rev30(const int port)
 {
 	return IS_ENABLED(CONFIG_USB_PD_REV30) &&
-	       prl_get_rev(port, TCPC_TX_SOP) == PD_REV30;
+	       prl_get_rev(port, TCPCI_MSG_SOP) == PD_REV30;
 }
 
 /* Common Protocol Layer Message Transmission */
@@ -1053,7 +1053,7 @@ static void prl_tx_layer_reset_for_transmit_run(const int port)
 
 static uint32_t get_sop_star_header(const int port)
 {
-	const int is_sop_packet = pdmsg[port].xmit_type == TCPC_TX_SOP;
+	const int is_sop_packet = pdmsg[port].xmit_type == TCPCI_MSG_SOP;
 	int ext;
 
 #ifdef CONFIG_USB_PD_EXTENDED_MESSAGES
@@ -1280,7 +1280,7 @@ void prl_hr_send_msg_to_phy(const int port)
 	/* Header is not used for hard reset */
 	const uint32_t header = 0;
 
-	pdmsg[port].xmit_type = TCPC_TX_HARD_RESET;
+	pdmsg[port].xmit_type = TCPCI_MSG_TX_HARD_RESET;
 
 	/*
 	 * These flags could be set if this function is called before the
@@ -2191,7 +2191,7 @@ static void prl_rx_wait_for_phy_message(const int port, int evt)
 	 */
 	if (!IS_ENABLED(CONFIG_USB_CTVPD) &&
 	    !IS_ENABLED(CONFIG_USB_VPD) &&
-	    PD_HEADER_GET_SOP(header) != TCPC_TX_SOP &&
+	    PD_HEADER_GET_SOP(header) != TCPCI_MSG_SOP &&
 	    PD_HEADER_PROLE(header) == PD_PLUG_FROM_DFP_UFP)
 		return;
 
diff --git a/common/usbc/usb_tc_drp_acc_trysrc_sm.c b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
index 26fce67011..041c3c7187 100644
--- a/common/usbc/usb_tc_drp_acc_trysrc_sm.c
+++ b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
@@ -531,7 +531,7 @@ void pd_set_src_caps(int port, int cnt, uint32_t *src_caps)
 {
 }
 
-int pd_get_rev(int port, enum tcpm_sop_type type)
+int pd_get_rev(int port, enum tcpci_msg_type type)
 {
 	return PD_REV30;
 }
@@ -708,9 +708,9 @@ static void tc_set_modes_exit(int port)
 {
 	if (IS_ENABLED(CONFIG_USB_PE_SM) &&
 			IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP)) {
-		pd_dfp_exit_mode(port, TCPC_TX_SOP, 0, 0);
-		pd_dfp_exit_mode(port, TCPC_TX_SOP_PRIME, 0, 0);
-		pd_dfp_exit_mode(port, TCPC_TX_SOP_PRIME_PRIME, 0, 0);
+		pd_dfp_exit_mode(port, TCPCI_MSG_SOP, 0, 0);
+		pd_dfp_exit_mode(port, TCPCI_MSG_SOP_PRIME, 0, 0);
+		pd_dfp_exit_mode(port, TCPCI_MSG_SOP_PRIME_PRIME, 0, 0);
 	}
 }
 
@@ -3930,7 +3930,7 @@ static void pd_chipset_reset(void)
 		return;
 
 	for (i = 0; i < board_get_usb_pd_port_count(); i++) {
-		enum tcpm_sop_type tx;
+		enum tcpci_msg_type tx;
 
 		/* Do not notify the AP of irrelevant past Hard Resets. */
 		pd_clear_events(i, PD_STATUS_EVENT_HARD_RESET);
@@ -3939,11 +3939,11 @@ static void pd_chipset_reset(void)
 		 * Re-set events for SOP and SOP' discovery complete so the
 		 * kernel knows to consume discovery information for them.
 		 */
-		for (tx = TCPC_TX_SOP; tx <= TCPC_TX_SOP_PRIME; tx++) {
+		for (tx = TCPCI_MSG_SOP; tx <= TCPCI_MSG_SOP_PRIME; tx++) {
 			if (pd_get_identity_discovery(i, tx) != PD_DISC_NEEDED
 			    && pd_get_svids_discovery(i, tx) != PD_DISC_NEEDED
 			    && pd_get_modes_discovery(i, tx) != PD_DISC_NEEDED)
-				pd_notify_event(i, tx == TCPC_TX_SOP ?
+				pd_notify_event(i, tx == TCPCI_MSG_SOP ?
 					PD_STATUS_EVENT_SOP_DISC_DONE :
 					PD_STATUS_EVENT_SOP_PRIME_DISC_DONE);
 		}
diff --git a/driver/retimer/bb_retimer.c b/driver/retimer/bb_retimer.c
index 43c67a95e1..75da6c653d 100644
--- a/driver/retimer/bb_retimer.c
+++ b/driver/retimer/bb_retimer.c
@@ -156,7 +156,7 @@ static void retimer_set_state_dfp(int port, mux_state_t mux_state,
 				  uint32_t *set_retimer_con)
 {
 	union tbt_mode_resp_cable cable_resp = {
-		.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP_PRIME) };
+		.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP_PRIME) };
 	union tbt_mode_resp_device dev_resp;
 	enum idh_ptype cable_type = get_usb_pd_cable_type(port);
 
@@ -188,7 +188,7 @@ static void retimer_set_state_dfp(int port, mux_state_t mux_state,
 
 	if (mux_state & USB_PD_MUX_TBT_COMPAT_ENABLED ||
 	    mux_state & USB_PD_MUX_USB4_ENABLED) {
-		dev_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPC_TX_SOP);
+		dev_resp.raw_value = pd_get_tbt_mode_vdo(port, TCPCI_MSG_SOP);
 
 		/*
 		 * Bit 2: RE_TIMER_DRIVER
diff --git a/driver/retimer/kb800x.c b/driver/retimer/kb800x.c
index ad615a3532..48e47404c2 100644
--- a/driver/retimer/kb800x.c
+++ b/driver/retimer/kb800x.c
@@ -340,7 +340,7 @@ static int kb800x_cio_init(const struct usb_mux *me, mux_state_t mux_state)
 	enum idh_ptype cable_type = get_usb_pd_cable_type(me->usb_port);
 	union tbt_mode_resp_cable cable_resp = {
 		.raw_value =
-			pd_get_tbt_mode_vdo(me->usb_port, TCPC_TX_SOP_PRIME)
+			pd_get_tbt_mode_vdo(me->usb_port, TCPCI_MSG_SOP_PRIME)
 	};
 
 	rv = kb800x_bulk_write(me, cio_init_addresses, cio_init_values,
diff --git a/driver/tcpm/anx74xx.c b/driver/tcpm/anx74xx.c
index 90834bff2e..567005920e 100644
--- a/driver/tcpm/anx74xx.c
+++ b/driver/tcpm/anx74xx.c
@@ -912,7 +912,7 @@ static int anx74xx_tcpm_get_message_raw(int port, uint32_t *payload, int *head)
 	return anx74xx_read_pd_obj(port, (uint8_t *)payload, len);
 }
 
-static int anx74xx_tcpm_transmit(int port, enum tcpm_sop_type type,
+static int anx74xx_tcpm_transmit(int port, enum tcpci_msg_type type,
 		  uint16_t header,
 		  const uint32_t *data)
 {
@@ -921,14 +921,14 @@ static int anx74xx_tcpm_transmit(int port, enum tcpm_sop_type type,
 
 	switch (type) {
 	/* ANX is aware of type */
-	case TCPC_TX_SOP:
-	case TCPC_TX_SOP_PRIME:
-	case TCPC_TX_SOP_PRIME_PRIME:
+	case TCPCI_MSG_SOP:
+	case TCPCI_MSG_SOP_PRIME:
+	case TCPCI_MSG_SOP_PRIME_PRIME:
 		len = PD_HEADER_CNT(header) * 4 + 2;
 		ret = anx74xx_send_message(port, header,
 						  data, type, len);
 		break;
-	case TCPC_TX_HARD_RESET:
+	case TCPCI_MSG_TX_HARD_RESET:
 	/* Request HARD RESET */
 		tcpc_read(port, ANX74XX_REG_TX_CTRL_1, &reg);
 		reg |= ANX74XX_REG_TX_HARD_RESET_REQ;
@@ -936,13 +936,13 @@ static int anx74xx_tcpm_transmit(int port, enum tcpm_sop_type type,
 	/*After Hard Reset, TCPM shall disable goodCRC*/
 		anx74xx_tcpm_set_auto_good_crc(port, 0);
 		break;
-	case TCPC_TX_CABLE_RESET:
+	case TCPCI_MSG_CABLE_RESET:
 	/* Request CABLE RESET */
 		tcpc_read(port, ANX74XX_REG_TX_CTRL_1, &reg);
 		reg |= ANX74XX_REG_TX_CABLE_RESET_REQ;
 		ret = tcpc_write(port, ANX74XX_REG_TX_CTRL_1, reg);
 		break;
-	case TCPC_TX_BIST_MODE_2:
+	case TCPCI_MSG_TX_BIST_MODE_2:
 	/* Request BIST MODE 2 */
 		reg = ANX74XX_REG_TX_BIST_START
 				| ANX74XX_REG_TX_BIXT_FOREVER | (0x02 << 4);
@@ -1028,9 +1028,9 @@ void anx74xx_tcpc_alert(int port)
 
 #ifdef CONFIG_USB_PD_DECODE_SOP
 	if (reg & ANX74XX_REG_EXT_SOP)
-		msg_sop[port] = TCPC_TX_SOP;
+		msg_sop[port] = TCPCI_MSG_SOP;
 	else if (reg & ANX74XX_REG_EXT_SOP_PRIME)
-		msg_sop[port] = TCPC_TX_SOP_PRIME;
+		msg_sop[port] = TCPCI_MSG_SOP_PRIME;
 #endif
 
 	/* Check for Hard Reset done bit */
@@ -1045,7 +1045,7 @@ void anx74xx_tcpc_alert(int port)
 
 #ifdef CONFIG_USB_PD_DECODE_SOP
 	if (reg & ANX74XX_REG_EXT_SOP_PRIME_PRIME)
-		msg_sop[port] = TCPC_TX_SOP_PRIME_PRIME;
+		msg_sop[port] = TCPCI_MSG_SOP_PRIME_PRIME;
 #endif
 
 	if (reg & ANX74XX_REG_EXT_HARD_RST) {
diff --git a/driver/tcpm/fusb302.c b/driver/tcpm/fusb302.c
index 13df515041..0098906d32 100644
--- a/driver/tcpm/fusb302.c
+++ b/driver/tcpm/fusb302.c
@@ -836,16 +836,16 @@ static int fusb302_tcpm_get_message_raw(int port, uint32_t *payload, int *head)
 			return EC_ERROR_UNKNOWN;
 
 		if (reg & TCPC_REG_STATUS1_RXSOP1)
-			*head |= PD_HEADER_SOP(TCPC_TX_SOP_PRIME);
+			*head |= PD_HEADER_SOP(TCPCI_MSG_SOP_PRIME);
 		else if (reg & TCPC_REG_STATUS1_RXSOP2)
-			*head |= PD_HEADER_SOP(TCPC_TX_SOP_PRIME_PRIME);
+			*head |= PD_HEADER_SOP(TCPCI_MSG_SOP_PRIME_PRIME);
 	}
 #endif
 
 	return rv;
 }
 
-static int fusb302_tcpm_transmit(int port, enum tcpm_sop_type type,
+static int fusb302_tcpm_transmit(int port, enum tcpci_msg_type type,
 				 uint16_t header, const uint32_t *data)
 {
 	/*
@@ -871,7 +871,7 @@ static int fusb302_tcpm_transmit(int port, enum tcpm_sop_type type,
 	fusb302_flush_tx_fifo(port);
 
 	switch (type) {
-	case TCPC_TX_SOP:
+	case TCPCI_MSG_SOP:
 
 		/* put register address first for of burst tcpc write */
 		buf[buf_pos++] = TCPC_REG_FIFOS;
@@ -883,7 +883,7 @@ static int fusb302_tcpm_transmit(int port, enum tcpm_sop_type type,
 		buf[buf_pos++] = FUSB302_TKN_SYNC2;
 
 		return fusb302_send_message(port, header, data, buf, buf_pos);
-	case TCPC_TX_SOP_PRIME:
+	case TCPCI_MSG_SOP_PRIME:
 
 		/* put register address first for of burst tcpc write */
 		buf[buf_pos++] = TCPC_REG_FIFOS;
@@ -895,7 +895,7 @@ static int fusb302_tcpm_transmit(int port, enum tcpm_sop_type type,
 		buf[buf_pos++] = FUSB302_TKN_SYNC3;
 
 		return fusb302_send_message(port, header, data, buf, buf_pos);
-	case TCPC_TX_SOP_PRIME_PRIME:
+	case TCPCI_MSG_SOP_PRIME_PRIME:
 
 		/* put register address first for of burst tcpc write */
 		buf[buf_pos++] = TCPC_REG_FIFOS;
@@ -907,14 +907,14 @@ static int fusb302_tcpm_transmit(int port, enum tcpm_sop_type type,
 		buf[buf_pos++] = FUSB302_TKN_SYNC3;
 
 		return fusb302_send_message(port, header, data, buf, buf_pos);
-	case TCPC_TX_HARD_RESET:
+	case TCPCI_MSG_TX_HARD_RESET:
 		/* Simply hit the SEND_HARD_RESET bit */
 		tcpc_read(port, TCPC_REG_CONTROL3, &reg);
 		reg |= TCPC_REG_CONTROL3_SEND_HARDRESET;
 		tcpc_write(port, TCPC_REG_CONTROL3, reg);
 
 		break;
-	case TCPC_TX_BIST_MODE_2:
+	case TCPCI_MSG_TX_BIST_MODE_2:
 		/* Hit the BIST_MODE2 bit and start TX */
 		tcpc_read(port, TCPC_REG_CONTROL1, &reg);
 		reg |= TCPC_REG_CONTROL1_BIST_MODE2;
diff --git a/driver/tcpm/it83xx.c b/driver/tcpm/it83xx.c
index 6c9092613b..964d5f09d2 100644
--- a/driver/tcpm/it83xx.c
+++ b/driver/tcpm/it83xx.c
@@ -178,7 +178,7 @@ static int it83xx_tcpm_get_message_raw(int port, uint32_t *buf, int *head)
 
 static enum tcpc_transmit_complete it83xx_tx_data(
 	enum usbpd_port port,
-	enum tcpm_sop_type type,
+	enum tcpci_msg_type type,
 	uint16_t header,
 	const uint32_t *buf)
 {
@@ -200,7 +200,7 @@ static enum tcpc_transmit_complete it83xx_tx_data(
 	IT83XX_USBPD_MTSR1(port) =
 		(IT83XX_USBPD_MTSR1(port) & ~0x70) | ((type & 0x7) << 4);
 	/* bit7: transmit message is send to cable or not */
-	if (TCPC_TX_SOP == type)
+	if (type == TCPCI_MSG_SOP)
 		IT83XX_USBPD_MTSR0(port) &= ~USBPD_REG_MASK_CABLE_ENABLE;
 	else
 		IT83XX_USBPD_MTSR0(port) |= USBPD_REG_MASK_CABLE_ENABLE;
@@ -247,9 +247,9 @@ static enum tcpc_transmit_complete it83xx_tx_data(
 }
 
 static enum tcpc_transmit_complete it83xx_send_hw_reset(enum usbpd_port port,
-				enum tcpm_sop_type reset_type)
+				enum tcpci_msg_type reset_type)
 {
-	if (reset_type == TCPC_TX_CABLE_RESET)
+	if (reset_type == TCPCI_MSG_CABLE_RESET)
 		IT83XX_USBPD_MTSR0(port) |= USBPD_REG_MASK_CABLE_ENABLE;
 	else
 		IT83XX_USBPD_MTSR0(port) &= ~USBPD_REG_MASK_CABLE_ENABLE;
@@ -678,29 +678,29 @@ static int it83xx_tcpm_set_rx_enable(int port, int enable)
 }
 
 static int it83xx_tcpm_transmit(int port,
-			enum tcpm_sop_type type,
+			enum tcpci_msg_type type,
 			uint16_t header,
 			const uint32_t *data)
 {
 	int status = TCPC_TX_COMPLETE_FAILED;
 
 	switch (type) {
-	case TCPC_TX_SOP:
-	case TCPC_TX_SOP_PRIME:
-	case TCPC_TX_SOP_PRIME_PRIME:
-	case TCPC_TX_SOP_DEBUG_PRIME:
-	case TCPC_TX_SOP_DEBUG_PRIME_PRIME:
+	case TCPCI_MSG_SOP:
+	case TCPCI_MSG_SOP_PRIME:
+	case TCPCI_MSG_SOP_PRIME_PRIME:
+	case TCPCI_MSG_SOP_DEBUG_PRIME:
+	case TCPCI_MSG_SOP_DEBUG_PRIME_PRIME:
 		status = it83xx_tx_data(port,
 					type,
 					header,
 					data);
 		break;
-	case TCPC_TX_BIST_MODE_2:
+	case TCPCI_MSG_TX_BIST_MODE_2:
 		it83xx_send_bist_mode2_pattern(port);
 		status = TCPC_TX_COMPLETE_SUCCESS;
 		break;
-	case TCPC_TX_HARD_RESET:
-	case TCPC_TX_CABLE_RESET:
+	case TCPCI_MSG_TX_HARD_RESET:
+	case TCPCI_MSG_CABLE_RESET:
 		status = it83xx_send_hw_reset(port, type);
 		break;
 	default:
diff --git a/driver/tcpm/it8xxx2.c b/driver/tcpm/it8xxx2.c
index bdf7de0b9f..e3227a3ed8 100644
--- a/driver/tcpm/it8xxx2.c
+++ b/driver/tcpm/it8xxx2.c
@@ -170,7 +170,7 @@ static int it8xxx2_tcpm_get_message_raw(int port, uint32_t *buf, int *head)
 	 * BIT[6:4] SOP type of Rx message
 	 * 000b=SOP, 001b=SOP', 010b=SOP", 011b=Debug SOP', 100b=Debug SOP"
 	 * 101b=HRDRST, 110b=CBLRST
-	 * 000b~100b is aligned to enum tcpm_sop_type.
+	 * 000b~100b is aligned to enum tcpci_msg_type.
 	 *
 	 */
 	if (IS_ENABLED(CONFIG_USB_PD_DECODE_SOP))
@@ -197,7 +197,7 @@ void it8xxx2_get_tx_error_status(enum usbpd_port port)
 }
 
 static enum tcpc_transmit_complete it8xxx2_tx_data(enum usbpd_port port,
-						   enum tcpm_sop_type type,
+						   enum tcpci_msg_type type,
 						   uint16_t header,
 						   const uint32_t *buf)
 {
@@ -595,31 +595,31 @@ static int it8xxx2_tcpm_set_rx_enable(int port, int enable)
 }
 
 static int it8xxx2_tcpm_transmit(int port,
-				 enum tcpm_sop_type type,
+				 enum tcpci_msg_type type,
 				 uint16_t header,
 				 const uint32_t *data)
 {
 	int status = TCPC_TX_COMPLETE_FAILED;
 
 	switch (type) {
-	case TCPC_TX_SOP:
-	case TCPC_TX_SOP_PRIME:
-	case TCPC_TX_SOP_PRIME_PRIME:
-	case TCPC_TX_SOP_DEBUG_PRIME:
-	case TCPC_TX_SOP_DEBUG_PRIME_PRIME:
+	case TCPCI_MSG_SOP:
+	case TCPCI_MSG_SOP_PRIME:
+	case TCPCI_MSG_SOP_PRIME_PRIME:
+	case TCPCI_MSG_SOP_DEBUG_PRIME:
+	case TCPCI_MSG_SOP_DEBUG_PRIME_PRIME:
 		status = it8xxx2_tx_data(port,
 					 type,
 					 header,
 					 data);
 		break;
-	case TCPC_TX_BIST_MODE_2:
+	case TCPCI_MSG_TX_BIST_MODE_2:
 		it8xxx2_send_bist_mode2_pattern(port);
 		status = TCPC_TX_COMPLETE_SUCCESS;
 		break;
-	case TCPC_TX_HARD_RESET:
+	case TCPCI_MSG_TX_HARD_RESET:
 		status = it8xxx2_send_hw_reset(port);
 		break;
-	case TCPC_TX_CABLE_RESET:
+	case TCPCI_MSG_CABLE_RESET:
 		status = it8xxx2_send_cable_reset(port);
 		break;
 	default:
diff --git a/driver/tcpm/ps8xxx.c b/driver/tcpm/ps8xxx.c
index ade607ac09..1742f19aeb 100644
--- a/driver/tcpm/ps8xxx.c
+++ b/driver/tcpm/ps8xxx.c
@@ -426,15 +426,15 @@ static int ps8xxx_tcpc_bist_mode_2(int port)
 	rv |= tcpc_write(port, PS8XXX_REG_BIST_CONT_MODE_CTR, 0);
 
 	/* Start BIST MODE 2 */
-	rv |= tcpc_write(port, TCPC_REG_TRANSMIT, TCPC_TX_BIST_MODE_2);
+	rv |= tcpc_write(port, TCPC_REG_TRANSMIT, TCPCI_MSG_TX_BIST_MODE_2);
 
 	return rv;
 }
 
-static int ps8xxx_tcpm_transmit(int port, enum tcpm_sop_type type,
+static int ps8xxx_tcpm_transmit(int port, enum tcpci_msg_type type,
 			uint16_t header, const uint32_t *data)
 {
-	if (type == TCPC_TX_BIST_MODE_2)
+	if (type == TCPCI_MSG_TX_BIST_MODE_2)
 		return ps8xxx_tcpc_bist_mode_2(port);
 	else
 		return tcpci_tcpm_transmit(port, type, header, data);
diff --git a/driver/tcpm/stm32gx.c b/driver/tcpm/stm32gx.c
index 4b33f32209..359c7c1108 100644
--- a/driver/tcpm/stm32gx.c
+++ b/driver/tcpm/stm32gx.c
@@ -103,7 +103,7 @@ static int stm32gx_tcpm_set_rx_enable(int port, int enable)
 }
 
 static int stm32gx_tcpm_transmit(int port,
-			enum tcpm_sop_type type,
+			enum tcpci_msg_type type,
 			uint16_t header,
 			const uint32_t *data)
 {
diff --git a/driver/tcpm/stub.c b/driver/tcpm/stub.c
index 48c0c51da9..863a88c044 100644
--- a/driver/tcpm/stub.c
+++ b/driver/tcpm/stub.c
@@ -113,7 +113,7 @@ void tcpm_clear_pending_messages(int port)
 	rx_buf_clear(port);
 }
 
-int tcpm_transmit(int port, enum tcpm_sop_type type, uint16_t header,
+int tcpm_transmit(int port, enum tcpci_msg_type type, uint16_t header,
 		  const uint32_t *data)
 {
 	return tcpc_transmit(port, type, header, data);
diff --git a/driver/tcpm/tcpci.c b/driver/tcpm/tcpci.c
index 6674b67c02..282718bae2 100644
--- a/driver/tcpm/tcpci.c
+++ b/driver/tcpm/tcpci.c
@@ -944,7 +944,7 @@ void tcpm_clear_pending_messages(int port)
 	q->tail = q->head;
 }
 
-int tcpci_tcpm_transmit(int port, enum tcpm_sop_type type,
+int tcpci_tcpm_transmit(int port, enum tcpci_msg_type type,
 			uint16_t header, const uint32_t *data)
 {
 	int reg = TCPC_REG_TX_DATA;
diff --git a/fuzz/usb_pd_fuzz.c b/fuzz/usb_pd_fuzz.c
index 12fe4cc9f1..64eb0913a6 100644
--- a/fuzz/usb_pd_fuzz.c
+++ b/fuzz/usb_pd_fuzz.c
@@ -45,7 +45,7 @@ static int mock_tcpm_set_vconn(int port, int enable) { return EC_SUCCESS; }
 static int mock_tcpm_set_msg_header(int port,
 			int power_role, int data_role) { return EC_SUCCESS; }
 static int mock_tcpm_set_rx_enable(int port, int enable) { return EC_SUCCESS; }
-static int mock_tcpm_transmit(int port, enum tcpm_sop_type type,
+static int mock_tcpm_transmit(int port, enum tcpci_msg_type type,
 		uint16_t header, const uint32_t *data)
 { return EC_SUCCESS; }
 static void mock_tcpc_alert(int port) {}
diff --git a/include/driver/tcpm/tcpci.h b/include/driver/tcpm/tcpci.h
index 5270da8d4e..53a6a4e65e 100644
--- a/include/driver/tcpm/tcpci.h
+++ b/include/driver/tcpm/tcpci.h
@@ -262,7 +262,7 @@ int tcpci_tcpm_set_vconn(int port, int enable);
 int tcpci_tcpm_set_msg_header(int port, int power_role, int data_role);
 int tcpci_tcpm_set_rx_enable(int port, int enable);
 int tcpci_tcpm_get_message_raw(int port, uint32_t *payload, int *head);
-int tcpci_tcpm_transmit(int port, enum tcpm_sop_type type,
+int tcpci_tcpm_transmit(int port, enum tcpci_msg_type type,
 			uint16_t header, const uint32_t *data);
 int tcpci_tcpm_release(int port);
 #ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
diff --git a/include/driver/tcpm/tcpm.h b/include/driver/tcpm/tcpm.h
index d8fe5602a3..fb63e5504f 100644
--- a/include/driver/tcpm/tcpm.h
+++ b/include/driver/tcpm/tcpm.h
@@ -271,7 +271,7 @@ static inline int tcpm_reset_bist_type_2(int port)
  */
 int tcpm_enqueue_message(int port);
 
-static inline int tcpm_transmit(int port, enum tcpm_sop_type type,
+static inline int tcpm_transmit(int port, enum tcpci_msg_type type,
 				uint16_t header, const uint32_t *data)
 {
 	return tcpc_config[port].drv->transmit(port, type, header, data);
@@ -532,7 +532,7 @@ void tcpm_enable_auto_discharge_disconnect(int port, int enable);
  *
  * @return EC_SUCCESS or error
  */
-int tcpm_transmit(int port, enum tcpm_sop_type type, uint16_t header,
+int tcpm_transmit(int port, enum tcpci_msg_type type, uint16_t header,
 		  const uint32_t *data);
 
 /**
diff --git a/include/mock/tcpci_i2c_mock.h b/include/mock/tcpci_i2c_mock.h
index 17dba6dddd..1d4a986ebe 100644
--- a/include/mock/tcpci_i2c_mock.h
+++ b/include/mock/tcpci_i2c_mock.h
@@ -17,21 +17,21 @@ void mock_tcpci_clr_reg_bits(int reg_offset, uint16_t mask);
 
 uint16_t mock_tcpci_get_reg(int reg_offset);
 
-int verify_tcpci_transmit(enum tcpm_sop_type tx_type,
+int verify_tcpci_transmit(enum tcpci_msg_type tx_type,
 			  enum pd_ctrl_msg_type ctrl_msg,
 			  enum pd_data_msg_type data_msg);
 
-int verify_tcpci_tx_retry_count(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_retry_count(enum tcpci_msg_type tx_type,
 				enum pd_ctrl_msg_type ctrl_msg,
 				enum pd_data_msg_type data_msg,
 				int retry_count);
 
-int verify_tcpci_tx_timeout(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_timeout(enum tcpci_msg_type tx_type,
 			    enum pd_ctrl_msg_type ctrl_msg,
 			    enum pd_data_msg_type data_msg,
 			    int timeout);
 
-int verify_tcpci_tx_with_data(enum tcpm_sop_type tx_type,
+int verify_tcpci_tx_with_data(enum tcpci_msg_type tx_type,
 			      enum pd_data_msg_type data_msg,
 			      uint8_t *data,
 			      int data_bytes,
@@ -39,7 +39,7 @@ int verify_tcpci_tx_with_data(enum tcpm_sop_type tx_type,
 			      int timeout);
 
 struct possible_tx {
-	enum tcpm_sop_type tx_type;
+	enum tcpci_msg_type tx_type;
 	enum pd_ctrl_msg_type ctrl_msg;
 	enum pd_data_msg_type data_msg;
 };
@@ -52,7 +52,7 @@ int verify_tcpci_possible_tx(struct possible_tx possible[],
 			     int *msg_len,
 			     int timeout);
 
-void mock_tcpci_receive(enum tcpm_sop_type sop, uint16_t header,
+void mock_tcpci_receive(enum tcpci_msg_type sop, uint16_t header,
 			uint32_t *payload);
 
 void tcpci_register_dump(void);
diff --git a/include/mock/usb_pe_sm_mock.h b/include/mock/usb_pe_sm_mock.h
index 58138f7473..fcd6e268a0 100644
--- a/include/mock/usb_pe_sm_mock.h
+++ b/include/mock/usb_pe_sm_mock.h
@@ -12,7 +12,7 @@
 #include "usb_pd_tcpm.h"
 
 struct mock_pe_port_t {
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 
 	int mock_pe_message_sent;
 	int mock_pe_error;
diff --git a/include/mock/usb_prl_mock.h b/include/mock/usb_prl_mock.h
index 15015a6f0f..ee37d6e6e2 100644
--- a/include/mock/usb_prl_mock.h
+++ b/include/mock/usb_prl_mock.h
@@ -14,7 +14,7 @@
 void mock_prl_reset(void);
 
 int mock_prl_wait_for_tx_msg(int port,
-			     enum tcpm_sop_type tx_type,
+			     enum tcpci_msg_type tx_type,
 			     enum pd_ctrl_msg_type ctrl_msg,
 			     enum pd_data_msg_type data_msg,
 			     int timeout);
@@ -31,6 +31,6 @@ void mock_prl_message_sent(int port);
 void mock_prl_message_received(int port);
 
 void mock_prl_report_error(int port, enum pe_error e,
-			   enum tcpm_sop_type tx_type);
+			   enum tcpci_msg_type tx_type);
 
 #endif /* __MOCK_DP_ALT_MODE_MOCK_H */
diff --git a/include/mock/usb_tc_sm_mock.h b/include/mock/usb_tc_sm_mock.h
index ca82eec638..ca16fb4d98 100644
--- a/include/mock/usb_tc_sm_mock.h
+++ b/include/mock/usb_tc_sm_mock.h
@@ -17,7 +17,7 @@ struct mock_tc_port_t {
 	int pd_enable;
 	int msg_tx_id;
 	int msg_rx_id;
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 	enum tcpc_rp_value lcl_rp;
 	int attached_snk;
 	int attached_src;
diff --git a/include/usb_dp_alt_mode.h b/include/usb_dp_alt_mode.h
index 430926c5bf..ea824ea476 100644
--- a/include/usb_dp_alt_mode.h
+++ b/include/usb_dp_alt_mode.h
@@ -50,7 +50,7 @@ bool dp_entry_is_done(int port);
  * @param vdo_count The number of VDOs in the ACK VDM
  * @param vdm       VDM from ACK
  */
-void dp_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dp_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm);
 
 /*
@@ -61,7 +61,7 @@ void dp_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
  * @param svid    The SVID of the request
  * @param vdm_cmd The VDM command of the request
  */
-void dp_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd);
+void dp_vdm_naked(int port, enum tcpci_msg_type type, uint8_t vdm_cmd);
 
 /*
  * Construct the next DisplayPort VDM that should be sent.
diff --git a/include/usb_mode.h b/include/usb_mode.h
index 598024d683..4333cc851e 100644
--- a/include/usb_mode.h
+++ b/include/usb_mode.h
@@ -72,7 +72,7 @@ bool enter_usb_cable_is_capable(int port);
  * @param port    USB-C port number
  * @param type    Transmit type (SOP, SOP', SOP'') for request
  */
-void enter_usb_accepted(int port, enum tcpm_sop_type type);
+void enter_usb_accepted(int port, enum tcpci_msg_type type);
 
 /*
  * Handles rejected USB4 response
@@ -80,7 +80,7 @@ void enter_usb_accepted(int port, enum tcpm_sop_type type);
  * @param port    USB-C port number
  * @param type    Transmit type (SOP, SOP', SOP'') for request
  */
-void enter_usb_rejected(int port, enum tcpm_sop_type type);
+void enter_usb_rejected(int port, enum tcpci_msg_type type);
 
 /*
  * Constructs the next USB4 EUDO that should be sent.
@@ -88,6 +88,6 @@ void enter_usb_rejected(int port, enum tcpm_sop_type type);
  * @param port    USB-C port number
  * @param type    Transmit type (SOP, SOP', SOP'') for request
  */
-uint32_t enter_usb_setup_next_msg(int port, enum tcpm_sop_type *type);
+uint32_t enter_usb_setup_next_msg(int port, enum tcpci_msg_type *type);
 
 #endif
diff --git a/include/usb_pd.h b/include/usb_pd.h
index ae30f75742..9670b2d8aa 100644
--- a/include/usb_pd.h
+++ b/include/usb_pd.h
@@ -419,11 +419,11 @@ enum pd_alternate_modes {
 
 /* Discover and possibly enter modes for all SOP* communications when enabled */
 #ifdef CONFIG_USB_PD_DECODE_SOP
-#define DISCOVERY_TYPE_COUNT (TCPC_TX_SOP_PRIME + 1)
-#define AMODE_TYPE_COUNT     (TCPC_TX_SOP_PRIME_PRIME + 1)
+#define DISCOVERY_TYPE_COUNT (TCPCI_MSG_SOP_PRIME + 1)
+#define AMODE_TYPE_COUNT     (TCPCI_MSG_SOP_PRIME_PRIME + 1)
 #else
-#define DISCOVERY_TYPE_COUNT (TCPC_TX_SOP + 1)
-#define AMODE_TYPE_COUNT     (TCPC_TX_SOP + 1)
+#define DISCOVERY_TYPE_COUNT (TCPCI_MSG_SOP + 1)
+#define AMODE_TYPE_COUNT     (TCPCI_MSG_SOP + 1)
 #endif
 
 /* Discovery results for a port partner (SOP) or cable plug (SOP') */
@@ -1359,7 +1359,7 @@ void schedule_deferred_pd_interrupt(int port);
  *         PD_REV20 for PD Revision 2.0
  *         PD_REV30 for PD Revision 3.0
  */
-int pd_get_rev(int port, enum tcpm_sop_type type);
+int pd_get_rev(int port, enum tcpci_msg_type type);
 
 /**
  * Get current PD VDO Version of Structured VDM
@@ -1369,7 +1369,7 @@ int pd_get_rev(int port, enum tcpm_sop_type type);
  * @return VDM_VER10 for VDM Version 1.0
  *         VDM_VER20 for VDM Version 2.0
  */
-int pd_get_vdo_ver(int port, enum tcpm_sop_type type);
+int pd_get_vdo_ver(int port, enum tcpci_msg_type type);
 
 /**
  * Get transmit retry count for active PD revision.
@@ -1378,7 +1378,7 @@ int pd_get_vdo_ver(int port, enum tcpm_sop_type type);
  * @param type The partner to query (SOP, SOP', or SOP'')
  * @return The number of retries to perform when transmitting.
  */
-int pd_get_retry_count(int port, enum tcpm_sop_type type);
+int pd_get_retry_count(int port, enum tcpci_msg_type type);
 
 /**
  * Check if max voltage request is allowed (only used if
@@ -1705,7 +1705,7 @@ __override_proto int pd_custom_vdm(int port, int cnt, uint32_t *payload,
  * @return if >0, number of VDOs to send back.
  */
 int pd_svdm(int port, int cnt, uint32_t *payload, uint32_t **rpayload,
-		uint32_t head, enum tcpm_sop_type *rtype);
+		uint32_t head, enum tcpci_msg_type *rtype);
 
 /**
  * Handle Custom VDMs for flashing.
@@ -1726,7 +1726,7 @@ int pd_custom_flash_vdm(int port, int cnt, uint32_t *payload);
  * @param opos object position of mode to exit.
  * @return vdm for UFP to be sent to enter mode or zero if not.
  */
-uint32_t pd_dfp_enter_mode(int port, enum tcpm_sop_type type,
+uint32_t pd_dfp_enter_mode(int port, enum tcpci_msg_type type,
 		uint16_t svid, int opos);
 
 /**
@@ -1764,7 +1764,7 @@ int pd_dfp_dp_get_pin_mode(int port, uint32_t status);
  * @param opos object position of mode to exit.
  * @return 1 if UFP should be sent exit mode VDM.
  */
-int pd_dfp_exit_mode(int port, enum tcpm_sop_type type, uint16_t svid,
+int pd_dfp_exit_mode(int port, enum tcpci_msg_type type, uint16_t svid,
 		int opos);
 
 /**
@@ -1783,7 +1783,7 @@ void dfp_consume_attention(int port, uint32_t *payload);
  * @param cnt     number of data objects in payload
  * @param payload payload data.
  */
-void dfp_consume_identity(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_identity(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload);
 
 /**
@@ -1794,7 +1794,7 @@ void dfp_consume_identity(int port, enum tcpm_sop_type type, int cnt,
  * @param cnt     number of data objects in payload
  * @param payload payload data.
  */
-void dfp_consume_svids(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_svids(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload);
 
 /**
@@ -1805,7 +1805,7 @@ void dfp_consume_svids(int port, enum tcpm_sop_type type, int cnt,
  * @param cnt     number of data objects in payload
  * @param payload payload data.
  */
-void dfp_consume_modes(int port, enum tcpm_sop_type type, int cnt,
+void dfp_consume_modes(int port, enum tcpci_msg_type type, int cnt,
 		uint32_t *payload);
 
 /**
@@ -1892,7 +1892,7 @@ void pd_dfp_discovery_init(int port);
  * @param type	SOP* type to set
  * @param disc  Discovery state to set (failed or complete)
  */
-void pd_set_identity_discovery(int port, enum tcpm_sop_type type,
+void pd_set_identity_discovery(int port, enum tcpci_msg_type type,
 			       enum pd_discovery_state disc);
 
 /**
@@ -1903,7 +1903,7 @@ void pd_set_identity_discovery(int port, enum tcpm_sop_type type,
  * @return      Current discovery state (failed or complete)
  */
 enum pd_discovery_state pd_get_identity_discovery(int port,
-						enum tcpm_sop_type type);
+						enum tcpci_msg_type type);
 
 /**
  * Set SVID discovery state for this type and port.
@@ -1912,7 +1912,7 @@ enum pd_discovery_state pd_get_identity_discovery(int port,
  * @param type SOP* type to set
  * @param disc Discovery state to set (failed or complete)
  */
-void pd_set_svids_discovery(int port, enum tcpm_sop_type type,
+void pd_set_svids_discovery(int port, enum tcpci_msg_type type,
 		enum pd_discovery_state disc);
 
 /**
@@ -1923,7 +1923,7 @@ void pd_set_svids_discovery(int port, enum tcpm_sop_type type,
  * @return     Current discovery state (failed or complete)
  */
 enum pd_discovery_state pd_get_svids_discovery(int port,
-		enum tcpm_sop_type type);
+		enum tcpci_msg_type type);
 
 /**
  * Set Modes discovery state for this port, SOP* type, and SVID.
@@ -1933,7 +1933,7 @@ enum pd_discovery_state pd_get_svids_discovery(int port,
  * @param svid SVID to set mode discovery state for
  * @param disc Discovery state to set (failed or complete)
  */
-void pd_set_modes_discovery(int port, enum tcpm_sop_type type,
+void pd_set_modes_discovery(int port, enum tcpci_msg_type type,
 		uint16_t svid, enum pd_discovery_state disc);
 
 /**
@@ -1950,7 +1950,7 @@ void pd_set_modes_discovery(int port, enum tcpm_sop_type type,
  *                                       PD_DISC_FAIL)
  */
 enum pd_discovery_state pd_get_modes_discovery(int port,
-		enum tcpm_sop_type type);
+		enum tcpci_msg_type type);
 
 /**
  * Returns the mode vdo count of the specified SVID and sets
@@ -1964,7 +1964,7 @@ enum pd_discovery_state pd_get_modes_discovery(int port,
  * @return         Mode VDO cnt of specified SVID if is discovered,
  *                 0 otherwise
  */
-int pd_get_mode_vdo_for_svid(int port, enum tcpm_sop_type type,
+int pd_get_mode_vdo_for_svid(int port, enum tcpci_msg_type type,
 		uint16_t svid, uint32_t *vdo_out);
 
 /**
@@ -1980,7 +1980,7 @@ int pd_get_mode_vdo_for_svid(int port, enum tcpm_sop_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 tcpm_sop_type type);
+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*
@@ -1991,7 +1991,7 @@ struct svid_mode_data *pd_get_next_mode(int port, enum tcpm_sop_type type);
  * @return      pointer to response structure, which the caller may not alter
  */
 const union disc_ident_ack *pd_get_identity_response(int port,
-					       enum tcpm_sop_type type);
+					       enum tcpci_msg_type type);
 
 /**
  * Return the VID of the USB PD accessory connected to a specified port
@@ -2024,7 +2024,7 @@ uint8_t pd_get_product_type(int port);
  * @param type	SOP* type to retrieve
  * @return      SVID count
  */
-int pd_get_svid_count(int port, enum tcpm_sop_type type);
+int pd_get_svid_count(int port, enum tcpci_msg_type type);
 
 /**
  * Return the SVID of given SVID index of port partner connected
@@ -2035,7 +2035,7 @@ int pd_get_svid_count(int port, enum tcpm_sop_type type);
  * @param type	   SOP* type to retrieve
  * @return         SVID
  */
-uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpm_sop_type type);
+uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpci_msg_type type);
 
 /**
  * Return the pointer to modes of VDO of port partner connected
@@ -2047,7 +2047,7 @@ uint16_t pd_get_svid(int port, uint16_t svid_idx, enum tcpm_sop_type type);
  * @return         Pointer to modes of VDO
  */
 uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
-		enum tcpm_sop_type type);
+		enum tcpci_msg_type type);
 
 /*
  * Looks for a discovered mode VDO for the specified SVID.
@@ -2057,7 +2057,7 @@ uint32_t *pd_get_mode_vdo(int port, uint16_t svid_idx,
  * @param svid SVID to look up
  * @return     Whether a mode was discovered for the SVID
  */
-bool pd_is_mode_discovered_for_svid(int port, enum tcpm_sop_type type,
+bool pd_is_mode_discovered_for_svid(int port, enum tcpci_msg_type type,
 		uint16_t svid);
 
 /**
@@ -2069,7 +2069,7 @@ bool pd_is_mode_discovered_for_svid(int port, enum tcpm_sop_type type,
  * @return      pointer to SVDM mode data
  */
 struct svdm_amode_data *pd_get_amode_data(int port,
-		enum tcpm_sop_type type, uint16_t svid);
+		enum tcpci_msg_type type, uint16_t svid);
 
 /*
  * Returns cable revision
@@ -2110,7 +2110,7 @@ bool consume_sop_prime_prime_repeat_msg(int port, uint8_t msg_id);
  * @param port USB-C port number
  * @param type Transmit type (SOP, SOP')
  */
-void pd_discovery_access_clear(int port, enum tcpm_sop_type type);
+void pd_discovery_access_clear(int port, enum tcpci_msg_type type);
 
 /*
  * Validate that this current task is the only one which has retrieved the
@@ -2121,7 +2121,7 @@ void pd_discovery_access_clear(int port, enum tcpm_sop_type type);
  * @param type Transmit type (SOP, SOP')
  * @return     True - No other tasks have accessed the data
  */
-bool pd_discovery_access_validate(int port, enum tcpm_sop_type type);
+bool pd_discovery_access_validate(int port, enum tcpci_msg_type type);
 
 /*
  * Returns the pointer to PD alternate mode discovery results
@@ -2138,7 +2138,7 @@ bool pd_discovery_access_validate(int port, enum tcpm_sop_type type);
  * @return     pointer to PD alternate mode discovery results
  */
 struct pd_discovery *pd_get_am_discovery(int port,
-		enum tcpm_sop_type type);
+		enum tcpci_msg_type type);
 
 /*
  * Returns the pointer to PD active alternate modes.
@@ -2149,7 +2149,7 @@ struct pd_discovery *pd_get_am_discovery(int port,
  * @return     Pointer to PD active alternate modes.
  */
 struct partner_active_modes *pd_get_partner_active_modes(int port,
-		enum tcpm_sop_type type);
+		enum tcpci_msg_type type);
 
 /*
  * Sets the current object position for DP alt-mode
@@ -2297,7 +2297,7 @@ enum tbt_compat_rounded_support get_tbt_rounded_support(int port);
  * @return      Discover Mode VDO for Intel SVID if the Intel mode VDO is
  *              discovered, 0 otherwise
  */
-uint32_t pd_get_tbt_mode_vdo(int port, enum tcpm_sop_type type);
+uint32_t pd_get_tbt_mode_vdo(int port, enum tcpci_msg_type type);
 
 /**
  * Sets the Mux state to Thunderbolt-Compatible mode
@@ -2324,7 +2324,7 @@ enum tbt_compat_cable_speed get_tbt_cable_speed(int port);
  * @param payload   payload data
  * @return          Number of object filled
  */
-int enter_tbt_compat_mode(int port, enum tcpm_sop_type sop,
+int enter_tbt_compat_mode(int port, enum tcpci_msg_type sop,
 			uint32_t *payload);
 
 /**
@@ -2453,7 +2453,7 @@ void pd_dpm_request(int port, enum pd_dpm_request req);
  *                must be 1 - 7 inclusive.
  * @return        True if the setup was successful
  */
-bool pd_setup_vdm_request(int port, enum tcpm_sop_type tx_type,
+bool pd_setup_vdm_request(int port, enum tcpci_msg_type tx_type,
 		uint32_t *vdm, uint32_t vdo_cnt);
 
 /* Power Data Objects for the source and the sink */
@@ -2487,7 +2487,7 @@ static inline void pd_send_host_event(int mask) { }
  * @param svid USB standard or vendor id
  * @return object position of mode chosen in alternate mode otherwise zero.
  */
-int pd_alt_mode(int port, enum tcpm_sop_type type, uint16_t svid);
+int pd_alt_mode(int port, enum tcpci_msg_type type, uint16_t svid);
 
 /**
  * Send hpd over USB PD.
diff --git a/include/usb_pd_dpm.h b/include/usb_pd_dpm.h
index f995363fdf..19d4c4fe6b 100644
--- a/include/usb_pd_dpm.h
+++ b/include/usb_pd_dpm.h
@@ -36,7 +36,7 @@ void dpm_set_mode_exit_request(int port);
  * @param vdo_count The number of VDOs in vdm; must be at least 1
  * @param vdm       The VDM payload of the ACK
  */
-void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dpm_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm);
 
 /*
@@ -48,7 +48,7 @@ void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
  * @param svid    The SVID of the request
  * @param vdm_cmd The VDM command of the request
  */
-void dpm_vdm_naked(int port, enum tcpm_sop_type type, uint16_t svid,
+void dpm_vdm_naked(int port, enum tcpci_msg_type type, uint16_t svid,
 		uint8_t vdm_cmd);
 
 /*
diff --git a/include/usb_pd_tcpc.h b/include/usb_pd_tcpc.h
index 34affc973d..0a10f97e0e 100644
--- a/include/usb_pd_tcpc.h
+++ b/include/usb_pd_tcpc.h
@@ -61,7 +61,7 @@ int tcpc_set_vconn(int port, int enable);
 int tcpc_set_msg_header(int port, int power_role, int data_role);
 int tcpc_set_rx_enable(int port, int enable);
 int tcpc_get_message(int port, uint32_t *payload, int *head);
-int tcpc_transmit(int port, enum tcpm_sop_type type, uint16_t header,
+int tcpc_transmit(int port, enum tcpci_msg_type type, uint16_t header,
 		  const uint32_t *data);
 int rx_buf_is_empty(int port);
 void rx_buf_clear(int port);
diff --git a/include/usb_pd_tcpm.h b/include/usb_pd_tcpm.h
index 7dfa2dca1c..08c332efa2 100644
--- a/include/usb_pd_tcpm.h
+++ b/include/usb_pd_tcpm.h
@@ -68,24 +68,25 @@ static inline enum tcpc_cc_polarity polarity_rm_dts(
 /*
  * Types of PD data that can be sent or received. The values match the TCPCI bit
  * field values TRANSMIT[Transmit SOP* Message] (TCPCI r2.0 v1.2, table 4-38)
- * and RX_BUF_FRAME_TYPE[Received SOP* message] (table 4-37).
+ * and RX_BUF_FRAME_TYPE[Received SOP* message] (table 4-37). Note that Hard
+ * Reset, Cable Reset, and BIST Carrier Mode 2 are not really messages.
  */
-enum tcpm_sop_type {
-	TCPC_TX_SOP = 0,
-	TCPC_TX_SOP_PRIME = 1,
-	TCPC_TX_SOP_PRIME_PRIME = 2,
-	TCPC_TX_SOP_DEBUG_PRIME = 3,
-	TCPC_TX_SOP_DEBUG_PRIME_PRIME = 4,
+enum tcpci_msg_type {
+	TCPCI_MSG_SOP = 0,
+	TCPCI_MSG_SOP_PRIME = 1,
+	TCPCI_MSG_SOP_PRIME_PRIME = 2,
+	TCPCI_MSG_SOP_DEBUG_PRIME = 3,
+	TCPCI_MSG_SOP_DEBUG_PRIME_PRIME = 4,
 	/* Only a valid register setting for TRANSMIT */
-	TCPC_TX_HARD_RESET = 5,
-	TCPC_TX_CABLE_RESET = 6,
+	TCPCI_MSG_TX_HARD_RESET = 5,
+	TCPCI_MSG_CABLE_RESET = 6,
 	/* Only a valid register setting for TRANSMIT */
-	TCPC_TX_BIST_MODE_2 = 7,
-	TCPC_TX_INVALID = 0xf,
+	TCPCI_MSG_TX_BIST_MODE_2 = 7,
+	TCPCI_MSG_INVALID = 0xf,
 };
 
 /* Number of valid Transmit Types */
-#define NUM_SOP_STAR_TYPES (TCPC_TX_SOP_DEBUG_PRIME_PRIME + 1)
+#define NUM_SOP_STAR_TYPES (TCPCI_MSG_SOP_DEBUG_PRIME_PRIME + 1)
 
 enum tcpc_transmit_complete {
 	TCPC_TX_UNSET = -1,
@@ -309,7 +310,7 @@ struct tcpm_drv {
 	 *
 	 * @return EC_SUCCESS or error
 	 */
-	int (*transmit)(int port, enum tcpm_sop_type type, uint16_t header,
+	int (*transmit)(int port, enum tcpci_msg_type type, uint16_t header,
 					const uint32_t *data);
 
 	/**
diff --git a/include/usb_pe_sm.h b/include/usb_pe_sm.h
index 4c7c375d16..d6ecb4d400 100644
--- a/include/usb_pe_sm.h
+++ b/include/usb_pe_sm.h
@@ -50,7 +50,7 @@ void pe_message_sent(int port);
  * @param  e    error
  * @param type  port address where error was generated
  */
-void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type);
+void pe_report_error(int port, enum pe_error e, enum tcpci_msg_type type);
 
 /**
  * Informs the Policy Engine of a discard.
@@ -186,4 +186,3 @@ void pe_clear_port_data(int port);
 #endif /* TEST_BUILD */
 
 #endif /* __CROS_EC_USB_PE_H */
-
diff --git a/include/usb_prl_sm.h b/include/usb_prl_sm.h
index 011dce2100..6607bd2824 100644
--- a/include/usb_prl_sm.h
+++ b/include/usb_prl_sm.h
@@ -80,7 +80,7 @@ void prl_run(int port, int evt, int en);
  * @param type port address
  * @param rev revision
  */
-void prl_set_rev(int port, enum tcpm_sop_type type,
+void prl_set_rev(int port, enum tcpci_msg_type type,
 					enum pd_rev_type rev);
 
 /**
@@ -90,7 +90,7 @@ void prl_set_rev(int port, enum tcpm_sop_type type,
  * @param type port address
  * @return pd rev
  */
-enum pd_rev_type prl_get_rev(int port, enum tcpm_sop_type type);
+enum pd_rev_type prl_get_rev(int port, enum tcpci_msg_type type);
 
 /**
  * Sends a PD control message
@@ -99,7 +99,7 @@ enum pd_rev_type prl_get_rev(int port, enum tcpm_sop_type type);
  * @param type Transmit type
  * @param msg  Control message type
  */
-void prl_send_ctrl_msg(int port, enum tcpm_sop_type type,
+void prl_send_ctrl_msg(int port, enum tcpci_msg_type type,
 	enum pd_ctrl_msg_type msg);
 
 /**
@@ -109,7 +109,7 @@ void prl_send_ctrl_msg(int port, enum tcpm_sop_type type,
  * @param type Transmit type
  * @param msg  Data message type
  */
-void prl_send_data_msg(int port, enum tcpm_sop_type type,
+void prl_send_data_msg(int port, enum tcpci_msg_type type,
 	enum pd_data_msg_type msg);
 
 /**
@@ -119,7 +119,7 @@ void prl_send_data_msg(int port, enum tcpm_sop_type type,
  * @param type Transmit type
  * @param msg  Extended data message type
  */
-void prl_send_ext_data_msg(int port, enum tcpm_sop_type type,
+void prl_send_ext_data_msg(int port, enum tcpci_msg_type type,
 	enum pd_ext_msg_type msg);
 
 /**
diff --git a/include/usb_tbt_alt_mode.h b/include/usb_tbt_alt_mode.h
index 5190f00ec1..1ea4828059 100644
--- a/include/usb_tbt_alt_mode.h
+++ b/include/usb_tbt_alt_mode.h
@@ -76,7 +76,7 @@ bool tbt_is_active(int port);
  * @param vdo_count The number of VDOs in the ACK VDM
  * @param vdm       VDM from ACK
  */
-void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void intel_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm);
 
 /*
@@ -87,7 +87,7 @@ void intel_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
  * @param svid    The SVID of the request
  * @param vdm_cmd The VDM command of the request
  */
-void intel_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd);
+void intel_vdm_naked(int port, enum tcpci_msg_type type, uint8_t vdm_cmd);
 
 /*
  * Construct the next Thunderbolt VDM that should be sent.
@@ -100,6 +100,6 @@ void intel_vdm_naked(int port, enum tcpm_sop_type type, uint8_t vdm_cmd);
  * @return          The number of VDOs written to VDM or -1 to indicate error
  */
 int tbt_setup_next_vdm(int port, int vdo_count, uint32_t *vdm,
-		enum tcpm_sop_type *tx_type);
+		enum tcpci_msg_type *tx_type);
 
 #endif
diff --git a/test/fake_usbc.c b/test/fake_usbc.c
index e60bd16898..dc631997cf 100644
--- a/test/fake_usbc.c
+++ b/test/fake_usbc.c
@@ -57,7 +57,7 @@ __overridable enum pd_cable_plug tc_get_cable_plug(int port)
 	return PD_PLUG_FROM_DFP_UFP;
 }
 
-__overridable int pd_get_rev(int port, enum tcpm_sop_type type)
+__overridable int pd_get_rev(int port, enum tcpci_msg_type type)
 {
 	return IS_ENABLED(CONFIG_USB_PD_REV30) ? PD_REV30 : PD_REV20;
 }
@@ -259,12 +259,12 @@ void dpm_init(int port)
 {
 }
 
-void dpm_vdm_acked(int port, enum tcpm_sop_type type, int vdo_count,
+void dpm_vdm_acked(int port, enum tcpci_msg_type type, int vdo_count,
 		uint32_t *vdm)
 {
 }
 
-void dpm_vdm_naked(int port, enum tcpm_sop_type type, uint16_t svid,
+void dpm_vdm_naked(int port, enum tcpci_msg_type type, uint16_t svid,
 		uint8_t vdm_cmd)
 {
 }
diff --git a/test/usb_pe_drp.c b/test/usb_pe_drp.c
index 84a13a73de..189cb41987 100644
--- a/test/usb_pe_drp.c
+++ b/test/usb_pe_drp.c
@@ -54,7 +54,7 @@ void before_test(void)
  * TODO: Add support for multiple data objects (when a test is added here that
  * needs it).
  */
-test_static void rx_message(enum tcpm_sop_type sop,
+test_static void rx_message(enum tcpci_msg_type sop,
 			    enum pd_ctrl_msg_type ctrl_msg,
 			    enum pd_data_msg_type data_msg,
 			    enum pd_power_role prole,
@@ -89,12 +89,12 @@ test_static int finish_src_discovery(int startup_cable_probes)
 	int i;
 
 	/* Expect GET_SOURCE_CAP, reply NOT_SUPPORTED. */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_GET_SOURCE_CAP, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
-	rx_message(TCPC_TX_SOP, PD_CTRL_NOT_SUPPORTED, 0,
+	rx_message(TCPCI_MSG_SOP, PD_CTRL_NOT_SUPPORTED, 0,
 		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
 
 	/*
@@ -102,20 +102,20 @@ test_static int finish_src_discovery(int startup_cable_probes)
 	 * above, so expect 5 more now.
 	 */
 	for (i = startup_cable_probes; i < 6; i++) {
-		TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP_PRIME,
+		TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP_PRIME,
 						 0, PD_DATA_VENDOR_DEF,
 						 60 * MSEC),
 			EC_SUCCESS, "%d");
-		mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP_PRIME);
+		mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPCI_MSG_SOP_PRIME);
 	}
 
 	/* Expect VENDOR_DEF for partner identity, reply NOT_SUPPORTED. */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_VENDOR_DEF, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
-	rx_message(TCPC_TX_SOP, PD_CTRL_NOT_SUPPORTED, 0,
+	rx_message(TCPCI_MSG_SOP, PD_CTRL_NOT_SUPPORTED, 0,
 		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
 
 	return EC_SUCCESS;
@@ -131,7 +131,7 @@ test_static int test_send_caps_error_before_connected(void)
 	mock_tc_port[PORT0].power_role = PD_ROLE_SOURCE;
 	mock_tc_port[PORT0].pd_enable = 1;
 	mock_tc_port[PORT0].vconn_src = true;
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_SOURCE_CAP, 10 * MSEC),
 		EC_SUCCESS, "%d");
 
@@ -140,22 +140,22 @@ test_static int test_send_caps_error_before_connected(void)
 	 * PE_SRC_Send_Capabilities goes to PE_SRC_Discovery on send error (and
 	 * does not send soft reset).
 	 */
-	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP);
+	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPCI_MSG_SOP);
 
 	/*
 	 * We should have gone to PE_SRC_Discovery on above error, so expect
 	 * VENDOR_DEF for cable identity, simulate no cable.
 	 */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP_PRIME,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP_PRIME,
 					 0, PD_DATA_VENDOR_DEF, 10 * MSEC),
 		EC_SUCCESS, "%d");
-	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP_PRIME);
+	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPCI_MSG_SOP_PRIME);
 
 	/*
 	 * Expect SOURCE_CAP again. This is a retry since the first one above
 	 * got ERR_TCH_XMIT. Now simulate success (ie GoodCRC).
 	 */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_SOURCE_CAP, 110 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -170,13 +170,13 @@ test_static int test_send_caps_error_before_connected(void)
 	 */
 
 	/* REQUEST 5V, expect ACCEPT, PS_RDY. */
-	rx_message(TCPC_TX_SOP, 0, PD_DATA_REQUEST,
+	rx_message(TCPCI_MSG_SOP, 0, PD_DATA_REQUEST,
 		   PD_ROLE_SINK, PD_ROLE_UFP, RDO_FIXED(1, 500, 500, 0));
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_ACCEPT, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_PS_RDY, 0, 35 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -198,20 +198,20 @@ test_static int test_send_caps_error_when_connected(void)
 	mock_tc_port[PORT0].power_role = PD_ROLE_SOURCE;
 	mock_tc_port[PORT0].pd_enable = 1;
 	mock_tc_port[PORT0].vconn_src = true;
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_SOURCE_CAP, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
 
 	/* REQUEST 5V, expect ACCEPT, PS_RDY. */
-	rx_message(TCPC_TX_SOP, 0, PD_DATA_REQUEST,
+	rx_message(TCPCI_MSG_SOP, 0, PD_DATA_REQUEST,
 		   PD_ROLE_SINK, PD_ROLE_UFP, RDO_FIXED(1, 500, 500, 0));
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_ACCEPT, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_PS_RDY, 0, 35 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -224,14 +224,14 @@ test_static int test_send_caps_error_when_connected(void)
 	 * Now connected. Send GET_SOURCE_CAP, to check how error sending
 	 * SOURCE_CAP is handled.
 	 */
-	rx_message(TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP, 0,
+	rx_message(TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP, 0,
 		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_SOURCE_CAP, 10 * MSEC),
 		EC_SUCCESS, "%d");
 
 	/* Simulate error sending SOURCE_CAP. */
-	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP);
+	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPCI_MSG_SOP);
 
 	/*
 	 * Expect SOFT_RESET.
@@ -240,7 +240,7 @@ test_static int test_send_caps_error_when_connected(void)
 	 * "The PE_SRC_Send_Soft_Reset state Shall be entered from any state
 	 * when ... A Message has not been sent after retries to the Sink"
 	 */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_SOFT_RESET, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -260,20 +260,20 @@ test_static int test_interrupting_pr_swap(void)
 	mock_tc_port[PORT0].power_role = PD_ROLE_SOURCE;
 	mock_tc_port[PORT0].pd_enable = 1;
 	mock_tc_port[PORT0].vconn_src = true;
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 0, PD_DATA_SOURCE_CAP, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
 
 	/* REQUEST 5V, expect ACCEPT, PS_RDY. */
-	rx_message(TCPC_TX_SOP, 0, PD_DATA_REQUEST,
+	rx_message(TCPCI_MSG_SOP, 0, PD_DATA_REQUEST,
 		   PD_ROLE_SINK, PD_ROLE_UFP, RDO_FIXED(1, 500, 500, 0));
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_ACCEPT, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_PS_RDY, 0, 35 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -286,10 +286,10 @@ test_static int test_interrupting_pr_swap(void)
 	 * Now connected.  Initiate a PR swap and then interrupt it after the
 	 * Accept, when power is transitioning to off.
 	 */
-	rx_message(TCPC_TX_SOP, PD_CTRL_PR_SWAP, 0,
+	rx_message(TCPCI_MSG_SOP, PD_CTRL_PR_SWAP, 0,
 		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
 
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_SOP,
 					 PD_CTRL_ACCEPT, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_prl_message_sent(PORT0);
@@ -297,14 +297,14 @@ test_static int test_interrupting_pr_swap(void)
 	task_wait_event(5 * SECOND);
 
 	/* Interrupt the non-interruptible AMS */
-	rx_message(TCPC_TX_SOP, PD_CTRL_PR_SWAP, 0,
+	rx_message(TCPCI_MSG_SOP, PD_CTRL_PR_SWAP, 0,
 		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
 
 	/*
 	 * Expect a hard reset since power was transitioning during this
 	 * interruption
 	 */
-	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_HARD_RESET,
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPCI_MSG_TX_HARD_RESET,
 					 0, 0, 10 * MSEC),
 		EC_SUCCESS, "%d");
 
diff --git a/test/usb_prl.c b/test/usb_prl.c
index e572da4966..061bb1ad3c 100644
--- a/test/usb_prl.c
+++ b/test/usb_prl.c
@@ -40,7 +40,7 @@ static void enable_prl(int port, int en)
 
 	task_wait_event(10*MSEC);
 
-	prl_set_rev(port, TCPC_TX_SOP, mock_tc_port[port].rev);
+	prl_set_rev(port, TCPCI_MSG_SOP, mock_tc_port[port].rev);
 }
 
 static int test_receive_control_msg(void)
@@ -77,7 +77,7 @@ static int test_send_control_msg(void)
 	int port = PORT0;
 
 	/* Set up the message to be sent. */
-	prl_send_ctrl_msg(port, TCPC_TX_SOP, PD_CTRL_ACCEPT);
+	prl_send_ctrl_msg(port, TCPCI_MSG_SOP, PD_CTRL_ACCEPT);
 	task_wait_event(MSEC);
 	/* Simulate the TX complete that the PD_INT handler would signal */
 	pd_transmit_complete(port, TCPC_TX_COMPLETE_SUCCESS);
@@ -112,7 +112,7 @@ static int test_discard_queued_tx_when_rx_happens(void)
 		buf[i] = (uint8_t)i;
 
 	tx_emsg[port].len = len;
-	prl_send_data_msg(port, TCPC_TX_SOP, PD_DATA_SOURCE_CAP);
+	prl_send_data_msg(port, TCPCI_MSG_SOP, PD_DATA_SOURCE_CAP);
 
 	/* Set up the message to be received. */
 	mock_tcpm_rx_msg(port, header, 0, NULL);
diff --git a/test/usb_prl_old.c b/test/usb_prl_old.c
index 4cd4b3bbaf..526015b6c9 100644
--- a/test/usb_prl_old.c
+++ b/test/usb_prl_old.c
@@ -115,7 +115,7 @@ static struct pd_prl {
 	enum pd_data_role data_role;
 	int msg_tx_id;
 	int msg_rx_id;
-	enum tcpm_sop_type sop;
+	enum tcpci_msg_type sop;
 
 	int mock_pe_message_sent;
 	int mock_pe_error;
@@ -506,7 +506,7 @@ static int verify_ctrl_msg_transmission(int port,
 }
 
 static int simulate_send_ctrl_msg_request_from_pe(int port,
-	enum tcpm_sop_type type, enum pd_ctrl_msg_type msg_type)
+	enum tcpci_msg_type type, enum pd_ctrl_msg_type msg_type)
 {
 	pd_port[port].mock_got_soft_reset = 0;
 	pd_port[port].mock_pe_error = -1;
@@ -565,7 +565,7 @@ static int verify_data_msg_transmission(int port,
 }
 
 static int simulate_send_data_msg_request_from_pe(int port,
-	enum tcpm_sop_type type, enum pd_ctrl_msg_type msg_type, int len)
+	enum tcpci_msg_type type, enum pd_ctrl_msg_type msg_type, int len)
 {
 	int i;
 	uint8_t *buf = tx_emsg[port].buf;
@@ -700,7 +700,7 @@ static int verify_extended_data_msg_transmission(int port,
 }
 
 static int simulate_send_extended_data_msg(int port,
-		enum tcpm_sop_type type, enum pd_ctrl_msg_type msg_type,
+		enum tcpci_msg_type type, enum pd_ctrl_msg_type msg_type,
 		int len)
 {
 	int i;
@@ -740,7 +740,7 @@ static void enable_prl(int port, int en)
 	/* Init PRL */
 	cycle_through_state_machine(port, 10, MSEC);
 
-	prl_set_rev(port, TCPC_TX_SOP, pd_port[port].rev);
+	prl_set_rev(port, TCPCI_MSG_SOP, pd_port[port].rev);
 }
 
 enum pd_power_role pd_get_power_role(int port)
@@ -758,7 +758,7 @@ enum pd_cable_plug tc_get_cable_plug(int port)
 	return PD_PLUG_FROM_DFP_UFP;
 }
 
-void pe_report_error(int port, enum pe_error e, enum tcpm_sop_type type)
+void pe_report_error(int port, enum pe_error e, enum tcpci_msg_type type)
 {
 	pd_port[port].mock_pe_error = e;
 	pd_port[port].sop = type;
@@ -844,7 +844,7 @@ static int test_send_ctrl_msg(void)
 				PRL_TX_WAIT_FOR_MESSAGE_REQUEST, "%u");
 
 		TEST_NE(simulate_send_ctrl_msg_request_from_pe(port,
-				TCPC_TX_SOP, PD_CTRL_ACCEPT), 0, "%d");
+				TCPCI_MSG_SOP, PD_CTRL_ACCEPT), 0, "%d");
 
 		cycle_through_state_machine(port, 1, MSEC);
 
@@ -882,7 +882,7 @@ static int test_send_data_msg(void)
 				PRL_TX_WAIT_FOR_MESSAGE_REQUEST, "%u");
 
 		TEST_NE(simulate_send_data_msg_request_from_pe(port,
-				TCPC_TX_SOP, PD_DATA_SOURCE_CAP, i), 0, "%d");
+				TCPCI_MSG_SOP, PD_DATA_SOURCE_CAP, i), 0, "%d");
 
 		cycle_through_state_machine(port, 1, MSEC);
 
@@ -919,7 +919,7 @@ static int test_send_data_msg_to_much_data(void)
 
 	/* Try to send 29-bytes */
 	TEST_EQ(simulate_send_data_msg_request_from_pe(port,
-			TCPC_TX_SOP, PD_DATA_SOURCE_CAP, 29), 0, "%d");
+			TCPCI_MSG_SOP, PD_DATA_SOURCE_CAP, 29), 0, "%d");
 
 	task_wake(PD_PORT_TO_TASK_ID(port));
 	task_wait_event(30 * MSEC);
@@ -964,8 +964,8 @@ static int test_send_extended_data_msg(void)
 		TEST_EQ(prl_tx_get_state(port),
 				PRL_TX_WAIT_FOR_MESSAGE_REQUEST, "%d");
 
-		TEST_NE(simulate_send_extended_data_msg(
-				port, TCPC_TX_SOP, PD_EXT_MANUFACTURER_INFO, i),
+		TEST_NE(simulate_send_extended_data_msg(port, TCPCI_MSG_SOP,
+					PD_EXT_MANUFACTURER_INFO, i),
 					0, "%d");
 
 		cycle_through_state_machine(port, 10, MSEC);
@@ -1148,7 +1148,7 @@ static int test_send_soft_reset_msg(void)
 				PRL_TX_WAIT_FOR_MESSAGE_REQUEST, "%u");
 
 	TEST_NE(simulate_send_ctrl_msg_request_from_pe(port,
-			TCPC_TX_SOP, PD_CTRL_SOFT_RESET), 0, "%d");
+			TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET), 0, "%d");
 
 	task_wake(PD_PORT_TO_TASK_ID(port));
 	task_wait_event(30 * MSEC);
diff --git a/test/usb_tcpmv2_compliance.c b/test/usb_tcpmv2_compliance.c
index 655672f290..e0288feb18 100644
--- a/test/usb_tcpmv2_compliance.c
+++ b/test/usb_tcpmv2_compliance.c
@@ -14,7 +14,7 @@
 void before_test(void)
 {
 	partner_set_pd_rev(PD_REV30);
-	partner_tx_msg_id_reset(TCPC_TX_SOP_ALL);
+	partner_tx_msg_id_reset(TCPCI_MSG_SOP_ALL);
 
 	mock_usb_mux_reset();
 	mock_tcpci_reset();
diff --git a/test/usb_tcpmv2_compliance.h b/test/usb_tcpmv2_compliance.h
index 6566a54e51..331e3c5ee8 100644
--- a/test/usb_tcpmv2_compliance.h
+++ b/test/usb_tcpmv2_compliance.h
@@ -51,10 +51,10 @@ enum pd_power_role partner_get_power_role(void);
 void partner_set_pd_rev(enum pd_rev_type pd_rev);
 enum pd_rev_type partner_get_pd_rev(void);
 
-#define TCPC_TX_SOP_ALL -1
+#define TCPCI_MSG_SOP_ALL -1
 void partner_tx_msg_id_reset(int sop);
 
-void partner_send_msg(enum tcpm_sop_type sop,
+void partner_send_msg(enum tcpci_msg_type sop,
 		      uint16_t type,
 		      uint16_t cnt,
 		      uint16_t ext,
diff --git a/test/usb_tcpmv2_compliance_common.c b/test/usb_tcpmv2_compliance_common.c
index 8f2c2f60e1..c1c4f21e09 100644
--- a/test/usb_tcpmv2_compliance_common.c
+++ b/test/usb_tcpmv2_compliance_common.c
@@ -118,14 +118,14 @@ enum pd_rev_type partner_get_pd_rev(void)
 static int partner_tx_id[NUM_SOP_STAR_TYPES];
 void partner_tx_msg_id_reset(int sop)
 {
-	if (sop == TCPC_TX_SOP_ALL)
+	if (sop == TCPCI_MSG_SOP_ALL)
 		for (sop = 0; sop < NUM_SOP_STAR_TYPES; ++sop)
 			partner_tx_id[sop] = 0;
 	else
 		partner_tx_id[sop] = 0;
 }
 
-void partner_send_msg(enum tcpm_sop_type sop,
+void partner_send_msg(enum tcpci_msg_type sop,
 		      uint16_t type,
 		      uint16_t cnt,
 		      uint16_t ext,
@@ -135,7 +135,7 @@ void partner_send_msg(enum tcpm_sop_type sop,
 
 	partner_tx_id[sop] &= 7;
 	header = PD_HEADER(type,
-			sop == TCPC_TX_SOP ? partner_get_power_role()
+			sop == TCPCI_MSG_SOP ? partner_get_power_role()
 			: PD_PLUG_FROM_CABLE,
 			partner_get_data_role(),
 			partner_tx_id[sop],
@@ -259,14 +259,14 @@ int proc_pd_e1(enum pd_data_role data_role, enum proc_pd_e1_attach attach)
 			 *    The Source Capabilities includes Fixed 5V 3A PDO.
 			 */
 			task_wait_event(1 * MSEC);
-			partner_send_msg(TCPC_TX_SOP, PD_DATA_SOURCE_CAP, 1, 0,
-					 &pdo);
+			partner_send_msg(TCPCI_MSG_SOP, PD_DATA_SOURCE_CAP, 1,
+					0, &pdo);
 
 			/*
 			 * f) The tester waits for the Request from the UUT for
 			 *    tSenderResponse max (30 ms).
 			 */
-			TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0,
+			TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0,
 						      PD_DATA_REQUEST),
 				EC_SUCCESS, "%d");
 			mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
@@ -275,10 +275,10 @@ int proc_pd_e1(enum pd_data_role data_role, enum proc_pd_e1_attach attach)
 			 * g) The tester sends Accept, and when Vbus is stable
 			 *    at the target voltage, sends PS_RDY.
 			 */
-			partner_send_msg(TCPC_TX_SOP, PD_CTRL_ACCEPT, 0, 0,
+			partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_ACCEPT, 0, 0,
 					 NULL);
 			task_wait_event(10 * MSEC);
-			partner_send_msg(TCPC_TX_SOP, PD_CTRL_PS_RDY, 0, 0,
+			partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_PS_RDY, 0, 0,
 					 NULL);
 			task_wait_event(1 * MSEC);
 
@@ -290,7 +290,7 @@ int proc_pd_e1(enum pd_data_role data_role, enum proc_pd_e1_attach attach)
 			 * c) The tester waits Source Capabilities for for
 			 *    tNoResponse max (5.5 s).
 			 */
-			TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0,
+			TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0,
 						      PD_DATA_SOURCE_CAP),
 				EC_SUCCESS, "%d");
 
@@ -304,10 +304,10 @@ int proc_pd_e1(enum pd_data_role data_role, enum proc_pd_e1_attach attach)
 			/*
 			 * e) The tester requests 5V 0.5A.
 			 */
-			partner_send_msg(TCPC_TX_SOP, PD_DATA_REQUEST, 1, 0,
+			partner_send_msg(TCPCI_MSG_SOP, PD_DATA_REQUEST, 1, 0,
 					 &rdo);
 
-			TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP,
+			TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP,
 						      PD_CTRL_ACCEPT, 0),
 				EC_SUCCESS, "%d");
 			mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
@@ -316,7 +316,7 @@ int proc_pd_e1(enum pd_data_role data_role, enum proc_pd_e1_attach attach)
 			 * f) The tester waits PS_RDY for tPSSourceOn max
 			 *    (480 ms).
 			 */
-			TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP,
+			TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP,
 						      PD_CTRL_PS_RDY, 0),
 				EC_SUCCESS, "%d");
 			mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
@@ -369,19 +369,19 @@ int handle_attach_expected_msgs(enum pd_data_role data_role)
 	struct possible_tx possible[4];
 
 	if (data_role == PD_ROLE_DFP) {
-		possible[0].tx_type = TCPC_TX_SOP;
+		possible[0].tx_type = TCPCI_MSG_SOP;
 		possible[0].ctrl_msg = PD_CTRL_GET_SOURCE_CAP;
 		possible[0].data_msg = 0;
 
-		possible[1].tx_type = TCPC_TX_SOP;
+		possible[1].tx_type = TCPCI_MSG_SOP;
 		possible[1].ctrl_msg = PD_CTRL_GET_SINK_CAP;
 		possible[1].data_msg = 0;
 
-		possible[2].tx_type = TCPC_TX_SOP_PRIME;
+		possible[2].tx_type = TCPCI_MSG_SOP_PRIME;
 		possible[2].ctrl_msg = 0;
 		possible[2].data_msg = PD_DATA_VENDOR_DEF;
 
-		possible[3].tx_type = TCPC_TX_SOP;
+		possible[3].tx_type = TCPCI_MSG_SOP;
 		possible[3].ctrl_msg = 0;
 		possible[3].data_msg = PD_DATA_VENDOR_DEF;
 
@@ -402,23 +402,23 @@ int handle_attach_expected_msgs(enum pd_data_role data_role)
 			task_wait_event(10 * MSEC);
 
 			switch (found_index) {
-			case 0:	/* TCPC_TX_SOP PD_CTRL_GET_SOURCE_CAP */
-				partner_send_msg(TCPC_TX_SOP,
+			case 0:	/* TCPCI_MSG_SOP PD_CTRL_GET_SOURCE_CAP */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_DATA_SOURCE_CAP,
 						 1, 0, &pdo);
 				break;
-			case 1: /* TCPC_TX_SOP PD_CTRL_GET_SINK_CAP */
-				partner_send_msg(TCPC_TX_SOP,
+			case 1: /* TCPCI_MSG_SOP PD_CTRL_GET_SINK_CAP */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_DATA_SINK_CAP,
 						 1, 0, &pdo);
 				break;
-			case 2: /* TCPC_TX_SOP_PRIME PD_DATA_VENDOR_DEF */
-				partner_send_msg(TCPC_TX_SOP_PRIME,
+			case 2: /* TCPCI_MSG_SOP_PRIME PD_DATA_VENDOR_DEF */
+				partner_send_msg(TCPCI_MSG_SOP_PRIME,
 						 PD_CTRL_NOT_SUPPORTED,
 						 0, 0, NULL);
 				break;
-			case 3: /* TCPC_TX_SOP PD_DATA_VENDOR_DEF */
-				partner_send_msg(TCPC_TX_SOP,
+			case 3: /* TCPCI_MSG_SOP PD_DATA_VENDOR_DEF */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_CTRL_NOT_SUPPORTED,
 						 0, 0, NULL);
 				break;
@@ -430,19 +430,19 @@ int handle_attach_expected_msgs(enum pd_data_role data_role)
 	} else if (data_role == PD_ROLE_UFP) {
 		int vcs = 0;
 
-		possible[0].tx_type = TCPC_TX_SOP;
+		possible[0].tx_type = TCPCI_MSG_SOP;
 		possible[0].ctrl_msg = PD_CTRL_GET_SINK_CAP;
 		possible[0].data_msg = 0;
 
-		possible[1].tx_type = TCPC_TX_SOP;
+		possible[1].tx_type = TCPCI_MSG_SOP;
 		possible[1].ctrl_msg = PD_CTRL_DR_SWAP;
 		possible[1].data_msg = 0;
 
-		possible[2].tx_type = TCPC_TX_SOP;
+		possible[2].tx_type = TCPCI_MSG_SOP;
 		possible[2].ctrl_msg = PD_CTRL_PR_SWAP;
 		possible[2].data_msg = 0;
 
-		possible[3].tx_type = TCPC_TX_SOP;
+		possible[3].tx_type = TCPCI_MSG_SOP;
 		possible[3].ctrl_msg = PD_CTRL_VCONN_SWAP;
 		possible[3].data_msg = 0;
 
@@ -463,24 +463,24 @@ int handle_attach_expected_msgs(enum pd_data_role data_role)
 			task_wait_event(10 * MSEC);
 
 			switch (found_index) {
-			case 0: /* TCPC_TX_SOP PD_CTRL_GET_SINK_CAP */
-				partner_send_msg(TCPC_TX_SOP,
+			case 0: /* TCPCI_MSG_SOP PD_CTRL_GET_SINK_CAP */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_DATA_SINK_CAP,
 						 1, 0, &pdo);
 				break;
-			case 1: /* TCPC_TX_SOP PD_CTRL_DR_SWAP */
-				partner_send_msg(TCPC_TX_SOP,
+			case 1: /* TCPCI_MSG_SOP PD_CTRL_DR_SWAP */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_CTRL_REJECT,
 						 0, 0, NULL);
 				break;
-			case 2:	/* TCPC_TX_SOP PD_CTRL_PR_SWAP */
-				partner_send_msg(TCPC_TX_SOP,
+			case 2:	/* TCPCI_MSG_SOP PD_CTRL_PR_SWAP */
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_CTRL_REJECT,
 						 0, 0, NULL);
 				break;
-			case 3: /* TCPC_TX_SOP PD_CTRL_VCONN_SWAP */
+			case 3: /* TCPCI_MSG_SOP PD_CTRL_VCONN_SWAP */
 				TEST_LT(vcs++, 4, "%d");
-				partner_send_msg(TCPC_TX_SOP,
+				partner_send_msg(TCPCI_MSG_SOP,
 						 PD_CTRL_REJECT,
 						 0, 0, NULL);
 				break;
diff --git a/test/usb_tcpmv2_td_pd_ll_e3.c b/test/usb_tcpmv2_td_pd_ll_e3.c
index 52ce100d1c..46fbee393f 100644
--- a/test/usb_tcpmv2_td_pd_ll_e3.c
+++ b/test/usb_tcpmv2_td_pd_ll_e3.c
@@ -42,12 +42,12 @@ static int td_pd_ll_e3(enum pd_data_role data_role)
 	 *    and do not send GoodCrc for nRetryCount + 1 times
 	 *    (nRetryCount equals 3 since PD 2.1).
 	 */
-	partner_send_msg(TCPC_TX_SOP,
+	partner_send_msg(TCPCI_MSG_SOP,
 			 PD_CTRL_GET_SINK_CAP,
 			 0, 0, NULL);
 
 	retries = (partner_get_pd_rev() == PD_REV30) ? 2 : 3;
-	TEST_EQ(verify_tcpci_tx_retry_count(TCPC_TX_SOP, 0, PD_DATA_SINK_CAP,
+	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, 0, PD_DATA_SINK_CAP,
 			retries),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
@@ -55,7 +55,7 @@ static int td_pd_ll_e3(enum pd_data_role data_role)
 	/*
 	 * c) Check that the UUT issues a Soft Reset.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, PD_CTRL_SOFT_RESET, 0),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET, 0),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 	task_wait_event(10 * MSEC);
@@ -63,7 +63,7 @@ static int td_pd_ll_e3(enum pd_data_role data_role)
 	/*
 	 * d) Handle correctly the Soft Reset procedure.
 	 */
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_ACCEPT, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_ACCEPT, 0, 0, NULL);
 
 	/*
 	 * e) Continue the bring-up procedure and check that the link is
diff --git a/test/usb_tcpmv2_td_pd_ll_e4.c b/test/usb_tcpmv2_td_pd_ll_e4.c
index 66eff67361..cb6aa8e8b6 100644
--- a/test/usb_tcpmv2_td_pd_ll_e4.c
+++ b/test/usb_tcpmv2_td_pd_ll_e4.c
@@ -44,12 +44,12 @@ static int td_pd_ll_e4(enum pd_data_role data_role)
 	 *    and do not send GoodCrc for nRetryCount + 1 times
 	 *    (nRetryCount equals 3 since PD 2.1).
 	 */
-	partner_send_msg(TCPC_TX_SOP,
+	partner_send_msg(TCPCI_MSG_SOP,
 			 PD_CTRL_GET_SINK_CAP,
 			 0, 0, NULL);
 
 	retries = 3;
-	TEST_EQ(verify_tcpci_tx_retry_count(TCPC_TX_SOP, 0, PD_DATA_SINK_CAP,
+	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, 0, PD_DATA_SINK_CAP,
 			retries),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
@@ -59,8 +59,8 @@ static int td_pd_ll_e4(enum pd_data_role data_role)
 	 *    not reply GoodCrc.
 	 */
 	retries = 3;
-	TEST_EQ(verify_tcpci_tx_retry_count(TCPC_TX_SOP, PD_CTRL_SOFT_RESET, 0,
-			retries),
+	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET,
+				0, retries),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
 	task_wait_event(1 * MSEC);
@@ -69,7 +69,7 @@ static int td_pd_ll_e4(enum pd_data_role data_role)
 	 * d) Check that the UUT issues a Hard Reset.
 	 */
 	TEST_EQ(mock_tcpci_get_reg(TCPC_REG_TRANSMIT),
-		TCPC_TX_HARD_RESET, "%d");
+		TCPCI_MSG_TX_HARD_RESET, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS | TCPC_REG_ALERT_TX_FAILED);
 	mock_tcpci_set_reg(TCPC_REG_TRANSMIT, 0);
 	task_wait_event(1 * MSEC);
diff --git a/test/usb_tcpmv2_td_pd_ll_e5.c b/test/usb_tcpmv2_td_pd_ll_e5.c
index a1d431bed7..ae6409eb20 100644
--- a/test/usb_tcpmv2_td_pd_ll_e5.c
+++ b/test/usb_tcpmv2_td_pd_ll_e5.c
@@ -38,9 +38,9 @@ static int td_pd_ll_e5(enum pd_data_role data_role)
 	 * b) Initiate a Soft Reset and check that the procedure is completed
 	 *    successfully.
 	 */
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_SOFT_RESET, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET, 0, 0, NULL);
 
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, PD_CTRL_ACCEPT, 0),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, PD_CTRL_ACCEPT, 0),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 
diff --git a/test/usb_tcpmv2_td_pd_other.c b/test/usb_tcpmv2_td_pd_other.c
index 17829030ea..1882480150 100644
--- a/test/usb_tcpmv2_td_pd_other.c
+++ b/test/usb_tcpmv2_td_pd_other.c
@@ -56,8 +56,8 @@ int test_retry_count_sop(void)
 	 * Source Caps is SOP message which should be retried at TCPC layer.
 	 * The retry count for PD3 should be 2.
 	 */
-	TEST_EQ(verify_tcpci_tx_retry_count(TCPC_TX_SOP, 0, PD_DATA_SOURCE_CAP,
-		2),
+	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_SOP, 0,
+				PD_DATA_SOURCE_CAP, 2),
 		EC_SUCCESS, "%d");
 	return EC_SUCCESS;
 }
@@ -83,7 +83,7 @@ int test_retry_count_hard_reset(void)
 	/*
 	 * The Tester waits for Source_Capabilities for tNoResponse max.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0, PD_DATA_SOURCE_CAP),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0, PD_DATA_SOURCE_CAP),
 		EC_SUCCESS, "%d");
 	/*
 	 * The Tester replies GoodCrc on reception of the Source_Capabilities.
@@ -100,7 +100,7 @@ int test_retry_count_hard_reset(void)
 	prl_execute_hard_reset(PORT0);
 
 	/* The retry count for hard resets should be 0 */
-	TEST_EQ(verify_tcpci_tx_retry_count(TCPC_TX_HARD_RESET, 0, 0, 0),
+	TEST_EQ(verify_tcpci_tx_retry_count(TCPCI_MSG_TX_HARD_RESET, 0, 0, 0),
 		EC_SUCCESS, "%d");
 
 	return EC_SUCCESS;
diff --git a/test/usb_tcpmv2_td_pd_snk3_e12.c b/test/usb_tcpmv2_td_pd_snk3_e12.c
index 096d101d65..0195d39dba 100644
--- a/test/usb_tcpmv2_td_pd_snk3_e12.c
+++ b/test/usb_tcpmv2_td_pd_snk3_e12.c
@@ -32,13 +32,13 @@ int test_td_pd_snk3_e12(void)
 	 * b) The Tester keeps the Rp value as SinkTXNG and sends a
 	 * Get_Sink_Cap message to the UUT.
 	 */
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_GET_SINK_CAP, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SINK_CAP, 0, 0, NULL);
 
 	/*
 	 * c) Upon receipt of the Sink_Capabilities Message, the Tester doesn't
 	 * reply with GoodCRC.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0, PD_DATA_SINK_CAP),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0, PD_DATA_SINK_CAP),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
 
@@ -47,7 +47,7 @@ int test_td_pd_snk3_e12(void)
 	 * within tReceive max + tSoftReset max
 	 */
 	TEST_EQ(verify_tcpci_tx_timeout(
-			TCPC_TX_SOP, PD_CTRL_SOFT_RESET, 0, 16 * MSEC),
+			TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET, 0, 16 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 
diff --git a/test/usb_tcpmv2_td_pd_src3_e1.c b/test/usb_tcpmv2_td_pd_src3_e1.c
index 4dd4dac016..751e354b11 100644
--- a/test/usb_tcpmv2_td_pd_src3_e1.c
+++ b/test/usb_tcpmv2_td_pd_src3_e1.c
@@ -69,7 +69,7 @@ int test_td_pd_src3_e1(void)
 	 *    5. Message Type field = 00001b (Source Capabilities)
 	 *    6. Extended field = 0b
 	 */
-	TEST_EQ(verify_tcpci_tx_with_data(TCPC_TX_SOP,
+	TEST_EQ(verify_tcpci_tx_with_data(TCPCI_MSG_SOP,
 					  PD_DATA_SOURCE_CAP,
 					  data,
 					  sizeof(data),
diff --git a/test/usb_tcpmv2_td_pd_src3_e26.c b/test/usb_tcpmv2_td_pd_src3_e26.c
index 405e36f9e2..f5f5bcd3c4 100644
--- a/test/usb_tcpmv2_td_pd_src3_e26.c
+++ b/test/usb_tcpmv2_td_pd_src3_e26.c
@@ -33,13 +33,13 @@ int test_td_pd_src3_e26(void)
 	/*
 	 * ...and sends a Get_Source_Cap message to the UUT.
 	 */
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP, 0, 0, NULL);
 
 	/*
 	 * c) Upon receipt of the Source_Capabilities Message, the Tester
 	 * doesn’t reply with GoodCRC.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0, PD_DATA_SOURCE_CAP),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0, PD_DATA_SOURCE_CAP),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_FAILED);
 
@@ -48,7 +48,7 @@ int test_td_pd_src3_e26(void)
 	 * within tReceive max (1.1 ms) + tSoftReset max (15 ms).
 	 */
 	TEST_EQ(verify_tcpci_tx_timeout(
-			TCPC_TX_SOP, PD_CTRL_SOFT_RESET, 0, 15 * MSEC),
+			TCPCI_MSG_SOP, PD_CTRL_SOFT_RESET, 0, 15 * MSEC),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 
diff --git a/test/usb_tcpmv2_td_pd_src3_e32.c b/test/usb_tcpmv2_td_pd_src3_e32.c
index dec17a67c3..9ade7b83c8 100644
--- a/test/usb_tcpmv2_td_pd_src3_e32.c
+++ b/test/usb_tcpmv2_td_pd_src3_e32.c
@@ -67,7 +67,7 @@ int test_td_pd_src3_e32(void)
 	 * incrementing values (mod 256) starting at 0x00.
 	 */
 	setup_chunk_msg(0, data);
-	partner_send_msg(TCPC_TX_SOP, 0x1F, 7, 1, (uint32_t *)data);
+	partner_send_msg(TCPCI_MSG_SOP, 0x1F, 7, 1, (uint32_t *)data);
 	start_time = get_time().val;
 
 	/*
@@ -77,11 +77,11 @@ int test_td_pd_src3_e32(void)
 	 * transmitted until the first bit of the response Message
 	 * Preamble has been received.
 	 */
-	possible[0].tx_type = TCPC_TX_SOP;
+	possible[0].tx_type = TCPCI_MSG_SOP;
 	possible[0].ctrl_msg = PD_CTRL_NOT_SUPPORTED;
 	possible[0].data_msg = 0;
 
-	possible[1].tx_type = TCPC_TX_SOP;
+	possible[1].tx_type = TCPCI_MSG_SOP;
 	possible[1].ctrl_msg = 0;
 	possible[1].data_msg = 0x1F;
 
@@ -128,9 +128,9 @@ int test_td_pd_src3_e32(void)
 		chunk = next_chunk;
 
 		setup_chunk_msg(chunk, data);
-		partner_send_msg(TCPC_TX_SOP, 0x1F, 7, 1, (uint32_t *)data);
+		partner_send_msg(TCPCI_MSG_SOP, 0x1F, 7, 1, (uint32_t *)data);
 
-		TEST_EQ(verify_tcpci_tx_with_data(TCPC_TX_SOP,
+		TEST_EQ(verify_tcpci_tx_with_data(TCPCI_MSG_SOP,
 					0x1F,
 					data,
 					sizeof(data),
@@ -153,13 +153,13 @@ int test_td_pd_src3_e32(void)
 	task_wait_event(PD_T_CHUNK_SENDER_RSP_MAX + (5 * MSEC));
 
 	setup_chunk_msg(0, data);
-	partner_send_msg(TCPC_TX_SOP, 0x1F, 7, 1, (uint32_t *)data);
+	partner_send_msg(TCPCI_MSG_SOP, 0x1F, 7, 1, (uint32_t *)data);
 
 	/*
 	 * i) If a message is not received within tChunkReceiverRequest max,
 	 * the test fails.
 	 */
-	TEST_EQ(verify_tcpci_tx_with_data(TCPC_TX_SOP,
+	TEST_EQ(verify_tcpci_tx_with_data(TCPCI_MSG_SOP,
 				0x1F,
 				data,
 				sizeof(data),
diff --git a/test/usb_tcpmv2_td_pd_src3_e7.c b/test/usb_tcpmv2_td_pd_src3_e7.c
index f018af849b..409d0d6b80 100644
--- a/test/usb_tcpmv2_td_pd_src3_e7.c
+++ b/test/usb_tcpmv2_td_pd_src3_e7.c
@@ -63,18 +63,18 @@ int test_td_pd_src3_e7(void)
 	 */
 	TEST_EQ(proc_pd_e3(), EC_SUCCESS, "%d");
 
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
 
 	/*
 	 * c) If a Not_Supported message is received, and Num_Fixed_Batteries
 	 *    and Num_Swappable_Battery_Slots in the VIF are 0, the test
 	 *    passes and stops here.
 	 */
-	possible[0].tx_type = TCPC_TX_SOP;
+	possible[0].tx_type = TCPCI_MSG_SOP;
 	possible[0].ctrl_msg = PD_CTRL_NOT_SUPPORTED;
 	possible[0].data_msg = 0;
 
-	possible[1].tx_type = TCPC_TX_SOP;
+	possible[1].tx_type = TCPCI_MSG_SOP;
 	possible[1].ctrl_msg = 0;
 	possible[1].data_msg = PD_EXT_SOURCE_CAP;
 
@@ -117,7 +117,7 @@ int test_td_pd_src3_e7(void)
 	ext_msg = EXT_MSG_CHUNKED |
 		  EXT_MSG_DATA_SIZE_1 |
 		  GBSDB_FIXED_BATTERY_0;
-	partner_send_msg(TCPC_TX_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
+	partner_send_msg(TCPCI_MSG_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
 			&ext_msg);
 
 	/*
@@ -127,7 +127,7 @@ int test_td_pd_src3_e7(void)
 	 *    been transmitted to the time the first bit of the Battery_Status
 	 *    message preamble has been received.
 	 */
-	TEST_EQ(verify_tcpci_tx_timeout(TCPC_TX_SOP,
+	TEST_EQ(verify_tcpci_tx_timeout(TCPCI_MSG_SOP,
 					0,
 					PD_DATA_BATTERY_STATUS,
 					(15 * MSEC)),
diff --git a/test/usb_tcpmv2_td_pd_src3_e8.c b/test/usb_tcpmv2_td_pd_src3_e8.c
index 5dfc551cba..dee52f1753 100644
--- a/test/usb_tcpmv2_td_pd_src3_e8.c
+++ b/test/usb_tcpmv2_td_pd_src3_e8.c
@@ -74,17 +74,17 @@ int test_td_pd_src3_e8(void)
 	 */
 	TEST_EQ(proc_pd_e3(), EC_SUCCESS, "%d");
 
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
 
 	/*
 	 * c) If a Source_Capabilities_Extended message is received, the
 	 *    Tester record the Number of Batteries/Battery Slots field.
 	 */
-	possible[0].tx_type = TCPC_TX_SOP;
+	possible[0].tx_type = TCPCI_MSG_SOP;
 	possible[0].ctrl_msg = PD_CTRL_NOT_SUPPORTED;
 	possible[0].data_msg = 0;
 
-	possible[1].tx_type = TCPC_TX_SOP;
+	possible[1].tx_type = TCPCI_MSG_SOP;
 	possible[1].ctrl_msg = 0;
 	possible[1].data_msg = PD_EXT_SOURCE_CAP;
 
@@ -143,14 +143,14 @@ int test_td_pd_src3_e8(void)
 
 		ext_msg = EXT_MSG_CHUNKED | EXT_MSG_DATA_SIZE_1 |
 			  (ref << 16);
-		partner_send_msg(TCPC_TX_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
+		partner_send_msg(TCPCI_MSG_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
 				 &ext_msg);
 
 		/*
 		 * e) If a Battery_Status message is received, the Tester
 		 *    verifies:
 		 */
-		TEST_EQ(verify_tcpci_tx_with_data(TCPC_TX_SOP,
+		TEST_EQ(verify_tcpci_tx_with_data(TCPCI_MSG_SOP,
 						  PD_DATA_BATTERY_STATUS,
 						  data,
 						  sizeof(data),
diff --git a/test/usb_tcpmv2_td_pd_src3_e9.c b/test/usb_tcpmv2_td_pd_src3_e9.c
index ecf0c745ff..faeed0922d 100644
--- a/test/usb_tcpmv2_td_pd_src3_e9.c
+++ b/test/usb_tcpmv2_td_pd_src3_e9.c
@@ -70,17 +70,17 @@ int test_td_pd_src3_e9(void)
 	 */
 	TEST_EQ(proc_pd_e3(), EC_SUCCESS, "%d");
 
-	partner_send_msg(TCPC_TX_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
+	partner_send_msg(TCPCI_MSG_SOP, PD_CTRL_GET_SOURCE_CAP_EXT, 0, 0, NULL);
 
 	/*
 	 * c) If a Source_Capabilities_Extended message is received, the
 	 *    Tester record the Number of Batteries/Battery Slots field.
 	 */
-	possible[0].tx_type = TCPC_TX_SOP;
+	possible[0].tx_type = TCPCI_MSG_SOP;
 	possible[0].ctrl_msg = PD_CTRL_NOT_SUPPORTED;
 	possible[0].data_msg = 0;
 
-	possible[1].tx_type = TCPC_TX_SOP;
+	possible[1].tx_type = TCPCI_MSG_SOP;
 	possible[1].ctrl_msg = 0;
 	possible[1].data_msg = PD_EXT_SOURCE_CAP;
 
@@ -135,7 +135,7 @@ int test_td_pd_src3_e9(void)
 	ref = 8;
 	ext_msg = EXT_MSG_CHUNKED | EXT_MSG_DATA_SIZE_1 |
 		  (ref << 16);
-	partner_send_msg(TCPC_TX_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
+	partner_send_msg(TCPCI_MSG_SOP, PD_EXT_GET_BATTERY_STATUS, 1, 1,
 			 &ext_msg);
 
 	/*
@@ -145,11 +145,11 @@ int test_td_pd_src3_e9(void)
 	 *    2. If the recorded Number of Batteries/Battery Slots field is
 	 *       not 0, the test fails.
 	 */
-	possible[0].tx_type = TCPC_TX_SOP;
+	possible[0].tx_type = TCPCI_MSG_SOP;
 	possible[0].ctrl_msg = PD_CTRL_NOT_SUPPORTED;
 	possible[0].data_msg = 0;
 
-	possible[1].tx_type = TCPC_TX_SOP;
+	possible[1].tx_type = TCPCI_MSG_SOP;
 	possible[1].ctrl_msg = 0;
 	possible[1].data_msg = PD_DATA_BATTERY_STATUS;
 
diff --git a/test/usb_tcpmv2_td_pd_src_e1.c b/test/usb_tcpmv2_td_pd_src_e1.c
index 90204a6106..a617f90ca2 100644
--- a/test/usb_tcpmv2_td_pd_src_e1.c
+++ b/test/usb_tcpmv2_td_pd_src_e1.c
@@ -38,7 +38,7 @@ int test_td_pd_src_e1(void)
 	 *    is not received from the Provider within 250 ms (tFirstSourceCap
 	 *    max) after VBus present.
 	 */
-	TEST_EQ(verify_tcpci_tx_timeout(TCPC_TX_SOP, 0,
+	TEST_EQ(verify_tcpci_tx_timeout(TCPCI_MSG_SOP, 0,
 					PD_DATA_SOURCE_CAP,
 					250 * MSEC),
 		EC_SUCCESS, "%d");
diff --git a/test/usb_tcpmv2_td_pd_src_e2.c b/test/usb_tcpmv2_td_pd_src_e2.c
index c8b862db28..f0e1b64c7e 100644
--- a/test/usb_tcpmv2_td_pd_src_e2.c
+++ b/test/usb_tcpmv2_td_pd_src_e2.c
@@ -63,7 +63,7 @@ int test_td_pd_src_e2(void)
 	 *    Provider, if the Specification Revision field is 10b
 	 *    (Rev 3.0), the test passes and stops here,
 	 */
-	TEST_EQ(verify_tcpci_tx_with_data(TCPC_TX_SOP,
+	TEST_EQ(verify_tcpci_tx_with_data(TCPCI_MSG_SOP,
 					  PD_DATA_SOURCE_CAP,
 					  data,
 					  sizeof(data),
diff --git a/test/usb_tcpmv2_td_pd_src_e5.c b/test/usb_tcpmv2_td_pd_src_e5.c
index 52cb88b098..eac1b93e8f 100644
--- a/test/usb_tcpmv2_td_pd_src_e5.c
+++ b/test/usb_tcpmv2_td_pd_src_e5.c
@@ -41,7 +41,7 @@ int test_td_pd_src_e5(void)
 	 * b) Upon receipt of the Source Capabilities message from the
 	 *    Provider, the Tester replies with a GoodCRC message.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, 0, PD_DATA_SOURCE_CAP),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, 0, PD_DATA_SOURCE_CAP),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 
@@ -64,19 +64,19 @@ int test_td_pd_src_e5(void)
 	end_time += 24 * MSEC;
 	while (get_time().val < end_time) {
 		TEST_NE(mock_tcpci_get_reg(TCPC_REG_TRANSMIT),
-			TCPC_TX_HARD_RESET, "%d");
+			TCPCI_MSG_TX_HARD_RESET, "%d");
 		task_wait_event(1 * MSEC);
 	}
 
 	end_time += 6 * MSEC;
 	while (get_time().val < end_time) {
 		if (mock_tcpci_get_reg(TCPC_REG_TRANSMIT) ==
-						TCPC_TX_HARD_RESET)
+						TCPCI_MSG_TX_HARD_RESET)
 			break;
 		task_wait_event(1 * MSEC);
 	}
 	TEST_EQ(mock_tcpci_get_reg(TCPC_REG_TRANSMIT),
-		TCPC_TX_HARD_RESET, "%d");
+		TCPCI_MSG_TX_HARD_RESET, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS | TCPC_REG_ALERT_TX_FAILED);
 	mock_tcpci_set_reg(TCPC_REG_TRANSMIT, 0);
 	task_wait_event(1 * MSEC);
diff --git a/test/usb_tcpmv2_td_pd_vndi3_e3.c b/test/usb_tcpmv2_td_pd_vndi3_e3.c
index ef16128934..cbfc0d75e3 100644
--- a/test/usb_tcpmv2_td_pd_vndi3_e3.c
+++ b/test/usb_tcpmv2_td_pd_vndi3_e3.c
@@ -43,7 +43,7 @@ static int td_pd_vndi3_e3(enum pd_data_role data_role)
 	/*
 	 * b) Tester executes a Discover Identity exchange
 	 */
-	partner_send_msg(TCPC_TX_SOP, PD_DATA_VENDOR_DEF,
+	partner_send_msg(TCPCI_MSG_SOP, PD_DATA_VENDOR_DEF,
 			 1, 0, &vdo);
 
 	/*
@@ -51,7 +51,7 @@ static int td_pd_vndi3_e3(enum pd_data_role data_role)
 	 * No, the tester checks that the UUT replies Not_Supported.  The test
 	 * stops here in this case.
 	 */
-	TEST_EQ(verify_tcpci_transmit(TCPC_TX_SOP, PD_CTRL_NOT_SUPPORTED, 0),
+	TEST_EQ(verify_tcpci_transmit(TCPCI_MSG_SOP, PD_CTRL_NOT_SUPPORTED, 0),
 		EC_SUCCESS, "%d");
 	mock_set_alert(TCPC_REG_ALERT_TX_SUCCESS);
 
diff --git a/zephyr/projects/herobrine/herobrine_npcx9/src/usb_pd_policy.c b/zephyr/projects/herobrine/herobrine_npcx9/src/usb_pd_policy.c
index 87d47c32e2..c17ca0c565 100644
--- a/zephyr/projects/herobrine/herobrine_npcx9/src/usb_pd_policy.c
+++ b/zephyr/projects/herobrine/herobrine_npcx9/src/usb_pd_policy.c
@@ -91,7 +91,7 @@ int pd_snk_is_vbus_provided(int port)
 #ifdef CONFIG_USB_PD_ALT_MODE_DFP
 __override int svdm_dp_config(int port, uint32_t *payload)
 {
-	int opos = pd_alt_mode(port, TCPC_TX_SOP, USB_SID_DISPLAYPORT);
+	int opos = pd_alt_mode(port, TCPCI_MSG_SOP, USB_SID_DISPLAYPORT);
 	uint8_t pin_mode = get_dp_pin_mode(port);
 
 	if (!pin_mode)