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>

22 files changed, 141 insertions, 141 deletions

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);