diff options
author | Abe Levkoy <alevkoy@chromium.org> | 2021-08-27 15:21:39 -0600 |
---|---|---|
committer | Commit Bot <commit-bot@chromium.org> | 2021-08-31 18:18:20 +0000 |
commit | 003ec08f8c67845ae8481d3fb4124555213b04c4 (patch) | |
tree | 3502c59532731d0003532657b1a2993e8ca9ad81 | |
parent | 5fa669005c3779b7310bf6bfe43f741a3d8ae871 (diff) | |
download | chrome-ec-003ec08f8c67845ae8481d3fb4124555213b04c4.tar.gz |
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 |= 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 |= 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 |= 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 |= 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) |