diff options
99 files changed, 1051 insertions, 1001 deletions
diff --git a/baseboard/dragonegg/baseboard.c b/baseboard/dragonegg/baseboard.c index 85c39296f6..aa2ee875b7 100644 --- a/baseboard/dragonegg/baseboard.c +++ b/baseboard/dragonegg/baseboard.c @@ -200,19 +200,21 @@ struct ppc_config_t ppc_chips[CONFIG_USB_PD_PORT_MAX_COUNT] = { }; unsigned int ppc_cnt = ARRAY_SIZE(ppc_chips); -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ITE_0] = { + .usb_port = USB_PD_PORT_ITE_0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, [USB_PD_PORT_ITE_1] = { + .usb_port = USB_PD_PORT_ITE_1, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, [USB_PD_PORT_TUSB422_2] = { - .port_addr = 0, + .usb_port = USB_PD_PORT_TUSB422_2, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, diff --git a/baseboard/grunt/baseboard.c b/baseboard/grunt/baseboard.c index 5ab7dc8d53..82bf063bf9 100644 --- a/baseboard/grunt/baseboard.c +++ b/baseboard/grunt/baseboard.c @@ -135,8 +135,6 @@ void tcpc_alert_event(enum gpio_signal signal) void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) board_reset_pd_mcu(); @@ -157,11 +155,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C + 1); @@ -280,28 +275,31 @@ void board_reset_pd_mcu(void) static uint32_t sku_id; -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* Tune USB mux registers for treeya's port 1 Rx measurement */ if ((sku_id >= 0xa0) && (sku_id <= 0xaf)) - mux_write(port, PS8XXX_REG_MUX_USB_C2SS_EQ, 0x40); + mux_write(me, PS8XXX_REG_MUX_USB_C2SS_EQ, 0x40); return EC_SUCCESS; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { #ifdef VARIANT_GRUNT_TCPC_0_ANX3429 [USB_PD_PORT_ANX74XX] = { + .usb_port = USB_PD_PORT_ANX74XX, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, #elif defined(VARIANT_GRUNT_TCPC_0_ANX3447) [USB_PD_PORT_ANX74XX] = { + .usb_port = USB_PD_PORT_ANX74XX, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, #endif [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, diff --git a/baseboard/grunt/usb_pd_policy.c b/baseboard/grunt/usb_pd_policy.c index 4edee5f232..0d2e41b64a 100644 --- a/baseboard/grunt/usb_pd_policy.c +++ b/baseboard/grunt/usb_pd_policy.c @@ -129,8 +129,6 @@ __override int svdm_dp_config(int port, uint32_t *payload) #define PORT_TO_HPD(port) ((port) ? GPIO_USB_C1_DP_HPD : GPIO_USB_C0_DP_HPD) __override void svdm_dp_post_config(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - /* Connect the SBU and USB lines to the connector. */ ppc_set_sbu(port, 1); usb_mux_set(port, svdm_dp_mux_mode(port), USB_SWITCH_CONNECT, @@ -144,7 +142,7 @@ __override void svdm_dp_post_config(int port) /* set the minimum time delay (2ms) for the next HPD IRQ */ svdm_hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; - mux->hpd_update(port, 1, 0); + usb_mux_hpd_update(port, 1, 0); } #endif /* CONFIG_USB_PD_ALT_MODE_DFP */ diff --git a/baseboard/intelrvp/retimer.c b/baseboard/intelrvp/retimer.c index a444806062..0397057641 100644 --- a/baseboard/intelrvp/retimer.c +++ b/baseboard/intelrvp/retimer.c @@ -29,19 +29,4 @@ const struct bb_usb_control bb_controls[] = { }; BUILD_ASSERT(ARRAY_SIZE(bb_controls) == CONFIG_USB_PD_PORT_MAX_COUNT); -struct usb_retimer usb_retimers[] = { - [TYPE_C_PORT_0] = { - .driver = &bb_usb_retimer, - .i2c_port = I2C_PORT0_BB_RETIMER, - .i2c_addr_flags = I2C_PORT0_BB_RETIMER_ADDR, - }, -#ifdef HAS_TASK_PD_C1 - [TYPE_C_PORT_1] = { - .driver = &bb_usb_retimer, - .i2c_port = I2C_PORT1_BB_RETIMER, - .i2c_addr_flags = I2C_PORT1_BB_RETIMER_ADDR, - }, -#endif /* HAS_TASK_PD_C1 */ -}; -BUILD_ASSERT(ARRAY_SIZE(usb_retimers) == CONFIG_USB_PD_PORT_MAX_COUNT); #endif /* CONFIG_USBC_RETIMER_INTEL_BB */ diff --git a/baseboard/intelrvp/usb_mux.c b/baseboard/intelrvp/usb_mux.c index 2dee2bf759..644ae1735c 100644 --- a/baseboard/intelrvp/usb_mux.c +++ b/baseboard/intelrvp/usb_mux.c @@ -7,20 +7,46 @@ #include "common.h" #include "anx7440.h" +#include "bb_retimer.h" #include "timer.h" #include "usb_mux.h" +#ifdef CONFIG_USBC_RETIMER_INTEL_BB +struct usb_mux usbc0_retimer = { + .usb_port = TYPE_C_PORT_0, + .driver = &bb_usb_retimer, + .i2c_port = I2C_PORT0_BB_RETIMER, + .i2c_addr_flags = I2C_PORT0_BB_RETIMER_ADDR, +}; +#ifdef HAS_TASK_PD_C1 +struct usb_mux usbc1_retimer = { + .usb_port = TYPE_C_PORT_1, + .driver = &bb_usb_retimer, + .i2c_port = I2C_PORT1_BB_RETIMER, + .i2c_addr_flags = I2C_PORT1_BB_RETIMER_ADDR, +}; +#endif /* HAS_TASK_PD_C1 */ +#endif + /* USB muxes Configuration */ #ifdef CONFIG_USB_MUX_VIRTUAL -struct usb_mux usb_muxes[] = { +const struct usb_mux usb_muxes[] = { [TYPE_C_PORT_0] = { + .usb_port = TYPE_C_PORT_0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, +#ifdef CONFIG_USBC_RETIMER_INTEL_BB + .next_mux = &usbc0_retimer, +#endif }, #ifdef HAS_TASK_PD_C1 [TYPE_C_PORT_1] = { + .usb_port = TYPE_C_PORT_1, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, +#ifdef CONFIG_USBC_RETIMER_INTEL_BB + .next_mux = &usbc1_retimer, +#endif }, #endif /* HAS_TASK_PD_C1 */ }; @@ -28,15 +54,25 @@ BUILD_ASSERT(ARRAY_SIZE(usb_muxes) == CONFIG_USB_PD_PORT_MAX_COUNT); #endif /* CONFIG_USB_MUX_VIRTUAL */ #ifdef CONFIG_USB_MUX_ANX7440 -struct usb_mux usb_muxes[] = { +const struct usb_mux usb_muxes[] = { [TYPE_C_PORT_0] = { - .port_addr = I2C_ADDR_USB_MUX0_FLAGS, + .usb_port = TYPE_C_PORT_0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = I2C_ADDR_USB_MUX0_FLAGS, .driver = &anx7440_usb_mux_driver, +#ifdef CONFIG_USBC_RETIMER_INTEL_BB + .next_mux = &usbc0_retimer, +#endif }, #ifdef HAS_TASK_PD_C1 [TYPE_C_PORT_1] = { - .port_addr = I2C_ADDR_USB_MUX1_FLAGS, + .usb_port = TYPE_C_PORT_1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = I2C_ADDR_USB_MUX1_FLAGS, .driver = &anx7440_usb_mux_driver, +#ifdef CONFIG_USBC_RETIMER_INTEL_BB + .next_mux = &usbc1_retimer, +#endif }, #endif /* HAS_TASK_PD_C1 */ }; diff --git a/baseboard/kalista/baseboard.c b/baseboard/kalista/baseboard.c index 859962b07c..6592033c83 100644 --- a/baseboard/kalista/baseboard.c +++ b/baseboard/kalista/baseboard.c @@ -150,19 +150,20 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* 0x98 sets lower EQ of DP port (4.5db) */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); return EC_SUCCESS; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, - } + }, }; const int usb_port_enable[USB_PORT_COUNT] = { @@ -181,7 +182,7 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port, reg; + int reg; /* This needs to be executed only once per boot. It could be run by RO * if we boot in recovery mode. It could be run by RW if we boot in @@ -202,10 +203,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/baseboard/kukui/usb_pd_policy.c b/baseboard/kukui/usb_pd_policy.c index 0925c1b329..b2d56e23b2 100644 --- a/baseboard/kukui/usb_pd_policy.c +++ b/baseboard/kukui/usb_pd_policy.c @@ -179,8 +179,6 @@ __override int svdm_dp_config(int port, uint32_t *payload) __override void svdm_dp_post_config(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - dp_flags[port] |= DP_FLAGS_DP_ON; if (!(dp_flags[port] & DP_FLAGS_HPD_HI_PENDING)) return; @@ -192,7 +190,8 @@ __override void svdm_dp_post_config(int port) /* set the minimum time delay (2ms) for the next HPD IRQ */ svdm_hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; - mux->hpd_update(port, 1, 0); + + usb_mux_hpd_update(port, 1, 0); } __override int svdm_dp_attention(int port, uint32_t *payload) @@ -200,7 +199,6 @@ __override int svdm_dp_attention(int port, uint32_t *payload) int cur_lvl = gpio_get_level(GPIO_USB_C0_HPD_OD); int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]); int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]); - const struct usb_mux * const mux = &usb_muxes[port]; dp_status[port] = payload[1]; @@ -211,7 +209,7 @@ __override int svdm_dp_attention(int port, uint32_t *payload) return 1; } - mux->hpd_update(port, lvl, irq); + usb_mux_hpd_update(port, lvl, irq); if (irq & cur_lvl) { uint64_t now = get_time().val; @@ -250,13 +248,11 @@ __override int svdm_dp_attention(int port, uint32_t *payload) __override void svdm_exit_dp_mode(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - svdm_safe_dp_mode(port); gpio_set_level(GPIO_USB_C0_HPD_OD, 0); #ifdef VARIANT_KUKUI_DP_MUX_GPIO board_set_dp_mux_control(0, 0); #endif - mux->hpd_update(port, 0, 0); + usb_mux_hpd_update(port, 0, 0); } #endif /* CONFIG_USB_PD_ALT_MODE_DFP */ diff --git a/baseboard/octopus/baseboard.c b/baseboard/octopus/baseboard.c index cd9296cd19..ceb32868a0 100644 --- a/baseboard/octopus/baseboard.c +++ b/baseboard/octopus/baseboard.c @@ -216,8 +216,6 @@ enum adc_channel board_get_vbus_adc(int port) void baseboard_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) board_reset_pd_mcu(); @@ -226,11 +224,8 @@ void baseboard_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } /* Called after the cbi_init (via +2) */ DECLARE_HOOK(HOOK_INIT, baseboard_tcpc_init, HOOK_PRIO_INIT_I2C + 2); diff --git a/baseboard/octopus/variant_usbc_ec_tcpcs.c b/baseboard/octopus/variant_usbc_ec_tcpcs.c index a247ef6452..cbc5fd79e0 100644 --- a/baseboard/octopus/variant_usbc_ec_tcpcs.c +++ b/baseboard/octopus/variant_usbc_ec_tcpcs.c @@ -48,9 +48,10 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { /* USB-C MUX Configuration */ /* TODO(crbug.com/826441): Consolidate this logic with other impls */ -static void board_it83xx_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void board_it83xx_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { - enum gpio_signal gpio = port ? + enum gpio_signal gpio = me->usb_port ? GPIO_USB_C1_HPD_1V8_ODL : GPIO_USB_C0_HPD_1V8_ODL; /* Invert HPD level since GPIOs are active low. */ @@ -67,15 +68,17 @@ static void board_it83xx_hpd_status(int port, int hpd_lvl, int hpd_irq) /* This configuration might be override by each boards */ struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ITE_0] = { - /* Driver uses I2C_PORT_USB_MUX as I2C port */ - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = USB_PD_PORT_ITE_0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_it83xx_hpd_status, }, [USB_PD_PORT_ITE_1] = { + .usb_port = USB_PD_PORT_ITE_1, /* Use PS8751 as mux only */ - .port_addr = MUX_PORT_AND_ADDR( - I2C_PORT_USBC1, PS8751_I2C_ADDR1_FLAGS), + .i2c_port = I2C_PORT_USBC1, + .i2c_addr_flags = PS8751_I2C_ADDR1_FLAGS, .flags = USB_MUX_FLAG_NOT_TCPC, .driver = &ps8xxx_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, diff --git a/baseboard/octopus/variant_usbc_standalone_tcpcs.c b/baseboard/octopus/variant_usbc_standalone_tcpcs.c index 41025de7fa..18a8a3035a 100644 --- a/baseboard/octopus/variant_usbc_standalone_tcpcs.c +++ b/baseboard/octopus/variant_usbc_standalone_tcpcs.c @@ -61,16 +61,17 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { /* USB-C MUX Configuration */ #if defined(VARIANT_OCTOPUS_TCPC_0_PS8751) -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* Tune USB mux registers for casta's port 0 Rx measurement */ - mux_write(port, PS8XXX_REG_MUX_USB_C2SS_EQ, 0x40); + mux_write(me, PS8XXX_REG_MUX_USB_C2SS_EQ, 0x40); return EC_SUCCESS; } #endif -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, #if defined(VARIANT_OCTOPUS_TCPC_0_PS8751) .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, @@ -81,6 +82,7 @@ struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { #endif }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/baseboard/volteer/baseboard.c b/baseboard/volteer/baseboard.c index 53b3a0d146..24e08b514b 100644 --- a/baseboard/volteer/baseboard.c +++ b/baseboard/volteer/baseboard.c @@ -396,14 +396,23 @@ unsigned int ppc_cnt = ARRAY_SIZE(ppc_chips); /******************************************************************************/ /* USBC mux configuration - Tiger Lake includes internal mux */ +struct usb_mux usbc1_usb_retimer = { + .usb_port = USBC_PORT_C1, + .driver = &bb_usb_retimer, + .i2c_port = I2C_PORT_USB_1_MIX, + .i2c_addr_flags = USBC_PORT_C1_BB_RETIMER_I2C_ADDR, +}; struct usb_mux usb_muxes[] = { [USBC_PORT_C0] = { + .usb_port = USBC_PORT_C0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, [USBC_PORT_C1] = { + .usb_port = USBC_PORT_C1, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, + .next_mux = &usbc1_usb_retimer, }, }; BUILD_ASSERT(ARRAY_SIZE(usb_muxes) == USBC_PORT_COUNT); @@ -421,18 +430,6 @@ struct bb_usb_control bb_controls[] = { }; BUILD_ASSERT(ARRAY_SIZE(bb_controls) == USBC_PORT_COUNT); -struct usb_retimer usb_retimers[] = { - [USBC_PORT_C0] = { - /* USB-C port 0 doesn't have a retimer */ - }, - [USBC_PORT_C1] = { - .driver = &bb_usb_retimer, - .i2c_port = I2C_PORT_USB_1_MIX, - .i2c_addr_flags = USBC_PORT_C1_BB_RETIMER_I2C_ADDR, - }, -}; -BUILD_ASSERT(ARRAY_SIZE(usb_retimers) == USBC_PORT_COUNT); - static void baseboard_tcpc_init(void) { /* Only reset TCPC if not sysjump */ @@ -660,8 +657,7 @@ static void config_db_usb3(void) { tcpc_config[USBC_PORT_C1] = tcpc_config_p1_usb3; /* USB-C port 1 has an integrated retimer */ - memset(&usb_retimers[USBC_PORT_C1], 0, - sizeof(usb_retimers[USBC_PORT_C1])); + usb_muxes[USBC_PORT_C1].next_mux = NULL; } /* diff --git a/baseboard/volteer/baseboard.h b/baseboard/volteer/baseboard.h index 0f53a0eb65..a9d1816fea 100644 --- a/baseboard/volteer/baseboard.h +++ b/baseboard/volteer/baseboard.h @@ -184,6 +184,8 @@ #define CONFIG_USB_PD_VBUS_DETECT_PPC #define CONFIG_USB_PD_VBUS_MEASURE_NOT_PRESENT +#define CONFIG_USB_MUX_RUNTIME_CONFIG + #define CONFIG_USBC_PPC #define CONFIG_CMD_PPC_DUMP /* Note - SN5S330 support automatically adds @@ -224,7 +226,6 @@ #define PD_VCONN_SWAP_DELAY 5000 /* us */ /* Retimer */ -#define CONFIG_USBC_MUX_RETIMER #define CONFIG_USBC_RETIMER_INTEL_BB #define CONFIG_USBC_RETIMER_INTEL_BB_RUNTIME_CONFIG #define USBC_PORT_C1_BB_RETIMER_I2C_ADDR 0x40 diff --git a/baseboard/zork/baseboard.c b/baseboard/zork/baseboard.c index f64a911f94..69a61681ff 100644 --- a/baseboard/zork/baseboard.c +++ b/baseboard/zork/baseboard.c @@ -23,7 +23,6 @@ #include "driver/retimer/pi3dpx1207.h" #include "driver/retimer/ps8802.h" #include "driver/retimer/ps8818.h" -#include "driver/tcpm/ps8xxx.h" #include "driver/tcpm/nct38xx.h" #include "driver/temp_sensor/sb_tsi.h" #include "driver/usb_mux/amd_fp5.h" @@ -440,19 +439,19 @@ void bc12_interrupt(enum gpio_signal signal) * PS8802 set mux tuning. * Adds in board specific gain and DP lane count configuration */ -static int ps8802_tune_mux(int port, mux_state_t mux_state) +static int ps8802_mux_set(const struct usb_mux *me, mux_state_t mux_state) { int rv = EC_SUCCESS; /* Make sure the PS8802 is awake */ - rv = ps8802_i2c_wake(port); + rv = ps8802_i2c_wake(me); if (rv) return rv; /* USB specific config */ if (mux_state & USB_PD_MUX_USB_ENABLED) { /* Boost the USB gain */ - rv = ps8802_i2c_field_update16(port, + rv = ps8802_i2c_field_update16(me, PS8802_REG_PAGE2, PS8802_REG2_USB_SSEQ_LEVEL, PS8802_USBEQ_LEVEL_UP_MASK, @@ -464,7 +463,7 @@ static int ps8802_tune_mux(int port, mux_state_t mux_state) /* DP specific config */ if (mux_state & USB_PD_MUX_DP_ENABLED) { /* Boost the DP gain */ - rv = ps8802_i2c_field_update8(port, + rv = ps8802_i2c_field_update8(me, PS8802_REG_PAGE2, PS8802_REG2_DPEQ_LEVEL, PS8802_DPEQ_LEVEL_UP_MASK, @@ -486,14 +485,14 @@ static int ps8802_tune_mux(int port, mux_state_t mux_state) * PS8818 set mux tuning. * Adds in board specific gain and DP lane count configuration */ -static int ps8818_tune_mux(int port, mux_state_t mux_state) +static int ps8818_mux_set(const struct usb_mux *me, mux_state_t mux_state) { int rv = EC_SUCCESS; /* USB specific config */ if (mux_state & USB_PD_MUX_USB_ENABLED) { /* Boost the USB gain */ - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE1, PS8818_REG1_APTX1EQ_10G_LEVEL, PS8818_EQ_LEVEL_UP_MASK, @@ -501,7 +500,7 @@ static int ps8818_tune_mux(int port, mux_state_t mux_state) if (rv) return rv; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE1, PS8818_REG1_APTX2EQ_10G_LEVEL, PS8818_EQ_LEVEL_UP_MASK, @@ -509,7 +508,7 @@ static int ps8818_tune_mux(int port, mux_state_t mux_state) if (rv) return rv; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE1, PS8818_REG1_APTX1EQ_5G_LEVEL, PS8818_EQ_LEVEL_UP_MASK, @@ -517,7 +516,7 @@ static int ps8818_tune_mux(int port, mux_state_t mux_state) if (rv) return rv; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE1, PS8818_REG1_APTX2EQ_5G_LEVEL, PS8818_EQ_LEVEL_UP_MASK, @@ -529,7 +528,7 @@ static int ps8818_tune_mux(int port, mux_state_t mux_state) /* DP specific config */ if (mux_state & USB_PD_MUX_DP_ENABLED) { /* Boost the DP gain */ - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE1, PS8818_REG1_DPEQ_LEVEL, PS8818_DPEQ_LEVEL_UP_MASK, @@ -548,47 +547,15 @@ static int ps8818_tune_mux(int port, mux_state_t mux_state) } /* - * FP5 is a true MUX but being used as a secondary MUX. Don't want to - * send FLIP or this will cause a double flip - */ -static int zork_c1_retimer_set_mux(int port, mux_state_t mux_state) -{ - return amd_fp5_usb_retimer.set(port, - mux_state & ~USB_PD_MUX_POLARITY_INVERTED); -} - -const struct usb_retimer_driver zork_c1_usb_retimer = { - /* Secondary MUX/Retimer only needs the set mux interface */ - .set = zork_c1_retimer_set_mux, -}; - -struct usb_retimer usb_retimers[] = { - [USBC_PORT_C0] = { - .driver = &pi3dpx1207_usb_retimer, - .i2c_port = I2C_PORT_TCPC0, - .i2c_addr_flags = PI3DPX1207_I2C_ADDR_FLAGS, - }, - [USBC_PORT_C1] = { - /* - * The driver is left off until we detect the - * hardware present. Once the hardware has been - * detected, the driver will be set to the - * detected hardware driver table. - */ - .i2c_port = I2C_PORT_TCPC1, - }, -}; -BUILD_ASSERT(ARRAY_SIZE(usb_retimers) == USBC_PORT_COUNT); - -/* * To support both OPT1 DB with PS8818 retimer, and OPT3 DB with PS8802 * retimer, Try both, and remember the first one that succeeds. - * - * TODO(b:147593660) Cleanup of retimers as muxes in a more - * generalized mechanism */ +const struct usb_mux usbc1_ps8802; +const struct usb_mux usbc1_ps8818; +struct usb_mux usbc1_amd_fp5_usb_mux; + enum zork_c1_retimer zork_c1_retimer = C1_RETIMER_UNKNOWN; -static int zork_c1_detect(int port, int err_if_power_off) +static int zork_c1_detect(const struct usb_mux *me, int err_if_power_off) { int rv; @@ -604,29 +571,30 @@ static int zork_c1_detect(int port, int err_if_power_off) * Identifying a PS8818 is faster than the PS8802, * so do it first. */ - usb_retimers[port].i2c_addr_flags = PS8818_I2C_ADDR_FLAGS; - rv = ps8818_detect(port); + rv = ps8818_detect(&usbc1_ps8818); if (rv == EC_SUCCESS) { zork_c1_retimer = C1_RETIMER_PS8818; ccprints("C1 PS8818 detected"); /* Main MUX is FP5, secondary MUX is PS8818 */ - usb_muxes[USBC_PORT_C1].driver = &amd_fp5_usb_mux_driver; - usb_retimers[USBC_PORT_C1].driver = &ps8818_usb_retimer; - usb_retimers[USBC_PORT_C1].tune = &ps8818_tune_mux; + memcpy(&usb_muxes[USBC_PORT_C1], + &usbc1_amd_fp5_usb_mux, + sizeof(struct usb_mux)); + usb_muxes[USBC_PORT_C1].next_mux = &usbc1_ps8818; return rv; } - usb_retimers[port].i2c_addr_flags = PS8802_I2C_ADDR_FLAGS; - rv = ps8802_detect(port); + rv = ps8802_detect(&usbc1_ps8802); if (rv == EC_SUCCESS) { zork_c1_retimer = C1_RETIMER_PS8802; ccprints("C1 PS8802 detected"); /* Main MUX is PS8802, secondary MUX is modified FP5 */ - usb_muxes[USBC_PORT_C1].driver = &ps8802_usb_mux_driver; - usb_retimers[USBC_PORT_C1].driver = &zork_c1_usb_retimer; - usb_retimers[USBC_PORT_C1].tune = &ps8802_tune_mux; + memcpy(&usb_muxes[USBC_PORT_C1], + &usbc1_ps8802, + sizeof(struct usb_mux)); + usb_muxes[USBC_PORT_C1].next_mux = &usbc1_amd_fp5_usb_mux; + usbc1_amd_fp5_usb_mux.flags = USB_MUX_FLAG_SET_WITHOUT_FLIP; } return rv; @@ -637,14 +605,36 @@ static int zork_c1_detect(int port, int err_if_power_off) * the interface to be this special primary MUX driver in order to * determine the actual hardware and then we patch the jump tables * to go to the actual drivers instead. + * + * "me" will always point to usb_muxes[0]. If detection is made + * on the real device, then detect will change the tables so the + * content of me is the real driver configuration and will setup + * next_mux appropriately. So all we have to do on detection is + * perform the actual call for this entry and then let the generic + * chain traverse mechanism in usb_mux.c do any following calls. */ -static int zork_c1_init_mux(int port) +static int zork_c1_init_mux(const struct usb_mux *me) { + int rv; + /* Try to detect, but don't give an error if no power */ - return zork_c1_detect(port, 0); + rv = zork_c1_detect(me, 0); + if (rv) + return rv; + + /* + * If we detected the hardware, then call the real routine. + * We only do this one time, after that time we will go direct + * and avoid this special driver. + */ + if (zork_c1_retimer != C1_RETIMER_UNKNOWN) + if (me->driver && me->driver->init) + rv = me->driver->init(me); + + return rv; } -static int zork_c1_set_mux(int port, mux_state_t mux_state) +static int zork_c1_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int rv; @@ -652,7 +642,7 @@ static int zork_c1_set_mux(int port, mux_state_t mux_state) * Try to detect, give an error if we are setting to a * MUX value that is not NONE when we have no power. */ - rv = zork_c1_detect(port, mux_state != USB_PD_MUX_NONE); + rv = zork_c1_detect(me, mux_state != USB_PD_MUX_NONE); if (rv) return rv; @@ -661,18 +651,35 @@ static int zork_c1_set_mux(int port, mux_state_t mux_state) * We only do this one time, after that time we will go direct * and avoid this special driver. */ - if (zork_c1_retimer != C1_RETIMER_UNKNOWN) - rv = usb_muxes[port].driver->set(port, mux_state); + if (zork_c1_retimer != C1_RETIMER_UNKNOWN) { + const struct usb_mux_driver *drv = me->driver; + + if (drv && drv->set) { + mux_state_t state = mux_state; + + if (me->flags & USB_MUX_FLAG_SET_WITHOUT_FLIP) + state &= ~USB_PD_MUX_POLARITY_INVERTED; + + /* Apply Driver generic settings */ + rv = drv->set(me, state); + if (rv) + return rv; + + /* Apply Board specific settings */ + if (me->board_set) + rv = me->board_set(me, state); + } + } return rv; } -static int zork_c1_get_mux(int port, mux_state_t *mux_state) +static int zork_c1_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { int rv; /* Try to detect the hardware */ - rv = zork_c1_detect(port, 1); + rv = zork_c1_detect(me, 1); if (rv) { /* * Not powered is MUX_NONE, so change the values @@ -691,7 +698,8 @@ static int zork_c1_get_mux(int port, mux_state_t *mux_state) * and avoid this special driver. */ if (zork_c1_retimer != C1_RETIMER_UNKNOWN) - rv = usb_muxes[port].driver->get(port, mux_state); + if (me->driver && me->driver->get) + rv = me->driver->get(me, mux_state); return rv; } @@ -714,9 +722,37 @@ const struct usb_mux_driver zork_c1_usb_mux_driver = { .get = zork_c1_get_mux, }; +const struct usb_mux usbc0_pi3dpx1207_usb_retimer = { + .usb_port = USBC_PORT_C0, + .i2c_port = I2C_PORT_TCPC0, + .i2c_addr_flags = PI3DPX1207_I2C_ADDR_FLAGS, + .driver = &pi3dpx1207_usb_retimer, +}; + +const struct usb_mux usbc1_ps8802 = { + .usb_port = USBC_PORT_C1, + .i2c_port = I2C_PORT_TCPC1, + .i2c_addr_flags = PS8802_I2C_ADDR_FLAGS, + .driver = &ps8802_usb_mux_driver, + .board_set = &ps8802_mux_set, +}; +const struct usb_mux usbc1_ps8818 = { + .usb_port = USBC_PORT_C1, + .i2c_port = I2C_PORT_TCPC1, + .i2c_addr_flags = PS8818_I2C_ADDR_FLAGS, + .driver = &ps8818_usb_retimer_driver, + .board_set = &ps8818_mux_set, +}; +struct usb_mux usbc1_amd_fp5_usb_mux = { + .usb_port = USBC_PORT_C1, + .driver = &amd_fp5_usb_mux_driver, +}; + struct usb_mux usb_muxes[] = { [USBC_PORT_C0] = { + .usb_port = USBC_PORT_C0, .driver = &amd_fp5_usb_mux_driver, + .next_mux = &usbc0_pi3dpx1207_usb_retimer, }, [USBC_PORT_C1] = { /* @@ -724,11 +760,14 @@ struct usb_mux usb_muxes[] = { * has been detected, the driver will change to the * detected hardware driver table. */ + .usb_port = USBC_PORT_C1, + .i2c_port = I2C_PORT_TCPC1, .driver = &zork_c1_usb_mux_driver, - }, + } }; BUILD_ASSERT(ARRAY_SIZE(usb_muxes) == USBC_PORT_COUNT); + struct ioexpander_config_t ioex_config[] = { [USBC_PORT_C0] = { .i2c_host_port = I2C_PORT_TCPC0, diff --git a/baseboard/zork/baseboard.h b/baseboard/zork/baseboard.h index 61719b012c..b51f42b683 100644 --- a/baseboard/zork/baseboard.h +++ b/baseboard/zork/baseboard.h @@ -133,6 +133,7 @@ #define CONFIG_CMD_PD_CONTROL #define CONFIG_USB_CHARGER +#define CONFIG_USB_MUX_RUNTIME_CONFIG #define CONFIG_USB_POWER_DELIVERY #define CONFIG_USB_PD_ALT_MODE #define CONFIG_USB_PD_ALT_MODE_DFP @@ -147,7 +148,6 @@ #define CONFIG_USB_PD_TCPC_LOW_POWER #define CONFIG_USB_PD_TCPM_MUX #define CONFIG_USB_PD_TCPM_NCT38XX -#define CONFIG_USB_PD_TCPM_PS8751 #define CONFIG_USB_PD_TCPM_TCPCI #define CONFIG_USB_PD_TRY_SRC #define CONFIG_USB_PD_VBUS_DETECT_TCPC diff --git a/baseboard/zork/usb_pd_policy.c b/baseboard/zork/usb_pd_policy.c index 66433f9ac0..26cc885479 100644 --- a/baseboard/zork/usb_pd_policy.c +++ b/baseboard/zork/usb_pd_policy.c @@ -136,8 +136,6 @@ __override int svdm_dp_config(int port, uint32_t *payload) __override void svdm_dp_post_config(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - /* Connect the SBU and USB lines to the connector. */ ppc_set_sbu(port, 1); usb_mux_set(port, svdm_dp_mux_mode(port), USB_SWITCH_CONNECT, @@ -152,14 +150,11 @@ __override void svdm_dp_post_config(int port) /* set the minimum time delay (2ms) for the next HPD IRQ */ svdm_hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; - if (mux->hpd_update) - mux->hpd_update(port, 1, 0); + usb_mux_hpd_update(port, 1, 0); } __override void svdm_exit_dp_mode(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - dp_flags[port] = 0; dp_status[port] = 0; @@ -167,7 +162,6 @@ __override void svdm_exit_dp_mode(int port) pd_get_polarity(port)); gpio_set_level(PORT_TO_HPD(port), 0); - if (mux->hpd_update) - mux->hpd_update(port, 0, 0); + usb_mux_hpd_update(port, 0, 0); } #endif /* CONFIG_USB_PD_ALT_MODE_DFP */ diff --git a/board/akemi/board.c b/board/akemi/board.c index c2f6b14d76..ad5fce6d71 100644 --- a/board/akemi/board.c +++ b/board/akemi/board.c @@ -141,12 +141,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/ampton/board.c b/board/ampton/board.c index df151c8918..4f1f0880df 100644 --- a/board/ampton/board.c +++ b/board/ampton/board.c @@ -66,13 +66,14 @@ int ppc_get_alert_status(int port) #define USB_PD_PORT_ITE_0 0 #define USB_PD_PORT_ITE_1 1 -static int tune_mux(int port); +static int tune_mux(const struct usb_mux *me); -struct usb_mux ampton_usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux ampton_usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ITE_0] = { /* Use PS8751 as mux only */ - .port_addr = MUX_PORT_AND_ADDR( - I2C_PORT_USBC0, PS8751_I2C_ADDR1_FLAGS), + .usb_port = USB_PD_PORT_ITE_0, + .i2c_port = I2C_PORT_USBC0, + .i2c_addr_flags = PS8751_I2C_ADDR1_FLAGS, .flags = USB_MUX_FLAG_NOT_TCPC, .driver = &ps8xxx_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, @@ -80,8 +81,9 @@ struct usb_mux ampton_usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, [USB_PD_PORT_ITE_1] = { /* Use PS8751 as mux only */ - .port_addr = MUX_PORT_AND_ADDR( - I2C_PORT_USBC1, PS8751_I2C_ADDR1_FLAGS), + .usb_port = USB_PD_PORT_ITE_1, + .i2c_port = I2C_PORT_USBC1, + .i2c_addr_flags = PS8751_I2C_ADDR1_FLAGS, .flags = USB_MUX_FLAG_NOT_TCPC, .driver = &ps8xxx_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, @@ -92,12 +94,12 @@ struct usb_mux ampton_usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { /* Some external monitors can't display content normally (eg. ViewSonic VX2880). * We need to turn the mux for monitors to function normally. */ -static int tune_mux(int port) +static int tune_mux(const struct usb_mux *me) { /* Auto EQ disabled, compensate for channel lost up to 3.6dB */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); /* DP output swing adjustment +15% */ - mux_write(port, PS8XXX_REG_MUX_DP_OUTPUT_CONFIGURATION, 0xc0); + mux_write(me, PS8XXX_REG_MUX_DP_OUTPUT_CONFIGURATION, 0xc0); return EC_SUCCESS; } diff --git a/board/ampton/board.h b/board/ampton/board.h index 96b135d774..0420bc5ccf 100644 --- a/board/ampton/board.h +++ b/board/ampton/board.h @@ -58,6 +58,8 @@ #undef CONFIG_UART_TX_BUF_SIZE #define CONFIG_UART_TX_BUF_SIZE 4096 +#define CONFIG_USB_MUX_RUNTIME_CONFIG + #ifndef __ASSEMBLER__ #include "gpio_signal.h" diff --git a/board/atlas/board.c b/board/atlas/board.c index 5a0659ba97..82dc847623 100644 --- a/board/atlas/board.c +++ b/board/atlas/board.c @@ -189,12 +189,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, @@ -209,8 +211,6 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) board_reset_pd_mcu(); @@ -222,11 +222,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/chell/board.c b/board/chell/board.c index 7b56ca621a..1472d7e5e9 100644 --- a/board/chell/board.c +++ b/board/chell/board.c @@ -183,12 +183,16 @@ static int ps874x_tune_mux(int port) struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = 0x1A, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x1A, .driver = &ps874x_usb_mux_driver, .board_init = &ps874x_tune_mux, }, { - .port_addr = 0x10, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, .board_init = &ps874x_tune_mux, } diff --git a/board/cheza/board.c b/board/cheza/board.c index 232f6cfc3d..855451049d 100644 --- a/board/cheza/board.c +++ b/board/cheza/board.c @@ -294,23 +294,23 @@ const unsigned int chg_cnt = ARRAY_SIZE(chg_chips); * Redirect to anx74xx_tcpm_usb_mux_driver but override the get() function * to check the HPD_IRQ mask from virtual_usb_mux_driver. */ -static int port0_usb_mux_init(int port) +static int port0_usb_mux_init(const struct usb_mux *me) { - return anx74xx_tcpm_usb_mux_driver.init(port); + return anx74xx_tcpm_usb_mux_driver.init(me); } -static int port0_usb_mux_set(int i2c_addr, mux_state_t mux_state) +static int port0_usb_mux_set(const struct usb_mux *me, mux_state_t mux_state) { - return anx74xx_tcpm_usb_mux_driver.set(i2c_addr, mux_state); + return anx74xx_tcpm_usb_mux_driver.set(me, mux_state); } -static int port0_usb_mux_get(int port, mux_state_t *mux_state) +static int port0_usb_mux_get(const struct usb_mux *me, mux_state_t *mux_state) { int rv; mux_state_t virtual_mux_state; - rv = anx74xx_tcpm_usb_mux_driver.get(port, mux_state); - rv |= virtual_usb_mux_driver.get(port, &virtual_mux_state); + rv = anx74xx_tcpm_usb_mux_driver.get(me, mux_state); + rv |= virtual_usb_mux_driver.get(me, &virtual_mux_state); if (virtual_mux_state & USB_PD_MUX_HPD_IRQ) *mux_state |= USB_PD_MUX_HPD_IRQ; @@ -330,32 +330,32 @@ const struct usb_mux_driver port0_usb_mux_driver = { * Redirect to tcpci_tcpm_usb_mux_driver but override the get() function * to check the HPD_IRQ mask from virtual_usb_mux_driver. */ -static int port1_usb_mux_init(int port) +static int port1_usb_mux_init(const struct usb_mux *me) { - return tcpci_tcpm_usb_mux_driver.init(port); + return tcpci_tcpm_usb_mux_driver.init(me); } -static int port1_usb_mux_set(int i2c_addr, mux_state_t mux_state) +static int port1_usb_mux_set(const struct usb_mux *me, mux_state_t mux_state) { - return tcpci_tcpm_usb_mux_driver.set(i2c_addr, mux_state); + return tcpci_tcpm_usb_mux_driver.set(me, mux_state); } -static int port1_usb_mux_get(int port, mux_state_t *mux_state) +static int port1_usb_mux_get(const struct usb_mux *me, mux_state_t *mux_state) { int rv; mux_state_t virtual_mux_state; - rv = tcpci_tcpm_usb_mux_driver.get(port, mux_state); - rv |= virtual_usb_mux_driver.get(port, &virtual_mux_state); + rv = tcpci_tcpm_usb_mux_driver.get(me, mux_state); + rv |= virtual_usb_mux_driver.get(me, &virtual_mux_state); if (virtual_mux_state & USB_PD_MUX_HPD_IRQ) *mux_state |= USB_PD_MUX_HPD_IRQ; return rv; } -static int port1_usb_mux_enter_low_power(int port) +static int port1_usb_mux_enter_low_power(const struct usb_mux *me) { - return tcpci_tcpm_usb_mux_driver.enter_low_power_mode(port); + return tcpci_tcpm_usb_mux_driver.enter_low_power_mode(me); } const struct usb_mux_driver port1_usb_mux_driver = { @@ -365,12 +365,14 @@ const struct usb_mux_driver port1_usb_mux_driver = { .enter_low_power_mode = &port1_usb_mux_enter_low_power, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &port0_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, { + .usb_port = 1, .driver = &port1_usb_mux_driver, .hpd_update = &virtual_hpd_update, } @@ -406,8 +408,6 @@ DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT); void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) { /* TODO(crosbug.com/p/61098): How long do we need to wait? */ @@ -428,11 +428,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/cheza/usb_pd_policy.c b/board/cheza/usb_pd_policy.c index 17f75136f9..694899ab79 100644 --- a/board/cheza/usb_pd_policy.c +++ b/board/cheza/usb_pd_policy.c @@ -177,11 +177,10 @@ __override int svdm_dp_attention(int port, uint32_t *payload) int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]); int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]); int mf_pref = PD_VDO_DPSTS_MF_PREF(payload[1]); - const struct usb_mux *mux = &usb_muxes[port]; dp_status[port] = payload[1]; - mux->hpd_update(port, lvl, irq); + usb_mux_hpd_update(port, lvl, irq); if (lvl && is_dp_muxable(port)) { /* diff --git a/board/coral/board.c b/board/coral/board.c index 9da7fb375a..3af03d6e0d 100644 --- a/board/coral/board.c +++ b/board/coral/board.c @@ -274,19 +274,21 @@ const enum gpio_signal hibernate_wake_pins[] = { const int hibernate_wake_pins_used = ARRAY_SIZE(hibernate_wake_pins); -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* 0x98 sets lower EQ of DP port (4.5db) */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); return EC_SUCCESS; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ANX74XX] = { + .usb_port = USB_PD_PORT_ANX74XX, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, @@ -357,7 +359,7 @@ void board_reset_pd_mcu(void) static void board_tcpc_init(void) { - int port, reg; + int reg; int count = 0; /* Wait for disconnected battery to wake up */ @@ -398,11 +400,8 @@ static void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_DEFAULT); diff --git a/board/damu/board.c b/board/damu/board.c index 87e78c5043..92b8a43b14 100644 --- a/board/damu/board.c +++ b/board/damu/board.c @@ -134,7 +134,8 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -143,10 +144,11 @@ static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) host_set_single_event(EC_HOST_EVENT_USB_MUX); } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - /* Driver uses I2C_PORT_USB_MUX as I2C port */ - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_status, }, diff --git a/board/dratini/board.c b/board/dratini/board.c index 97b6a07eab..c4670cd65c 100644 --- a/board/dratini/board.c +++ b/board/dratini/board.c @@ -146,12 +146,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/elm/board.c b/board/elm/board.c index 29c1b2e510..578e7ac312 100644 --- a/board/elm/board.c +++ b/board/elm/board.c @@ -163,8 +163,9 @@ const struct temp_sensor_t temp_sensors[] = { }; BUILD_ASSERT(ARRAY_SIZE(temp_sensors) == TEMP_SENSOR_COUNT); -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &anx7688_usb_mux_driver, }, }; diff --git a/board/eve/board.c b/board/eve/board.c index 452732e393..8d1b21ccd6 100644 --- a/board/eve/board.c +++ b/board/eve/board.c @@ -221,12 +221,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, @@ -299,8 +301,6 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) board_reset_pd_mcu(); @@ -319,11 +319,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/fizz/board.c b/board/fizz/board.c index 8461cc3ae3..b3627afa7b 100644 --- a/board/fizz/board.c +++ b/board/fizz/board.c @@ -185,15 +185,16 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* 0x98 sets lower EQ of DP port (4.5db) */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); return EC_SUCCESS; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, @@ -217,7 +218,7 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port, reg; + int reg; /* This needs to be executed only once per boot. It could be run by RO * if we boot in recovery mode. It could be run by RW if we boot in @@ -238,10 +239,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/flapjack/board.c b/board/flapjack/board.c index 0035bc01dd..3d0e08afe5 100644 --- a/board/flapjack/board.c +++ b/board/flapjack/board.c @@ -304,8 +304,9 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { .drv = &mt6370_tcpm_drv}, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, diff --git a/board/flapjack/usb_pd_policy.c b/board/flapjack/usb_pd_policy.c index 7174389dde..20de95dc3b 100644 --- a/board/flapjack/usb_pd_policy.c +++ b/board/flapjack/usb_pd_policy.c @@ -77,8 +77,6 @@ void pd_power_supply_reset(int port) #ifdef CONFIG_USB_PD_ALT_MODE_DFP __override void svdm_dp_post_config(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - dp_flags[port] |= DP_FLAGS_DP_ON; if (!(dp_flags[port] & DP_FLAGS_HPD_HI_PENDING)) return; @@ -89,7 +87,7 @@ __override void svdm_dp_post_config(int port) /* set the minimum time delay (2ms) for the next HPD IRQ */ svdm_hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; - mux->hpd_update(port, 1, 0); + usb_mux_hpd_update(port, 1, 0); } __override int svdm_dp_attention(int port, uint32_t *payload) @@ -97,7 +95,6 @@ __override int svdm_dp_attention(int port, uint32_t *payload) int cur_lvl = gpio_get_level(GPIO_USB_C0_HPD_OD); int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]); int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]); - const struct usb_mux * const mux = &usb_muxes[port]; dp_status[port] = payload[1]; @@ -111,7 +108,7 @@ __override int svdm_dp_attention(int port, uint32_t *payload) usb_mux_set(port, lvl ? USB_PD_MUX_DP_ENABLED : USB_PD_MUX_NONE, USB_SWITCH_CONNECT, pd_get_polarity(port)); - mux->hpd_update(port, lvl, irq); + usb_mux_hpd_update(port, lvl, irq); if (irq & cur_lvl) { uint64_t now = get_time().val; @@ -148,11 +145,9 @@ __override int svdm_dp_attention(int port, uint32_t *payload) __override void svdm_exit_dp_mode(int port) { - const struct usb_mux * const mux = &usb_muxes[port]; - svdm_safe_dp_mode(port); gpio_set_level(GPIO_USB_C0_HPD_OD, 0); gpio_set_level(GPIO_USB_C0_DP_OE_L, 1); - mux->hpd_update(port, 0, 0); + usb_mux_hpd_update(port, 0, 0); } #endif /* CONFIG_USB_PD_ALT_MODE_DFP */ diff --git a/board/glados/board.c b/board/glados/board.c index 2b70233631..f973e4f74b 100644 --- a/board/glados/board.c +++ b/board/glados/board.c @@ -166,12 +166,15 @@ BUILD_ASSERT(ARRAY_SIZE(pi3usb9281_chips) == struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR0), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, }, { - .port_addr = 0x10, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, } }; diff --git a/board/glkrvp/chg_usb_pd.c b/board/glkrvp/chg_usb_pd.c index f143dcece5..634da73a1c 100644 --- a/board/glkrvp/chg_usb_pd.c +++ b/board/glkrvp/chg_usb_pd.c @@ -50,13 +50,17 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }; BUILD_ASSERT(ARRAY_SIZE(tcpc_config) == CONFIG_USB_PD_PORT_MAX_COUNT); -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = 0x10, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, }, { - .port_addr = 0x11, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x11, .driver = &ps874x_usb_mux_driver, }, }; diff --git a/board/glkrvp_ite/chg_usb_pd.c b/board/glkrvp_ite/chg_usb_pd.c index 0dbf286b7e..87ff5bf6d9 100644 --- a/board/glkrvp_ite/chg_usb_pd.c +++ b/board/glkrvp_ite/chg_usb_pd.c @@ -50,13 +50,17 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }; BUILD_ASSERT(ARRAY_SIZE(tcpc_config) == CONFIG_USB_PD_PORT_MAX_COUNT); -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = 0x10, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, }, { - .port_addr = 0x11, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x11, .driver = &ps874x_usb_mux_driver, }, }; diff --git a/board/hatch/board.c b/board/hatch/board.c index 4e68b7d215..8060de471e 100644 --- a/board/hatch/board.c +++ b/board/hatch/board.c @@ -145,12 +145,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/helios/board.c b/board/helios/board.c index dd0b2c87a3..7ab13d5734 100644 --- a/board/helios/board.c +++ b/board/helios/board.c @@ -167,12 +167,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/jacuzzi/board.c b/board/jacuzzi/board.c index 7fb0f45fcc..defcebd884 100644 --- a/board/jacuzzi/board.c +++ b/board/jacuzzi/board.c @@ -142,7 +142,8 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -151,10 +152,11 @@ static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) host_set_single_event(EC_HOST_EVENT_USB_MUX); } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - /* Driver uses I2C_PORT_USB_MUX as I2C port */ - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_status, }, diff --git a/board/jinlon/board.c b/board/jinlon/board.c index a9646a7794..56082fde2c 100644 --- a/board/jinlon/board.c +++ b/board/jinlon/board.c @@ -147,12 +147,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/kakadu/board.c b/board/kakadu/board.c index 0a408d0c36..e6e63a9bc7 100644 --- a/board/kakadu/board.c +++ b/board/kakadu/board.c @@ -106,7 +106,8 @@ struct mt6370_thermal_bound thermal_bound = { .err = 4, }; -static void board_hpd_update(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_update(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -129,9 +130,11 @@ __override const struct rt946x_init_setting *board_rt946x_init_setting(void) return &battery_init_setting; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_update, }, diff --git a/board/kappa/board.c b/board/kappa/board.c index 6f4628ab8a..b4f37975ae 100644 --- a/board/kappa/board.c +++ b/board/kappa/board.c @@ -138,7 +138,8 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -147,10 +148,11 @@ static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) host_set_single_event(EC_HOST_EVENT_USB_MUX); } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - /* Driver uses I2C_PORT_USB_MUX as I2C port */ - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_status, }, diff --git a/board/kindred/board.c b/board/kindred/board.c index 308ccf2eca..fa5b064016 100644 --- a/board/kindred/board.c +++ b/board/kindred/board.c @@ -168,12 +168,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/kodama/board.c b/board/kodama/board.c index abc44c43d4..03ecf1afe7 100644 --- a/board/kodama/board.c +++ b/board/kodama/board.c @@ -104,7 +104,8 @@ struct mt6370_thermal_bound thermal_bound = { .err = 4, }; -static void board_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -128,9 +129,11 @@ __override const struct rt946x_init_setting *board_rt946x_init_setting(void) return &battery_init_setting; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_status, }, diff --git a/board/kohaku/board.c b/board/kohaku/board.c index dc56f432e1..ef59e36afb 100644 --- a/board/kohaku/board.c +++ b/board/kohaku/board.c @@ -131,12 +131,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/kukui/board.c b/board/kukui/board.c index 91b989aec8..5476030130 100644 --- a/board/kukui/board.c +++ b/board/kukui/board.c @@ -119,7 +119,8 @@ void board_set_dp_mux_control(int output_enable, int polarity) gpio_set_level(GPIO_USB_C0_DP_POLARITY, polarity); } -static void board_hpd_update(int port, int hpd_lvl, int hpd_irq) +static void board_hpd_update(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { /* * svdm_dp_attention() did most of the work, we only need to notify @@ -144,7 +145,9 @@ __override const struct rt946x_init_setting *board_rt946x_init_setting(void) struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = IT5205_I2C_ADDR1_FLAGS, + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = IT5205_I2C_ADDR1_FLAGS, .driver = &it5205_usb_mux_driver, .hpd_update = &board_hpd_update, }, diff --git a/board/kukui/board.h b/board/kukui/board.h index 9b299bc02a..2057ab191a 100644 --- a/board/kukui/board.h +++ b/board/kukui/board.h @@ -28,6 +28,7 @@ #define CONFIG_USB_MUX_IT5205 #define CONFIG_USB_MUX_VIRTUAL #define CONFIG_VOLUME_BUTTONS +#define CONFIG_USB_MUX_RUNTIME_CONFIG /* Battery */ #ifdef BOARD_KRANE diff --git a/board/mchpevb1/board.c b/board/mchpevb1/board.c index 7fd2c16575..d6e8da3a02 100644 --- a/board/mchpevb1/board.c +++ b/board/mchpevb1/board.c @@ -389,12 +389,15 @@ BUILD_ASSERT(ARRAY_SIZE(pi3usb9281_chips) == struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR0), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, }, { - .port_addr = 0x10, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, } }; diff --git a/board/mushu/board.c b/board/mushu/board.c index 1656e4adf0..bd5d2750b3 100644 --- a/board/mushu/board.c +++ b/board/mushu/board.c @@ -147,12 +147,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/nami/board.c b/board/nami/board.c index b6cbbd359d..9bbffdc755 100644 --- a/board/nami/board.c +++ b/board/nami/board.c @@ -252,19 +252,21 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* 0x98 sets lower EQ of DP port (3.6db) */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); return EC_SUCCESS; } struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, [USB_PD_PORT_ANX7447] = { + .usb_port = USB_PD_PORT_ANX7447, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, } @@ -314,8 +316,6 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) board_reset_pd_mcu(); @@ -331,10 +331,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C + 2); diff --git a/board/nami/board.h b/board/nami/board.h index e039f0dcb5..8159f13c7a 100644 --- a/board/nami/board.h +++ b/board/nami/board.h @@ -186,6 +186,7 @@ #define CONFIG_USBC_SS_MUX #define CONFIG_USBC_VCONN #define CONFIG_USBC_VCONN_SWAP +#define CONFIG_USB_MUX_RUNTIME_CONFIG /* BC 1.2 charger */ diff --git a/board/nautilus/board.c b/board/nautilus/board.c index c9897212f8..3f01a70f6c 100644 --- a/board/nautilus/board.c +++ b/board/nautilus/board.c @@ -166,12 +166,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } @@ -216,8 +218,6 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) { board_reset_pd_mcu(); @@ -231,11 +231,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/nocturne/board.c b/board/nocturne/board.c index 9a397d1298..3184b6293b 100644 --- a/board/nocturne/board.c +++ b/board/nocturne/board.c @@ -318,13 +318,15 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, diff --git a/board/oak/board.c b/board/oak/board.c index ec871824bc..e79dc31460 100644 --- a/board/oak/board.c +++ b/board/oak/board.c @@ -195,24 +195,24 @@ struct als_t als[] = { BUILD_ASSERT(ARRAY_SIZE(als) == ALS_COUNT); #endif -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR0), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, }, -#if (BOARD_REV <= OAK_REV4) { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR1), + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, +#if (BOARD_REV <= OAK_REV4) + .i2c_addr_flags = PI3USB3X532_I2C_ADDR1, .driver = &pi3usb3x532_usb_mux_driver, - }, #else - { - .port_addr = 0x10, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, - }, #endif + }, }; /** diff --git a/board/pdeval-stm32f072/usb_pd_policy.c b/board/pdeval-stm32f072/usb_pd_policy.c index 2f0022d211..775f8b8876 100644 --- a/board/pdeval-stm32f072/usb_pd_policy.c +++ b/board/pdeval-stm32f072/usb_pd_policy.c @@ -36,8 +36,9 @@ const uint32_t pd_snk_pdo[] = { const int pd_snk_pdo_cnt = ARRAY_SIZE(pd_snk_pdo); #if defined(CONFIG_USB_PD_TCPM_MUX) && defined(CONFIG_USB_PD_TCPM_ANX7447) -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &anx7447_usb_mux_driver, }, }; @@ -200,6 +201,9 @@ __override int svdm_dp_config(int port, uint32_t *payload) { int opos = pd_alt_mode(port, USB_SID_DISPLAYPORT); int pin_mode = pd_dfp_dp_get_pin_mode(port, dp_status[port]); +#if defined(CONFIG_USB_PD_TCPM_MUX) && defined(CONFIG_USB_PD_TCPM_ANX7447) + const struct usb_mux *mux = &usb_muxes[port]; +#endif #ifdef CONFIG_USB_PD_TCPM_ANX7447 mux_state_t mux_state = USB_PD_MUX_NONE; @@ -217,13 +221,13 @@ __override int svdm_dp_config(int port, uint32_t *payload) case MODE_DP_PIN_C: case MODE_DP_PIN_E: mux_state |= USB_PD_MUX_DP_ENABLED; - usb_muxes[port].driver->set(port, mux_state); + mux->driver->set(mux, mux_state); break; case MODE_DP_PIN_B: case MODE_DP_PIN_D: case MODE_DP_PIN_F: mux_state |= USB_PD_MUX_DOCK; - usb_muxes[port].driver->set(port, mux_state); + mux->driver->set(mux, mux_state); break; } #endif @@ -242,13 +246,14 @@ __override int svdm_dp_config(int port, uint32_t *payload) __override void svdm_dp_post_config(int port) { + const struct usb_mux *mux = &usb_muxes[port]; + dp_flags[port] |= DP_FLAGS_DP_ON; if (!(dp_flags[port] & DP_FLAGS_HPD_HI_PENDING)) return; -#ifdef CONFIG_USB_PD_TCPM_ANX7447 - anx7447_tcpc_update_hpd_status(port, 1, 0); -#endif + if (IS_ENABLED(CONFIG_USB_PD_TCPM_ANX7447)) + anx7447_tcpc_update_hpd_status(mux, 1, 0); } __override int svdm_dp_attention(int port, uint32_t *payload) @@ -256,9 +261,10 @@ __override int svdm_dp_attention(int port, uint32_t *payload) #ifdef CONFIG_USB_PD_TCPM_ANX7447 int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]); int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]); + const struct usb_mux *mux = &usb_muxes[port]; CPRINTS("Attention: 0x%x", payload[1]); - anx7447_tcpc_update_hpd_status(port, lvl, irq); + anx7447_tcpc_update_hpd_status(mux, lvl, irq); #endif dp_status[port] = payload[1]; diff --git a/board/poppy/board.c b/board/poppy/board.c index 9ccd9774b4..80bcf98433 100644 --- a/board/poppy/board.c +++ b/board/poppy/board.c @@ -208,12 +208,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } @@ -284,7 +286,7 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port, reg; + int reg; /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) { @@ -318,11 +320,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/puff/board.c b/board/puff/board.c index 4917432d6b..1f8162b147 100644 --- a/board/puff/board.c +++ b/board/puff/board.c @@ -244,8 +244,9 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { .flags = TCPC_FLAGS_RESET_ACTIVE_HIGH, }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, diff --git a/board/rainier/board.c b/board/rainier/board.c index 99751de860..a2592bd54d 100644 --- a/board/rainier/board.c +++ b/board/rainier/board.c @@ -137,8 +137,9 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, diff --git a/board/rammus/board.c b/board/rammus/board.c index 9ce61ef501..6f6d175959 100644 --- a/board/rammus/board.c +++ b/board/rammus/board.c @@ -178,12 +178,14 @@ struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, [USB_PD_PORT_ANX7447] = { + .usb_port = USB_PD_PORT_ANX7447, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, } @@ -242,8 +244,6 @@ static void ps8751_i2c_remap(void) void board_tcpc_init(void) { - int port; - ps8751_i2c_remap(); /* Only reset TCPC if not sysjump */ @@ -259,10 +259,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/reef/board.c b/board/reef/board.c index 0a9d453ce5..30b3058161 100644 --- a/board/reef/board.c +++ b/board/reef/board.c @@ -279,19 +279,21 @@ const enum gpio_signal hibernate_wake_pins[] = { const int hibernate_wake_pins_used = ARRAY_SIZE(hibernate_wake_pins); -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { /* 0x98 sets lower EQ of DP port (4.5db) */ - mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); return EC_SUCCESS; } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ANX74XX] = { + .usb_port = USB_PD_PORT_ANX74XX, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, @@ -361,7 +363,7 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port, reg; + int reg; /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) @@ -392,11 +394,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/reef_it8320/board.c b/board/reef_it8320/board.c index c06ceaa87e..5c5796bb9e 100644 --- a/board/reef_it8320/board.c +++ b/board/reef_it8320/board.c @@ -146,10 +146,12 @@ const enum gpio_signal hibernate_wake_pins[] = { const int hibernate_wake_pins_used = ARRAY_SIZE(hibernate_wake_pins); -static void it83xx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) +static void it83xx_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { enum gpio_signal gpio = - port ? GPIO_USB_C1_HPD_1P8_ODL : GPIO_USB_C0_HPD_1P8_ODL; + me->usb_port ? GPIO_USB_C1_HPD_1P8_ODL + : GPIO_USB_C0_HPD_1P8_ODL; hpd_lvl = !hpd_lvl; @@ -161,15 +163,18 @@ static void it83xx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) } } -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR0), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, .hpd_update = &it83xx_tcpc_update_hpd_status, }, { - .port_addr = 0x10, + .usb_port = 1, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = 0x10, .driver = &ps874x_usb_mux_driver, .hpd_update = &it83xx_tcpc_update_hpd_status, }, @@ -245,8 +250,6 @@ static void board_set_tablet_mode(void) /* Initialize board. */ static void board_init(void) { - int port; - board_set_tablet_mode(); /* Enable charger interrupts */ gpio_enable_interrupt(GPIO_CHARGER_INT_L); @@ -255,8 +258,8 @@ static void board_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) - usb_muxes[port].hpd_update(port, 0, 0); + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_INIT_I2C + 1); diff --git a/board/reef_mchp/board.c b/board/reef_mchp/board.c index 89fc2ec139..b9927976ab 100644 --- a/board/reef_mchp/board.c +++ b/board/reef_mchp/board.c @@ -406,12 +406,12 @@ const int hibernate_wake_pins_used = ARRAY_SIZE(hibernate_wake_pins); * results taking up to 10ms before I2C communication with PS8751 * is stable. Don't know how to fix this. */ -static int ps8751_tune_mux(int port) +static int ps8751_tune_mux(const struct usb_mux *me) { int rv; /* 0x98 sets lower EQ of DP port (4.5db) */ - rv = mux_write(port, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); + rv = mux_write(me, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98); /* TCPCI spec. delay msleep(6); */ @@ -423,12 +423,14 @@ static int ps8751_tune_mux(int port) * tcpc_config array. The tcpc_config array contains the actual EC I2C * port, device slave address, and a function pointer into the driver code. */ -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_ANX74XX] = { + .usb_port = USB_PD_PORT_ANX74XX, .driver = &anx74xx_tcpm_usb_mux_driver, .hpd_update = &anx74xx_tcpc_update_hpd_status, }, [USB_PD_PORT_PS8751] = { + .usb_port = USB_PD_PORT_PS8751, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, .board_init = &ps8751_tune_mux, @@ -501,7 +503,7 @@ void board_reset_pd_mcu(void) void board_tcpc_init(void) { - int port, reg; + int reg; /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) @@ -538,11 +540,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/samus_pd/usb_mux.c b/board/samus_pd/usb_mux.c index 732de79968..2213fc41e0 100644 --- a/board/samus_pd/usb_mux.c +++ b/board/samus_pd/usb_mux.c @@ -40,14 +40,14 @@ static const struct usb_port_mux mux_gpios[] = { BUILD_ASSERT(ARRAY_SIZE(mux_gpios) == CONFIG_USB_PD_PORT_MAX_COUNT); -static int board_init_usb_mux(int port) +static int board_init_usb_mux(const struct usb_mux *me) { return EC_SUCCESS; } -static int board_set_usb_mux(int port, mux_state_t mux_state) +static int board_set_usb_mux(const struct usb_mux *me, mux_state_t mux_state) { - const struct usb_port_mux *usb_mux = mux_gpios + port; + const struct usb_port_mux *usb_mux = mux_gpios + me->usb_port; int polarity = mux_state & USB_PD_MUX_POLARITY_INVERTED; /* reset everything */ @@ -80,9 +80,9 @@ static int board_set_usb_mux(int port, mux_state_t mux_state) return EC_SUCCESS; } -static int board_get_usb_mux(int port, mux_state_t *mux_state) +static int board_get_usb_mux(const struct usb_mux *me, mux_state_t *mux_state) { - const struct usb_port_mux *usb_mux = mux_gpios + port; + const struct usb_port_mux *usb_mux = mux_gpios + me->usb_port; *mux_state = 0; @@ -105,11 +105,13 @@ const struct usb_mux_driver board_custom_usb_mux_driver = { .get = board_get_usb_mux, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &board_custom_usb_mux_driver, }, { + .usb_port = 1, .driver = &board_custom_usb_mux_driver, }, }; diff --git a/board/scarlet/board.c b/board/scarlet/board.c index 5f20812a23..8de3de4bf5 100644 --- a/board/scarlet/board.c +++ b/board/scarlet/board.c @@ -144,8 +144,9 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &virtual_usb_mux_driver, .hpd_update = &virtual_hpd_update, }, diff --git a/board/strago/board.c b/board/strago/board.c index 73f105cd24..308c4ee8ce 100644 --- a/board/strago/board.c +++ b/board/strago/board.c @@ -141,10 +141,11 @@ struct pi3usb9281_config pi3usb9281_chips[] = { BUILD_ASSERT(ARRAY_SIZE(pi3usb9281_chips) == CONFIG_BC12_DETECT_PI3USB9281_CHIP_COUNT); -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_MUX, - PI3USB3X532_I2C_ADDR1), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_MUX, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR1, .driver = &pi3usb3x532_usb_mux_driver, }, }; diff --git a/board/stryke/board.c b/board/stryke/board.c index dc5de9d253..5f74ea26f6 100644 --- a/board/stryke/board.c +++ b/board/stryke/board.c @@ -144,12 +144,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { [USB_PD_PORT_TCPC_0] = { + .usb_port = USB_PD_PORT_TCPC_0, .driver = &anx7447_usb_mux_driver, .hpd_update = &anx7447_tcpc_update_hpd_status, }, [USB_PD_PORT_TCPC_1] = { + .usb_port = USB_PD_PORT_TCPC_1, .driver = &tcpci_tcpm_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } diff --git a/board/trogdor/board.c b/board/trogdor/board.c index 717392a1a2..c8d770fc37 100644 --- a/board/trogdor/board.c +++ b/board/trogdor/board.c @@ -266,12 +266,14 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { * to AP. But the TCPC chip is also needed to know the HPD status; otherwise, * the mux misbehaves. */ -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { + .usb_port = 0, .driver = &ps8xxx_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, }, { + .usb_port = 1, .driver = &ps8xxx_usb_mux_driver, .hpd_update = &ps8xxx_tcpc_update_hpd_status, } @@ -328,8 +330,6 @@ DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT); void board_tcpc_init(void) { - int port; - /* Only reset TCPC if not sysjump */ if (!system_jumped_to_this_image()) { /* TODO(crosbug.com/p/61098): How long do we need to wait? */ @@ -347,11 +347,8 @@ void board_tcpc_init(void) * Initialize HPD to low; after sysjump SOC needs to see * HPD pulse to enable video path */ - for (port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; port++) { - const struct usb_mux *mux = &usb_muxes[port]; - - mux->hpd_update(port, 0, 0); - } + for (int port = 0; port < CONFIG_USB_PD_PORT_MAX_COUNT; ++port) + usb_mux_hpd_update(port, 0, 0); } DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C+1); diff --git a/board/trogdor/usb_pd_policy.c b/board/trogdor/usb_pd_policy.c index c88768f63a..6840ae919e 100644 --- a/board/trogdor/usb_pd_policy.c +++ b/board/trogdor/usb_pd_policy.c @@ -152,7 +152,6 @@ __override int svdm_dp_attention(int port, uint32_t *payload) enum gpio_signal hpd = GPIO_DP_HOT_PLUG_DET; int lvl = PD_VDO_DPSTS_HPD_LVL(payload[1]); int irq = PD_VDO_DPSTS_HPD_IRQ(payload[1]); - const struct usb_mux *mux = &usb_muxes[port]; int cur_lvl = gpio_get_level(hpd); dp_status[port] = payload[1]; @@ -217,7 +216,7 @@ __override int svdm_dp_attention(int port, uint32_t *payload) pd_notify_dp_alt_mode_entry(); /* Configure TCPC for the HPD event, for proper muxing */ - mux->hpd_update(port, lvl, irq); + usb_mux_hpd_update(port, lvl, irq); /* Signal AP for the HPD event, through GPIO to AP */ if (irq & cur_lvl) { @@ -249,8 +248,6 @@ __override int svdm_dp_attention(int port, uint32_t *payload) __override void svdm_exit_dp_mode(int port) { - const struct usb_mux *mux = &usb_muxes[port]; - /* Disconnect the DP port selection mux. */ gpio_set_level(GPIO_DP_MUX_OE_L, 1); @@ -258,7 +255,7 @@ __override void svdm_exit_dp_mode(int port) svdm_safe_dp_mode(port); /* Signal AP for the HPD low event */ - mux->hpd_update(port, 0, 0); + usb_mux_hpd_update(port, 0, 0); gpio_set_level(GPIO_DP_HOT_PLUG_DET, 0); } #endif /* CONFIG_USB_PD_ALT_MODE_DFP */ diff --git a/board/waddledoo/board.c b/board/waddledoo/board.c index cf697d6564..6979a326fe 100644 --- a/board/waddledoo/board.c +++ b/board/waddledoo/board.c @@ -344,28 +344,28 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usbc1_retimer = { + .usb_port = 1, + .i2c_port = I2C_PORT_SUB_USB_C1, + .i2c_addr_flags = NB7V904M_I2C_ADDR0, + .driver = &nb7v904m_usb_redriver_drv, +}; +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_USB_C0, - PI3USB3X532_I2C_ADDR0), + .usb_port = 0, + .i2c_port = I2C_PORT_USB_C0, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, }, { - .port_addr = MUX_PORT_AND_ADDR(I2C_PORT_SUB_USB_C1, - PI3USB3X532_I2C_ADDR0), + .usb_port = 1, + .i2c_port = I2C_PORT_SUB_USB_C1, + .i2c_addr_flags = PI3USB3X532_I2C_ADDR0, .driver = &pi3usb3x532_usb_mux_driver, + .next_mux = &usbc1_retimer, } }; -struct usb_retimer usb_retimers[CONFIG_USB_PD_PORT_MAX_COUNT] = { - { 0 }, /* There's no retimer on Port 0 */ - { - .i2c_port = I2C_PORT_SUB_USB_C1, - .i2c_addr_flags = NB7V904M_I2C_ADDR0, - .driver = &nb7v904m_usb_redriver_drv, - }, -}; - uint16_t tcpc_get_alert_status(void) { uint16_t status = 0; diff --git a/common/mock/usb_mux_mock.c b/common/mock/usb_mux_mock.c index c64c5cad0b..f367bfeb95 100644 --- a/common/mock/usb_mux_mock.c +++ b/common/mock/usb_mux_mock.c @@ -18,12 +18,12 @@ void mock_usb_mux_reset(void) memset(&mock_usb_mux, 0, sizeof(mock_usb_mux)); } -static int mock_init(int port) +static int mock_init(const struct usb_mux *me) { return EC_SUCCESS; } -static int mock_set(int port, mux_state_t mux_state) +static int mock_set(const struct usb_mux *me, mux_state_t mux_state) { mock_usb_mux.state = mux_state; ++mock_usb_mux.num_set_calls; @@ -32,13 +32,13 @@ static int mock_set(int port, mux_state_t mux_state) return EC_SUCCESS; } -int mock_get(int port, mux_state_t *mux_state) +int mock_get(const struct usb_mux *me, mux_state_t *mux_state) { *mux_state = mock_usb_mux.state; return EC_SUCCESS; } -static int mock_enter_low_power_mode(int port) +static int mock_enter_low_power_mode(const struct usb_mux *me) { return EC_SUCCESS; } diff --git a/driver/retimer/bb_retimer.c b/driver/retimer/bb_retimer.c index 61a84c4116..08afbc7308 100644 --- a/driver/retimer/bb_retimer.c +++ b/driver/retimer/bb_retimer.c @@ -27,7 +27,8 @@ /** * Utility functions */ -static int bb_retimer_read(int port, const uint8_t offset, uint32_t *data) +static int bb_retimer_read(const struct usb_mux *me, + const uint8_t offset, uint32_t *data) { int rv; uint8_t buf[BB_RETIMER_READ_SIZE]; @@ -39,8 +40,7 @@ static int bb_retimer_read(int port, const uint8_t offset, uint32_t *data) * byte[1:4] : Data [LSB -> MSB] * Stop */ - rv = i2c_xfer(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags, + rv = i2c_xfer(me->i2c_port, me->i2c_addr_flags, &offset, 1, buf, BB_RETIMER_READ_SIZE); if (rv) return rv; @@ -52,7 +52,8 @@ static int bb_retimer_read(int port, const uint8_t offset, uint32_t *data) return EC_SUCCESS; } -static int bb_retimer_write(int port, const uint8_t offset, uint32_t data) +static int bb_retimer_write(const struct usb_mux *me, + const uint8_t offset, uint32_t data) { uint8_t buf[BB_RETIMER_WRITE_SIZE]; @@ -71,14 +72,14 @@ static int bb_retimer_write(int port, const uint8_t offset, uint32_t data) buf[4] = (data >> 16) & 0xFF; buf[5] = (data >> 24) & 0xFF; - return i2c_xfer(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags, + return i2c_xfer(me->i2c_port, + me->i2c_addr_flags, buf, BB_RETIMER_WRITE_SIZE, NULL, 0); } -static void bb_retimer_power_handle(int port, int on_off) +static void bb_retimer_power_handle(const struct usb_mux *me, int on_off) { - const struct bb_usb_control *control = &bb_controls[port]; + const struct bb_usb_control *control = &bb_controls[me->usb_port]; /* handle retimer's power domain */ @@ -110,10 +111,11 @@ static void bb_retimer_power_handle(int port, int on_off) /** * Driver interface functions */ -static int retimer_set_state(int port, mux_state_t mux_state) +static int retimer_set_state(const struct usb_mux *me, mux_state_t mux_state) { uint32_t set_retimer_con = 0; uint8_t dp_pin_mode; + int port = me->usb_port; union tbt_mode_resp_cable cable_resp; union tbt_mode_resp_device dev_resp; @@ -280,30 +282,30 @@ static int retimer_set_state(int port, mux_state_t mux_state) cable_resp.tbt_cable_speed); } /* Writing the register4 */ - return bb_retimer_write(port, BB_RETIMER_REG_CONNECTION_STATE, + return bb_retimer_write(me, BB_RETIMER_REG_CONNECTION_STATE, set_retimer_con); } -static int retimer_low_power_mode(int port) +static int retimer_low_power_mode(const struct usb_mux *me) { - bb_retimer_power_handle(port, 0); + bb_retimer_power_handle(me, 0); return EC_SUCCESS; } -static int retimer_init(int port) +static int retimer_init(const struct usb_mux *me) { int rv; uint32_t data; - bb_retimer_power_handle(port, 1); + bb_retimer_power_handle(me, 1); - rv = bb_retimer_read(port, BB_RETIMER_REG_VENDOR_ID, &data); + rv = bb_retimer_read(me, BB_RETIMER_REG_VENDOR_ID, &data); if (rv) return rv; if (data != BB_RETIMER_VENDOR_ID) return EC_ERROR_UNKNOWN; - rv = bb_retimer_read(port, BB_RETIMER_REG_DEVICE_ID, &data); + rv = bb_retimer_read(me, BB_RETIMER_REG_DEVICE_ID, &data); if (rv) return rv; @@ -313,7 +315,7 @@ static int retimer_init(int port) return EC_SUCCESS; } -const struct usb_retimer_driver bb_usb_retimer = { +const struct usb_mux_driver bb_usb_retimer = { .init = retimer_init, .set = retimer_set_state, .enter_low_power_mode = retimer_low_power_mode, @@ -324,14 +326,24 @@ static int console_command_bb_retimer(int argc, char **argv) { char rw, *e; int rv, port, reg, data, val; + const struct usb_mux *mux; if (argc < 4) return EC_ERROR_PARAM_COUNT; /* Get port number */ port = strtoi(argv[1], &e, 0); - if (*e || port < 0 || port > board_get_usb_pd_port_count() || - !usb_retimers[port].driver) + if (*e || port < 0 || port > board_get_usb_pd_port_count()) + return EC_ERROR_PARAM1; + + mux = &usb_muxes[port]; + while (mux) { + if (mux->driver == &bb_usb_retimer) + break; + mux = mux->next_mux; + } + + if (!mux) return EC_ERROR_PARAM1; /* Validate r/w selection */ @@ -345,16 +357,16 @@ static int console_command_bb_retimer(int argc, char **argv) return EC_ERROR_PARAM3; if (rw == 'r') - rv = bb_retimer_read(port, reg, &data); + rv = bb_retimer_read(mux, reg, &data); else { /* Get value to be written */ val = strtoi(argv[4], &e, 0); if (*e || val < 0) return EC_ERROR_PARAM4; - rv = bb_retimer_write(port, reg, val); + rv = bb_retimer_write(mux, reg, val); if (rv == EC_SUCCESS) { - rv = bb_retimer_read(port, reg, &data); + rv = bb_retimer_read(mux, reg, &data); if (rv == EC_SUCCESS && data != val) rv = EC_ERROR_UNKNOWN; } diff --git a/driver/retimer/bb_retimer.h b/driver/retimer/bb_retimer.h index 3b34b72e3d..868cb5ee7c 100644 --- a/driver/retimer/bb_retimer.h +++ b/driver/retimer/bb_retimer.h @@ -40,7 +40,7 @@ #define BB_RETIMER_TBT_CABLE_GENERATION(x) (((x) & 0x3) << 28) /* Supported USB retimer drivers */ -extern const struct usb_retimer_driver bb_usb_retimer; +extern const struct usb_mux_driver bb_usb_retimer; /* Retimer driver hardware specific controls */ struct bb_usb_control { diff --git a/driver/retimer/nb7v904m.c b/driver/retimer/nb7v904m.c index 81fd5abc93..e1cedede95 100644 --- a/driver/retimer/nb7v904m.c +++ b/driver/retimer/nb7v904m.c @@ -15,28 +15,28 @@ #define CPRINTS(format, args...) cprints(CC_USB, format, ## args) #define CPRINTF(format, args...) cprintf(CC_USB, format, ## args) -static int nb7v904m_write(int port, int offset, int data) +static int nb7v904m_write(const struct usb_mux *me, int offset, int data) { - return i2c_write8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags, + return i2c_write8(me->i2c_port, + me->i2c_addr_flags, offset, data); } -static int nb7v904m_read(int port, int offset, int *regval) +static int nb7v904m_read(const struct usb_mux *me, int offset, int *regval) { - return i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags, + return i2c_read8(me->i2c_port, + me->i2c_addr_flags, offset, regval); } -static int set_low_power_mode(int port, bool enable) +static int set_low_power_mode(const struct usb_mux *me, bool enable) { int regval; int rv; - rv = nb7v904m_read(port, NB7V904M_REG_GEN_DEV_SETTINGS, ®val); + rv = nb7v904m_read(me, NB7V904M_REG_GEN_DEV_SETTINGS, ®val); if (rv) return rv; @@ -45,28 +45,29 @@ static int set_low_power_mode(int port, bool enable) else regval &= ~NB7V904M_CHIP_EN; - return nb7v904m_write(port, NB7V904M_REG_GEN_DEV_SETTINGS, regval); + return nb7v904m_write(me, NB7V904M_REG_GEN_DEV_SETTINGS, regval); } -static int nb7v904m_enter_low_power_mode(int port) +static int nb7v904m_enter_low_power_mode(const struct usb_mux *me) { - int rv = set_low_power_mode(port, 1); + int rv = set_low_power_mode(me, 1); if (rv) - CPRINTS("C%d: NB7V904M: Failed to enter low power mode!", port); + CPRINTS("C%d: NB7V904M: Failed to enter low power mode!", + me->usb_port); return rv; } -static int nb7v904m_init(int port) +static int nb7v904m_init(const struct usb_mux *me) { - int rv = set_low_power_mode(port, 0); + int rv = set_low_power_mode(me, 0); if (rv) - CPRINTS("C%d: NB7V904M: init failed!", port); + CPRINTS("C%d: NB7V904M: init failed!", me->usb_port); return rv; } -static int nb7v904m_set_mux(int port, mux_state_t mux_state) +static int nb7v904m_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int rv = EC_SUCCESS; int regval; @@ -74,17 +75,17 @@ static int nb7v904m_set_mux(int port, mux_state_t mux_state) /* Turn off redriver if it's not needed at all. */ if (mux_state == USB_PD_MUX_NONE) - return nb7v904m_enter_low_power_mode(port); + return nb7v904m_enter_low_power_mode(me); - rv = nb7v904m_init(port); + rv = nb7v904m_init(me); if (rv) return rv; /* Clear operation mode field */ - rv = nb7v904m_read(port, NB7V904M_REG_GEN_DEV_SETTINGS, ®val); + rv = nb7v904m_read(me, NB7V904M_REG_GEN_DEV_SETTINGS, ®val); if (rv) { - CPRINTS("C%d %s: Failed to obtain dev settings!", port, - __func__); + CPRINTS("C%d %s: Failed to obtain dev settings!", + me->usb_port, __func__); return rv; } regval &= ~NB7V904M_OP_MODE_MASK; @@ -108,14 +109,14 @@ static int nb7v904m_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_DP_ENABLED) { /* Connect AUX */ - rv = nb7v904m_write(port, NB7V904M_REG_AUX_CH_CTRL, flipped ? + rv = nb7v904m_write(me, NB7V904M_REG_AUX_CH_CTRL, flipped ? NB7V904M_AUX_CH_FLIPPED : NB7V904M_AUX_CH_NORMAL); /* Enable all channels for DP */ regval |= NB7V904M_CH_EN_MASK; } else { /* Disconnect AUX since it's not being used. */ - rv = nb7v904m_write(port, NB7V904M_REG_AUX_CH_CTRL, + rv = nb7v904m_write(me, NB7V904M_REG_AUX_CH_CTRL, NB7V904M_AUX_CH_HI_Z); /* Disable the unused channels to save power */ @@ -129,14 +130,14 @@ static int nb7v904m_set_mux(int port, mux_state_t mux_state) } } - rv |= nb7v904m_write(port, NB7V904M_REG_GEN_DEV_SETTINGS, regval); + rv |= nb7v904m_write(me, NB7V904M_REG_GEN_DEV_SETTINGS, regval); if (rv) - CPRINTS("C%d: %s failed!", port, __func__); + CPRINTS("C%d: %s failed!", me->usb_port, __func__); return rv; } -const struct usb_retimer_driver nb7v904m_usb_redriver_drv = { +const struct usb_mux_driver nb7v904m_usb_redriver_drv = { .enter_low_power_mode = &nb7v904m_enter_low_power_mode, .init = &nb7v904m_init, .set = &nb7v904m_set_mux, diff --git a/driver/retimer/nb7v904m.h b/driver/retimer/nb7v904m.h index 4306615825..8bb43f79eb 100644 --- a/driver/retimer/nb7v904m.h +++ b/driver/retimer/nb7v904m.h @@ -37,5 +37,5 @@ #define NB7V904M_AUX_CH_FLIPPED BIT(0) #define NB7V904M_AUX_CH_HI_Z BIT(1) -extern const struct usb_retimer_driver nb7v904m_usb_redriver_drv; +extern const struct usb_mux_driver nb7v904m_usb_redriver_drv; #endif /* __CROS_EC_USB_REDRIVER_NB7V904M_H */ diff --git a/driver/retimer/pi3dpx1207.c b/driver/retimer/pi3dpx1207.c index 74eb80aac1..9254c3d4bb 100644 --- a/driver/retimer/pi3dpx1207.c +++ b/driver/retimer/pi3dpx1207.c @@ -21,8 +21,7 @@ static uint8_t buf[PI3DPX1207_NUM_REGISTERS]; /** * Local utility functions */ -static int pi3dpx1207_i2c_write(int i2c_port, - uint16_t addr_flags, +static int pi3dpx1207_i2c_write(const struct usb_mux *me, uint8_t offset, uint8_t val) { @@ -45,7 +44,7 @@ static int pi3dpx1207_i2c_write(int i2c_port, attempt = 0; do { attempt++; - rv = i2c_xfer(i2c_port, addr_flags, + rv = i2c_xfer(me->i2c_port, me->i2c_addr_flags, NULL, 0, buf, offset); } while ((rv != EC_SUCCESS) && (attempt < I2C_MAX_RETRIES)); } @@ -56,15 +55,16 @@ static int pi3dpx1207_i2c_write(int i2c_port, attempt = 0; do { attempt++; - rv = i2c_xfer(i2c_port, addr_flags, + rv = i2c_xfer(me->i2c_port, me->i2c_addr_flags, buf, offset + 1, NULL, 0); } while ((rv != EC_SUCCESS) && (attempt < I2C_MAX_RETRIES)); } return rv; } -static void pi3dpx1207_shutoff_power(int port) +static void pi3dpx1207_shutoff_power(const struct usb_mux *me) { + const int port = me->usb_port; const int gpio_enable = pi3dpx1207_controls[port].enable_gpio; const int gpio_dp_enable = pi3dpx1207_controls[port].dp_enable_gpio; @@ -75,27 +75,26 @@ static void pi3dpx1207_shutoff_power(int port) /** * Driver interface code */ -static int pi3dpx1207_init(int port) +static int pi3dpx1207_init(const struct usb_mux *me) { + const int port = me->usb_port; const int gpio_enable = pi3dpx1207_controls[port].enable_gpio; gpio_or_ioex_set_level(gpio_enable, 1); return EC_SUCCESS; } -static int pi3dpx1207_enter_low_power_mode(int port) +static int pi3dpx1207_enter_low_power_mode(const struct usb_mux *me) { - pi3dpx1207_shutoff_power(port); + pi3dpx1207_shutoff_power(me); return EC_SUCCESS; } -static int pi3dpx1207_set_mux(int port, mux_state_t mux_state) +static int pi3dpx1207_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int rv = EC_SUCCESS; uint8_t mode_val = PI3DPX1207_MODE_WATCHDOG_EN; - - const int i2c_port = usb_retimers[port].i2c_port; - const uint16_t i2c_addr_flags = usb_retimers[port].i2c_addr_flags; + const int port = me->usb_port; const int gpio_enable = pi3dpx1207_controls[port].enable_gpio; const int gpio_dp_enable = pi3dpx1207_controls[port].dp_enable_gpio; @@ -127,18 +126,16 @@ static int pi3dpx1207_set_mux(int port, mux_state_t mux_state) } /* Nothing enabled, power down the retimer */ else { - pi3dpx1207_shutoff_power(port); + pi3dpx1207_shutoff_power(me); return EC_SUCCESS; } /* Write the retimer config byte */ - rv = pi3dpx1207_i2c_write(i2c_port, i2c_addr_flags, - PI3DPX1207_MODE_OFFSET, - mode_val); + rv = pi3dpx1207_i2c_write(me, PI3DPX1207_MODE_OFFSET, mode_val); return rv; } -const struct usb_retimer_driver pi3dpx1207_usb_retimer = { +const struct usb_mux_driver pi3dpx1207_usb_retimer = { .init = pi3dpx1207_init, .set = pi3dpx1207_set_mux, .enter_low_power_mode = pi3dpx1207_enter_low_power_mode, diff --git a/driver/retimer/pi3dpx1207.h b/driver/retimer/pi3dpx1207.h index 53b849b081..2e3405d1aa 100644 --- a/driver/retimer/pi3dpx1207.h +++ b/driver/retimer/pi3dpx1207.h @@ -40,7 +40,7 @@ #define PI3DPX1207_MODE_CONF_USB_SUPER 0xC0 /* Supported USB retimer drivers */ -extern const struct usb_retimer_driver pi3dpx1207_usb_retimer; +extern const struct usb_mux_driver pi3dpx1207_usb_retimer; /* Retimer driver hardware specific controls */ struct pi3dpx1207_usb_control { diff --git a/driver/retimer/ps8802.c b/driver/retimer/ps8802.c index 94ea2e5797..c4a9a5478b 100644 --- a/driver/retimer/ps8802.c +++ b/driver/retimer/ps8802.c @@ -16,47 +16,47 @@ #define PS8802_DEBUG 0 #define PS8802_I2C_WAKE_DELAY 500 -int ps8802_i2c_read(int port, int page, int offset, int *data) +int ps8802_i2c_read(const struct usb_mux *me, int page, int offset, int *data) { int rv; - rv = i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, data); if (PS8802_DEBUG) ccprintf("%s(%d:0x%02X, 0x%02X) =>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->i2c_port, + me->i2c_addr_flags + page, offset, *data); return rv; } -int ps8802_i2c_write(int port, int page, int offset, int data) +int ps8802_i2c_write(const struct usb_mux *me, int page, int offset, int data) { int rv; int pre_val, post_val; if (PS8802_DEBUG) - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_write8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_write8(me->i2c_port, + me->i2c_addr_flags + page, offset, data); if (PS8802_DEBUG) { - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%02X) " "0x%02X=>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->i2c_port, + me->i2c_addr_flags + page, offset, data, pre_val, post_val); } @@ -64,30 +64,31 @@ int ps8802_i2c_write(int port, int page, int offset, int data) return rv; } -int ps8802_i2c_write16(int port, int page, int offset, int data) +int ps8802_i2c_write16(const struct usb_mux *me, int page, int offset, + int data) { int rv; int pre_val, post_val; if (PS8802_DEBUG) - i2c_read16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read16(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_write16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_write16(me->i2c_port, + me->i2c_addr_flags + page, offset, data); if (PS8802_DEBUG) { - i2c_read16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read16(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%04X) " "0x%04X=>0x%04X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->i2c_port, + me->i2c_addr_flags + page, offset, data, pre_val, post_val); } @@ -95,33 +96,33 @@ int ps8802_i2c_write16(int port, int page, int offset, int data) return rv; } -int ps8802_i2c_field_update8(int port, int page, int offset, +int ps8802_i2c_field_update8(const struct usb_mux *me, int page, int offset, uint8_t field_mask, uint8_t set_value) { int rv; int pre_val, post_val; if (PS8802_DEBUG) - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_field_update8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_field_update8(me->i2c_port, + me->i2c_addr_flags + page, offset, field_mask, set_value); if (PS8802_DEBUG) { - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%02X, 0x%02X) " "0x%02X=>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->i2c_port, + me->i2c_addr_flags + page, offset, field_mask, set_value, pre_val, post_val); } @@ -129,33 +130,33 @@ int ps8802_i2c_field_update8(int port, int page, int offset, return rv; } -int ps8802_i2c_field_update16(int port, int page, int offset, +int ps8802_i2c_field_update16(const struct usb_mux *me, int page, int offset, uint16_t field_mask, uint16_t set_value) { int rv; int pre_val, post_val; if (PS8802_DEBUG) - i2c_read16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read16(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_field_update16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_field_update16(me->i2c_port, + me->i2c_addr_flags + page, offset, field_mask, set_value); if (PS8802_DEBUG) { - i2c_read16(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read16(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%02X, 0x%04X) " "0x%04X=>0x%04X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->i2c_port, + me->i2c_addr_flags + page, offset, field_mask, set_value, pre_val, post_val); } @@ -168,14 +169,14 @@ int ps8802_i2c_field_update16(int port, int page, int offset, * From Application Note: 1) Activate by reading any Page 2 register. 2) Wait * 500 microseconds. 3) After 5 seconds idle, PS8802 will return to standby. */ -int ps8802_i2c_wake(int port) +int ps8802_i2c_wake(const struct usb_mux *me) { int data; int rv = EC_ERROR_UNKNOWN; /* If in standby, first read will fail, second should succeed. */ for (int i = 0; i < 2; i++) { - rv = ps8802_i2c_read(port, + rv = ps8802_i2c_read(me, PS8802_REG_PAGE2, PS8802_REG2_MODE, &data); @@ -188,39 +189,39 @@ int ps8802_i2c_wake(int port) return rv; } -int ps8802_detect(int port) +int ps8802_detect(const struct usb_mux *me) { int rv = EC_ERROR_NOT_POWERED; /* Detected if we are powered and can read the device */ if (!chipset_in_state(CHIPSET_STATE_HARD_OFF)) - rv = ps8802_i2c_wake(port); + rv = ps8802_i2c_wake(me); return rv; } -static int ps8802_init(int port) +static int ps8802_init(const struct usb_mux *me) { return EC_SUCCESS; } -static int ps8802_set_mux(int port, mux_state_t mux_state) +static int ps8802_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int val; int rv; if (chipset_in_state(CHIPSET_STATE_HARD_OFF)) return (mux_state == USB_PD_MUX_NONE) ? EC_SUCCESS - : EC_ERROR_NOT_POWERED; + : EC_ERROR_NOT_POWERED; /* Make sure the PS8802 is awake */ - rv = ps8802_i2c_wake(port); + rv = ps8802_i2c_wake(me); if (rv) return rv; if (PS8802_DEBUG) ccprintf("%s(%d, 0x%02X) %s %s %s\n", - __func__, port, mux_state, + __func__, me->usb_port, mux_state, (mux_state & USB_PD_MUX_USB_ENABLED) ? "USB" : "", (mux_state & USB_PD_MUX_DP_ENABLED) ? "DP" : "", (mux_state & USB_PD_MUX_POLARITY_INVERTED) @@ -239,24 +240,15 @@ static int ps8802_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) val |= PS8802_MODE_FLIP_ENABLE; - rv = ps8802_i2c_write(port, + rv = ps8802_i2c_write(me, PS8802_REG_PAGE2, PS8802_REG2_MODE, val); - if (rv) - return rv; - - /* Board specific retimer mux tuning */ - if (usb_retimers[port].tune) { - rv = usb_retimers[port].tune(port, mux_state); - if (rv) - return rv; - } return rv; } -static int ps8802_get_mux(int port, mux_state_t *mux_state) +static int ps8802_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { int rv; int val; @@ -266,11 +258,11 @@ static int ps8802_get_mux(int port, mux_state_t *mux_state) if (chipset_in_state(CHIPSET_STATE_HARD_OFF)) return EC_ERROR_NOT_POWERED; - rv = ps8802_i2c_wake(port); + rv = ps8802_i2c_wake(me); if (rv) return rv; - rv = ps8802_i2c_read(port, + rv = ps8802_i2c_read(me, PS8802_REG_PAGE2, PS8802_REG2_MODE, &val); @@ -287,17 +279,6 @@ static int ps8802_get_mux(int port, mux_state_t *mux_state) return rv; } -/* - * PS8802 can look like a retimer or a MUX. So create both tables - * and use them as needed, until retimers become a type of MUX and - * then we will only need one of these tables. - * - * TODO(b:147593660) Cleanup of retimers as muxes in a more - * generalized mechanism - */ -const struct usb_retimer_driver ps8802_usb_retimer = { - .set = ps8802_set_mux, -}; const struct usb_mux_driver ps8802_usb_mux_driver = { .init = ps8802_init, .set = ps8802_set_mux, diff --git a/driver/retimer/ps8802.h b/driver/retimer/ps8802.h index 7c1b5c0cc8..2e4a301275 100644 --- a/driver/retimer/ps8802.h +++ b/driver/retimer/ps8802.h @@ -4,6 +4,7 @@ * * PS8802 retimer. */ +#include "usb_mux.h" #ifndef __CROS_EC_USB_RETIMER_PS8802_H #define __CROS_EC_USB_RETIMER_PS8802_H @@ -65,17 +66,17 @@ extern const struct usb_mux_driver ps8802_usb_mux_driver; -extern const struct usb_retimer_driver ps8802_usb_retimer; -int ps8802_i2c_wake(int port); -int ps8802_detect(int port); +int ps8802_i2c_wake(const struct usb_mux *me); +int ps8802_detect(const struct usb_mux *me); -int ps8802_i2c_read(int port, int page, int offset, int *data); -int ps8802_i2c_write(int port, int page, int offset, int data); -int ps8802_i2c_write16(int port, int page, int offset, int data); -int ps8802_i2c_field_update8(int port, int page, int offset, +int ps8802_i2c_read(const struct usb_mux *me, int page, int offset, int *data); +int ps8802_i2c_write(const struct usb_mux *me, int page, int offset, int data); +int ps8802_i2c_write16(const struct usb_mux *me, int page, int offset, + int data); +int ps8802_i2c_field_update8(const struct usb_mux *me, int page, int offset, uint8_t field_mask, uint8_t set_value); -int ps8802_i2c_field_update16(int port, int page, int offset, +int ps8802_i2c_field_update16(const struct usb_mux *me, int page, int offset, uint16_t field_mask, uint16_t set_value); #endif /* __CROS_EC_USB_RETIMER_PS8802_H */ diff --git a/driver/retimer/ps8818.c b/driver/retimer/ps8818.c index 10dc70dca0..e70b8bf986 100644 --- a/driver/retimer/ps8818.c +++ b/driver/retimer/ps8818.c @@ -16,47 +16,47 @@ #define PS8818_DEBUG 0 -int ps8818_i2c_read(int port, int page, int offset, int *data) +int ps8818_i2c_read(const struct usb_mux *me, int page, int offset, int *data) { int rv; - rv = i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, data); if (PS8818_DEBUG) ccprintf("%s(%d:0x%02X, 0x%02X) =>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->usb_port, + me->i2c_addr_flags + page, offset, *data); return rv; } -int ps8818_i2c_write(int port, int page, int offset, int data) +int ps8818_i2c_write(const struct usb_mux *me, int page, int offset, int data) { int rv; int pre_val, post_val; if (PS8818_DEBUG) - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_write8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_write8(me->i2c_port, + me->i2c_addr_flags + page, offset, data); if (PS8818_DEBUG) { - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%02X) " "0x%02X=>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->usb_port, + me->i2c_addr_flags + page, offset, data, pre_val, post_val); } @@ -64,33 +64,33 @@ int ps8818_i2c_write(int port, int page, int offset, int data) return rv; } -int ps8818_i2c_field_update8(int port, int page, int offset, +int ps8818_i2c_field_update8(const struct usb_mux *me, int page, int offset, uint8_t field_mask, uint8_t set_value) { int rv; int pre_val, post_val; if (PS8818_DEBUG) - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &pre_val); - rv = i2c_field_update8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + rv = i2c_field_update8(me->i2c_port, + me->i2c_addr_flags + page, offset, field_mask, set_value); if (PS8818_DEBUG) { - i2c_read8(usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + i2c_read8(me->i2c_port, + me->i2c_addr_flags + page, offset, &post_val); ccprintf("%s(%d:0x%02X, 0x%02X, 0x%02X, 0x%02X) " "0x%02X=>0x%02X\n", __func__, - usb_retimers[port].i2c_port, - usb_retimers[port].i2c_addr_flags + page, + me->usb_port, + me->i2c_addr_flags + page, offset, field_mask, set_value, pre_val, post_val); } @@ -98,14 +98,14 @@ int ps8818_i2c_field_update8(int port, int page, int offset, return rv; } -int ps8818_detect(int port) +int ps8818_detect(const struct usb_mux *me) { int rv = EC_ERROR_NOT_POWERED; int val; /* Detected if we are powered and can read the device */ if (!chipset_in_state(CHIPSET_STATE_HARD_OFF)) - rv = ps8818_i2c_read(port, + rv = ps8818_i2c_read(me, PS8818_REG_PAGE0, PS8818_REG0_FLIP, &val); @@ -113,7 +113,7 @@ int ps8818_detect(int port) return rv; } -static int ps8818_set_mux(int port, mux_state_t mux_state) +static int ps8818_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int rv; int val = 0; @@ -124,7 +124,7 @@ static int ps8818_set_mux(int port, mux_state_t mux_state) if (PS8818_DEBUG) ccprintf("%s(%d, 0x%02X) %s %s %s\n", - __func__, port, mux_state, + __func__, me->usb_port, mux_state, (mux_state & USB_PD_MUX_USB_ENABLED) ? "USB" : "", (mux_state & USB_PD_MUX_DP_ENABLED) ? "DP" : "", (mux_state & USB_PD_MUX_POLARITY_INVERTED) @@ -136,7 +136,7 @@ static int ps8818_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_DP_ENABLED) val |= PS8818_MODE_DP_ENABLE; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE0, PS8818_REG0_MODE, PS8818_MODE_NON_RESERVED_MASK, @@ -149,7 +149,7 @@ static int ps8818_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) val |= PS8818_FLIP_CONFIG; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE0, PS8818_REG0_FLIP, PS8818_FLIP_NON_RESERVED_MASK, @@ -162,24 +162,15 @@ static int ps8818_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_DP_ENABLED) val |= PS8818_DPHPD_PLUGGED; - rv = ps8818_i2c_field_update8(port, + rv = ps8818_i2c_field_update8(me, PS8818_REG_PAGE0, PS8818_REG0_DPHPD_CONFIG, PS8818_DPHPD_NON_RESERVED_MASK, val); - if (rv) - return rv; - - /* Board specific retimer mux tuning */ - if (usb_retimers[port].tune) { - rv = usb_retimers[port].tune(port, mux_state); - if (rv) - return rv; - } return rv; } -const struct usb_retimer_driver ps8818_usb_retimer = { +const struct usb_mux_driver ps8818_usb_retimer_driver = { .set = ps8818_set_mux, }; diff --git a/driver/retimer/ps8818.h b/driver/retimer/ps8818.h index a28d04a38b..c761284cf8 100644 --- a/driver/retimer/ps8818.h +++ b/driver/retimer/ps8818.h @@ -4,6 +4,7 @@ * * PS8818 retimer. */ +#include "usb_mux.h" #ifndef __CROS_EC_USB_RETIMER_PS8818_H #define __CROS_EC_USB_RETIMER_PS8818_H @@ -77,13 +78,16 @@ #define PS8818_STATUS_NORMAL_OPERATION BIT(7) #define PS8818_STATUS_10_GBPS BIT(5) -extern const struct usb_retimer_driver ps8818_usb_retimer; +extern const struct usb_mux_driver ps8818_usb_retimer_driver; -int ps8818_detect(int port); +int ps8818_detect(const struct usb_mux *me); -int ps8818_i2c_read(int port, int page, int offset, int *data); -int ps8818_i2c_write(int port, int page, int offset, int data); -int ps8818_i2c_field_update8(int port, int page, int offset, +int ps8818_i2c_read(const struct usb_mux *me, + int page, int offset, int *data); +int ps8818_i2c_write(const struct usb_mux *me, + int page, int offset, int data); +int ps8818_i2c_field_update8(const struct usb_mux *me, + int page, int offset, uint8_t field_mask, uint8_t set_value); #endif /* __CROS_EC_USB_RETIMER_PS8818_H */ diff --git a/driver/tcpm/anx7447.c b/driver/tcpm/anx7447.c index ed4e601f6c..a093aa9094 100644 --- a/driver/tcpm/anx7447.c +++ b/driver/tcpm/anx7447.c @@ -48,7 +48,7 @@ struct anx_usb_mux { int state; }; -static int anx7447_mux_set(int port, mux_state_t mux_state); +static int anx7447_mux_set(const struct usb_mux *me, mux_state_t mux_state); static struct anx_state anx[CONFIG_USB_PD_PORT_MAX_COUNT]; static struct anx_usb_mux mux[CONFIG_USB_PD_PORT_MAX_COUNT]; @@ -285,6 +285,7 @@ DECLARE_CONSOLE_COMMAND(anx_ocm, command_anx_ocm, static int anx7447_init(int port) { int rv, reg, i; + const struct usb_mux *me = &usb_muxes[port]; ASSERT(port < CONFIG_USB_PD_PORT_MAX_COUNT); @@ -363,14 +364,20 @@ static int anx7447_init(int port) reg &= ~ANX7447_REG_R_VCONN_PWR_PRT_INRUSH_TIME_MASK; reg |= ANX7447_REG_R_VCONN_PWR_PRT_INRUSH_TIME_2430US; rv = tcpc_write(port, ANX7447_REG_ANALOG_CTRL_10, reg); + if (rv) + return rv; #ifdef CONFIG_USB_PD_TCPM_MUX /* * Run mux_set() here for considering CCD(Case-Closed Debugging) case * If this TCPC is not also the MUX then don't initialize to NONE */ - if (!(usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC)) - rv |= anx7447_mux_set(port, USB_PD_MUX_NONE); + while ((me != NULL) && (me->driver != &anx7447_usb_mux_driver)) + me = me->next_mux; + + if (me != NULL && + !(me->flags & USB_MUX_FLAG_NOT_TCPC)) + rv = anx7447_mux_set(me, USB_PD_MUX_NONE); #endif /* CONFIG_USB_PD_TCPM_MUX */ return rv; @@ -453,9 +460,11 @@ static void anx7447_tcpc_alert(int port) */ static uint64_t hpd_deadline[CONFIG_USB_PD_PORT_MAX_COUNT]; -void anx7447_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) +void anx7447_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { int reg = 0; + int port = me->usb_port; /* * All calls within this method need to update to a mux_read/write calls @@ -464,7 +473,7 @@ void anx7447_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) * it doesn't have a re-driver). If that changes, we need to update this * code. */ - ASSERT(!(usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC)); + ASSERT(!(me->flags & USB_MUX_FLAG_NOT_TCPC)); anx7447_set_hpd_level(port, hpd_lvl); @@ -492,8 +501,10 @@ void anx7447_tcpc_clear_hpd_status(int port) } #ifdef CONFIG_USB_PD_TCPM_MUX -static int anx7447_mux_init(int port) +static int anx7447_mux_init(const struct usb_mux *me) { + int port = me->usb_port; + ASSERT(port < CONFIG_USB_PD_PORT_MAX_COUNT); memset(&mux[port], 0, sizeof(struct anx_usb_mux)); @@ -508,41 +519,42 @@ static int anx7447_mux_init(int port) * USB_PD_MUX_DP_ENABLED) when reinitialized, we need to force * initialize it to USB_PD_MUX_NONE */ - return anx7447_mux_set(port, USB_PD_MUX_NONE); + return anx7447_mux_set(me, USB_PD_MUX_NONE); } #ifdef CONFIG_USB_PD_TCPM_ANX7447_AUX_PU_PD -static void anx7447_mux_safemode(int port, int on_off) +static void anx7447_mux_safemode(const struct usb_mux *me, int on_off) { int reg; - mux_read(port, ANX7447_REG_ANALOG_CTRL_9, ®); + mux_read(me, ANX7447_REG_ANALOG_CTRL_9, ®); if (on_off) reg |= ANX7447_REG_SAFE_MODE; else reg &= ~(ANX7447_REG_SAFE_MODE); - mux_write(port, ANX7447_REG_ANALOG_CTRL_9, reg); + mux_write(me, ANX7447_REG_ANALOG_CTRL_9, reg); CPRINTS("C%d set mux to safemode %s, reg = 0x%x", - port, (on_off) ? "on" : "off", reg); + me->usb_port, (on_off) ? "on" : "off", reg); } -static inline void anx7447_configure_aux_src(int port, int on_off) +static inline void anx7447_configure_aux_src(const struct usb_mux *me, + int on_off) { int reg; - mux_read(port, ANX7447_REG_ANALOG_CTRL_9, ®); + mux_read(me, ANX7447_REG_ANALOG_CTRL_9, ®); if (on_off) reg |= ANX7447_REG_R_AUX_RES_PULL_SRC; else reg &= ~(ANX7447_REG_R_AUX_RES_PULL_SRC); - mux_write(port, ANX7447_REG_ANALOG_CTRL_9, reg); + mux_write(me, ANX7447_REG_ANALOG_CTRL_9, reg); CPRINTS("C%d set aux_src to %s, reg = 0x%x", - port, (on_off) ? "on" : "off", reg); + me->usb_port, (on_off) ? "on" : "off", reg); } #endif @@ -555,12 +567,13 @@ static inline void anx7447_configure_aux_src(int port, int on_off) * * a2, a3, a10, a11, b2, b3, b10, b11 are pins on the USB-C connector. */ -static int anx7447_mux_set(int port, mux_state_t mux_state) +static int anx7447_mux_set(const struct usb_mux *me, mux_state_t mux_state) { int cc_direction; mux_state_t mux_type; int sw_sel = 0x00, aux_sw = 0x00; int rv; + int port = me->usb_port; cc_direction = mux_state & USB_PD_MUX_POLARITY_INVERTED; mux_type = mux_state & USB_PD_MUX_DOCK; @@ -605,11 +618,11 @@ static int anx7447_mux_set(int port, mux_state_t mux_state) * first. After the mux configured, should set mux to normal mode. */ #ifdef CONFIG_USB_PD_TCPM_ANX7447_AUX_PU_PD - anx7447_mux_safemode(port, 1); + anx7447_mux_safemode(me, 1); #endif - rv = mux_write(port, ANX7447_REG_TCPC_SWITCH_0, sw_sel); - rv |= mux_write(port, ANX7447_REG_TCPC_SWITCH_1, sw_sel); - rv |= mux_write(port, ANX7447_REG_TCPC_AUX_SWITCH, aux_sw); + rv = mux_write(me, ANX7447_REG_TCPC_SWITCH_0, sw_sel); + rv |= mux_write(me, ANX7447_REG_TCPC_SWITCH_1, sw_sel); + rv |= mux_write(me, ANX7447_REG_TCPC_AUX_SWITCH, aux_sw); mux[port].state = mux_state; @@ -619,18 +632,20 @@ static int anx7447_mux_set(int port, mux_state_t mux_state) * normal mode, otherwise: keep safe mode. */ if (mux_type != USB_PD_MUX_NONE) { - anx7447_configure_aux_src(port, 1); - anx7447_mux_safemode(port, 0); + anx7447_configure_aux_src(me, 1); + anx7447_mux_safemode(me, 0); } else - anx7447_configure_aux_src(port, 0); + anx7447_configure_aux_src(me, 0); #endif return rv; } /* current mux state */ -static int anx7447_mux_get(int port, mux_state_t *mux_state) +static int anx7447_mux_get(const struct usb_mux *me, mux_state_t *mux_state) { + int port = me->usb_port; + *mux_state = mux[port].state; return EC_SUCCESS; @@ -650,7 +665,8 @@ static int anx7447_set_cc(int port, int pull) } /* Override for tcpci_tcpm_set_polarity */ -static int anx7447_set_polarity(int port, enum tcpc_cc_polarity polarity) +static int anx7447_set_polarity(int port, + enum tcpc_cc_polarity polarity) { return tcpc_update8(port, TCPC_REG_TCPC_CTRL, diff --git a/driver/tcpm/anx7447.h b/driver/tcpm/anx7447.h index 4da300884c..849b3c3189 100644 --- a/driver/tcpm/anx7447.h +++ b/driver/tcpm/anx7447.h @@ -3,6 +3,8 @@ * found in the LICENSE file. */ +#include "usb_mux.h" + /* USB Power delivery port management */ #ifndef __CROS_EC_USB_PD_TCPM_ANX7447_H @@ -127,8 +129,9 @@ void anx7447_hpd_output_en(int port); extern const struct tcpm_drv anx7447_tcpm_drv; extern const struct usb_mux_driver anx7447_usb_mux_driver; -void anx7447_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq); void anx7447_tcpc_clear_hpd_status(int port); +void anx7447_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq); /** * Erase OCM flash if it's not empty diff --git a/driver/tcpm/anx74xx.c b/driver/tcpm/anx74xx.c index 0e9635e6b1..938b65a14f 100644 --- a/driver/tcpm/anx74xx.c +++ b/driver/tcpm/anx74xx.c @@ -226,16 +226,18 @@ static void anx74xx_tcpc_discharge_vbus(int port, int enable) */ static uint64_t hpd_deadline[CONFIG_USB_PD_PORT_MAX_COUNT]; -void anx74xx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) +void anx74xx_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { int reg; + int port = me->usb_port; - mux_read(port, ANX74XX_REG_HPD_CTRL_0, ®); + mux_read(me, ANX74XX_REG_HPD_CTRL_0, ®); if (hpd_lvl) reg |= ANX74XX_REG_HPD_OUT_DATA; else reg &= ~ANX74XX_REG_HPD_OUT_DATA; - mux_write(port, ANX74XX_REG_HPD_CTRL_0, reg); + mux_write(me, ANX74XX_REG_HPD_CTRL_0, reg); if (hpd_irq) { uint64_t now = get_time().val; @@ -243,12 +245,12 @@ void anx74xx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) if (now < hpd_deadline[port]) usleep(hpd_deadline[port] - now); - mux_read(port, ANX74XX_REG_HPD_CTRL_0, ®); + mux_read(me, ANX74XX_REG_HPD_CTRL_0, ®); reg &= ~ANX74XX_REG_HPD_OUT_DATA; - mux_write(port, ANX74XX_REG_HPD_CTRL_0, reg); + mux_write(me, ANX74XX_REG_HPD_CTRL_0, reg); usleep(HPD_DSTREAM_DEBOUNCE_IRQ); reg |= ANX74XX_REG_HPD_OUT_DATA; - mux_write(port, ANX74XX_REG_HPD_CTRL_0, reg); + mux_write(me, ANX74XX_REG_HPD_CTRL_0, reg); } /* enforce 2-ms delay between HPD pulses */ hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; @@ -264,12 +266,13 @@ void anx74xx_tcpc_clear_hpd_status(int port) } #ifdef CONFIG_USB_PD_TCPM_MUX -static int anx74xx_tcpm_mux_init(int port) +static int anx74xx_tcpm_mux_init(const struct usb_mux *me) { /* Nothing to do here, ANX initializes its muxes * as (USB_PD_MUX_USB_ENABLED | USB_PD_MUX_DP_ENABLED) */ - anx[port].mux_state = USB_PD_MUX_USB_ENABLED | USB_PD_MUX_DP_ENABLED; + anx[me->usb_port].mux_state = USB_PD_MUX_USB_ENABLED | + USB_PD_MUX_DP_ENABLED; return EC_SUCCESS; } @@ -277,10 +280,11 @@ static int anx74xx_tcpm_mux_init(int port) static int anx74xx_tcpm_mux_enter_safe_mode(int port) { int reg; + const struct usb_mux *me = &usb_muxes[port]; - if (mux_read(port, ANX74XX_REG_ANALOG_CTRL_2, ®)) + if (mux_read(me, ANX74XX_REG_ANALOG_CTRL_2, ®)) return EC_ERROR_UNKNOWN; - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_2, reg | + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_2, reg | ANX74XX_REG_MODE_TRANS)) return EC_ERROR_UNKNOWN; @@ -291,10 +295,11 @@ static int anx74xx_tcpm_mux_enter_safe_mode(int port) static int anx74xx_tcpm_mux_exit_safe_mode(int port) { int reg; + const struct usb_mux *me = &usb_muxes[port]; - if (mux_read(port, ANX74XX_REG_ANALOG_CTRL_2, ®)) + if (mux_read(me, ANX74XX_REG_ANALOG_CTRL_2, ®)) return EC_ERROR_UNKNOWN; - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_2, reg & + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_2, reg & ~ANX74XX_REG_MODE_TRANS)) return EC_ERROR_UNKNOWN; @@ -305,6 +310,7 @@ static int anx74xx_tcpm_mux_exit_safe_mode(int port) static int anx74xx_tcpm_mux_exit(int port) { int reg; + const struct usb_mux *me = &usb_muxes[port]; /* * Safe mode must be entered before any changes are made to the mux @@ -318,18 +324,18 @@ static int anx74xx_tcpm_mux_exit(int port) return EC_ERROR_UNKNOWN; /* Disconnect aux from sbu */ - if (mux_read(port, ANX74XX_REG_ANALOG_CTRL_2, ®)) + if (mux_read(me, ANX74XX_REG_ANALOG_CTRL_2, ®)) return EC_ERROR_UNKNOWN; - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_2, reg & 0xf)) + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_2, reg & 0xf)) return EC_ERROR_UNKNOWN; /* Clear Bit[7:0] R_SWITCH */ - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_1, 0x0)) + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_1, 0x0)) return EC_ERROR_UNKNOWN; /* Clear Bit[7:4] R_SWITCH_H */ - if (mux_read(port, ANX74XX_REG_ANALOG_CTRL_5, ®)) + if (mux_read(me, ANX74XX_REG_ANALOG_CTRL_5, ®)) return EC_ERROR_UNKNOWN; - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_5, reg & 0x0f)) + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_5, reg & 0x0f)) return EC_ERROR_UNKNOWN; /* Exit safe mode */ @@ -345,6 +351,7 @@ static int anx74xx_mux_aux_to_sbu(int port, int polarity, int enabled) int reg; const int aux_mask = ANX74XX_REG_AUX_SWAP_SET_CC2 | ANX74XX_REG_AUX_SWAP_SET_CC1; + const struct usb_mux *me = &usb_muxes[port]; /* * Get the current value of analog_ctrl_2 register. Note, that safe mode @@ -352,7 +359,7 @@ static int anx74xx_mux_aux_to_sbu(int port, int polarity, int enabled) * about setting the correct value for the upper 4 bits of analog_ctrl_2 * here. */ - if (mux_read(port, ANX74XX_REG_ANALOG_CTRL_2, ®)) + if (mux_read(me, ANX74XX_REG_ANALOG_CTRL_2, ®)) return EC_ERROR_UNKNOWN; /* Assume aux_p/n lines are not connected */ @@ -366,25 +373,26 @@ static int anx74xx_mux_aux_to_sbu(int port, int polarity, int enabled) reg |= ANX74XX_REG_AUX_SWAP_SET_CC1; } /* Write new aux <-> sbu settings */ - if (mux_write(port, ANX74XX_REG_ANALOG_CTRL_2, reg)) + if (mux_write(me, ANX74XX_REG_ANALOG_CTRL_2, reg)) return EC_ERROR_UNKNOWN; return EC_SUCCESS; } -static int anx74xx_tcpm_mux_set(int i2c_addr, mux_state_t mux_state) +static int anx74xx_tcpm_mux_set(const struct usb_mux *me, + mux_state_t mux_state) { int ctrl5; int ctrl1 = 0; int rv; - int port = i2c_addr; + int port = me->usb_port; if (!(mux_state & ~USB_PD_MUX_POLARITY_INVERTED)) { anx[port].mux_state = mux_state; return anx74xx_tcpm_mux_exit(port); } - rv = mux_read(port, ANX74XX_REG_ANALOG_CTRL_5, &ctrl5); + rv = mux_read(me, ANX74XX_REG_ANALOG_CTRL_5, &ctrl5); if (rv) return EC_ERROR_UNKNOWN; ctrl5 &= 0x0f; @@ -436,9 +444,9 @@ static int anx74xx_tcpm_mux_set(int i2c_addr, mux_state_t mux_state) return EC_ERROR_UNKNOWN; /* Write updated pin assignment */ - rv = mux_write(port, ANX74XX_REG_ANALOG_CTRL_1, ctrl1); + rv = mux_write(me, ANX74XX_REG_ANALOG_CTRL_1, ctrl1); /* Write Rswitch config bits */ - rv |= mux_write(port, ANX74XX_REG_ANALOG_CTRL_5, ctrl5); + rv |= mux_write(me, ANX74XX_REG_ANALOG_CTRL_5, ctrl5); if (rv) return EC_ERROR_UNKNOWN; @@ -458,17 +466,18 @@ static int anx74xx_tcpm_mux_set(int i2c_addr, mux_state_t mux_state) } /* current mux state */ -static int anx74xx_tcpm_mux_get(int port, mux_state_t *mux_state) +static int anx74xx_tcpm_mux_get(const struct usb_mux *me, + mux_state_t *mux_state) { - *mux_state = anx[port].mux_state; + *mux_state = anx[me->usb_port].mux_state; return EC_SUCCESS; } const struct usb_mux_driver anx74xx_tcpm_usb_mux_driver = { - .init = anx74xx_tcpm_mux_init, - .set = anx74xx_tcpm_mux_set, - .get = anx74xx_tcpm_mux_get, + .init = &anx74xx_tcpm_mux_init, + .set = &anx74xx_tcpm_mux_set, + .get = &anx74xx_tcpm_mux_get, }; #endif /* CONFIG_USB_PD_TCPM_MUX */ @@ -764,6 +773,7 @@ static int anx74xx_tcpm_set_cc(int port, int pull) static int anx74xx_tcpm_set_polarity(int port, enum tcpc_cc_polarity polarity) { int reg, mux_state, rv = EC_SUCCESS; + const struct usb_mux *me = &usb_muxes[port]; rv |= tcpc_read(port, ANX74XX_REG_CC_SOFTWARE_CTRL, ®); if (polarity_rm_dts(polarity)) /* Inform ANX to use CC2 */ @@ -779,7 +789,7 @@ static int anx74xx_tcpm_set_polarity(int port, enum tcpc_cc_polarity polarity) mux_state = anx[port].mux_state & ~USB_PD_MUX_POLARITY_INVERTED; if (polarity_rm_dts(polarity)) mux_state |= USB_PD_MUX_POLARITY_INVERTED; - anx74xx_tcpm_mux_set(port, mux_state); + anx74xx_tcpm_mux_set(me, mux_state); #endif return rv; } diff --git a/driver/tcpm/anx74xx.h b/driver/tcpm/anx74xx.h index 2648013abf..d7ba62bda3 100644 --- a/driver/tcpm/anx74xx.h +++ b/driver/tcpm/anx74xx.h @@ -5,6 +5,8 @@ * Author : Analogix Semiconductor. */ +#include "usb_mux.h" + /* USB Power delivery port management */ #ifndef __CROS_EC_USB_PD_TCPM_ANX74XX_H @@ -216,8 +218,9 @@ extern const struct tcpm_drv anx74xx_tcpm_drv; extern const struct usb_mux_driver anx74xx_tcpm_usb_mux_driver; void anx74xx_tcpc_set_vbus(int port, int enable); -void anx74xx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq); void anx74xx_tcpc_clear_hpd_status(int port); +void anx74xx_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq); #ifdef CONFIG_CMD_I2C_STRESS_TEST_TCPC extern struct i2c_stress_test_dev anx74xx_i2c_stress_test_dev; diff --git a/driver/tcpm/anx7688.c b/driver/tcpm/anx7688.c index bc3d1b8354..8b5a70cf73 100644 --- a/driver/tcpm/anx7688.c +++ b/driver/tcpm/anx7688.c @@ -144,12 +144,12 @@ static void anx7688_tcpc_alert(int port) anx7688_update_hpd_enable(port); } -static int anx7688_mux_set(int port, mux_state_t mux_state) +static int anx7688_mux_set(const struct usb_mux *me, mux_state_t mux_state) { int reg = 0; int rv, polarity; - rv = mux_read(port, TCPC_REG_CONFIG_STD_OUTPUT, ®); + rv = mux_read(me, TCPC_REG_CONFIG_STD_OUTPUT, ®); if (rv != EC_SUCCESS) return rv; @@ -160,14 +160,14 @@ static int anx7688_mux_set(int port, mux_state_t mux_state) reg |= TCPC_REG_CONFIG_STD_OUTPUT_MUX_DP; /* ANX7688 needs to set bit0 */ - rv = mux_read(port, TCPC_REG_TCPC_CTRL, &polarity); + rv = mux_read(me, TCPC_REG_TCPC_CTRL, &polarity); if (rv != EC_SUCCESS) return rv; /* copy the polarity from TCPC_CTRL[0], take care clear then set */ reg &= ~TCPC_REG_TCPC_CTRL_POLARITY(1); reg |= TCPC_REG_TCPC_CTRL_POLARITY(polarity); - return mux_write(port, TCPC_REG_CONFIG_STD_OUTPUT, reg); + return mux_write(me, TCPC_REG_CONFIG_STD_OUTPUT, reg); } #ifdef CONFIG_USB_PD_VBUS_DETECT_TCPC diff --git a/driver/tcpm/ps8xxx.c b/driver/tcpm/ps8xxx.c index 77de4fca15..9151eaf841 100644 --- a/driver/tcpm/ps8xxx.c +++ b/driver/tcpm/ps8xxx.c @@ -17,6 +17,7 @@ #include "tcpci.h" #include "tcpm.h" #include "timer.h" +#include "usb_mux.h" #include "usb_pd.h" #if !defined(CONFIG_USB_PD_TCPM_PS8751) && \ @@ -40,40 +41,42 @@ */ static uint64_t hpd_deadline[CONFIG_USB_PD_PORT_MAX_COUNT]; -static int dp_set_hpd(int port, int enable) +static int dp_set_hpd(const struct usb_mux *me, int enable) { int reg; int rv; - rv = mux_read(port, MUX_IN_HPD_ASSERTION_REG, ®); + rv = mux_read(me, MUX_IN_HPD_ASSERTION_REG, ®); if (rv) return rv; if (enable) reg |= IN_HPD; else reg &= ~IN_HPD; - return mux_write(port, MUX_IN_HPD_ASSERTION_REG, reg); + return mux_write(me, MUX_IN_HPD_ASSERTION_REG, reg); } -static int dp_set_irq(int port, int enable) +static int dp_set_irq(const struct usb_mux *me, int enable) { - int reg; int rv; - rv = mux_read(port, MUX_IN_HPD_ASSERTION_REG, ®); + rv = mux_read(me, MUX_IN_HPD_ASSERTION_REG, ®); if (rv) return rv; if (enable) reg |= HPD_IRQ; else reg &= ~HPD_IRQ; - return mux_write(port, MUX_IN_HPD_ASSERTION_REG, reg); + return mux_write(me, MUX_IN_HPD_ASSERTION_REG, reg); } -void ps8xxx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) +void ps8xxx_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq) { - dp_set_hpd(port, hpd_lvl); + int port = me->usb_port; + + dp_set_hpd(me, hpd_lvl); if (hpd_irq) { uint64_t now = get_time().val; @@ -81,9 +84,9 @@ void ps8xxx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq) if (now < hpd_deadline[port]) usleep(hpd_deadline[port] - now); - dp_set_irq(port, 0); + dp_set_irq(me, 0); usleep(HPD_DSTREAM_DEBOUNCE_IRQ); - dp_set_irq(port, hpd_irq); + dp_set_irq(me, hpd_irq); } /* enforce 2-ms delay between HPD pulses */ hpd_deadline[port] = get_time().val + HPD_USTREAM_DEBOUNCE_LVL; @@ -380,26 +383,26 @@ struct i2c_stress_test_dev ps8xxx_i2c_stress_test_dev = { }; #endif /* CONFIG_CMD_I2C_STRESS_TEST_TCPC */ -static int ps8xxx_mux_init(int port) +static int ps8xxx_mux_init(const struct usb_mux *me) { - tcpci_tcpm_mux_init(port); + tcpci_tcpm_mux_init(me); /* If this MUX is also the TCPC, then skip init */ - if (!(usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC)) + if (!(me->flags & USB_MUX_FLAG_NOT_TCPC)) return EC_SUCCESS; /* We always want to be a sink when this device is only being used as a mux * to support external peripherals better. */ - return mux_write(port, TCPC_REG_ROLE_CTRL, + return mux_write(me, TCPC_REG_ROLE_CTRL, TCPC_REG_ROLE_CTRL_SET(0, 1, TYPEC_CC_RD, TYPEC_CC_RD)); } -static int ps8xxx_mux_enter_low_power_mode(int port) +static int ps8xxx_mux_enter_low_power_mode(const struct usb_mux *me) { - mux_write(port, TCPC_REG_ROLE_CTRL, + mux_write(me, TCPC_REG_ROLE_CTRL, TCPC_REG_ROLE_CTRL_SET(0, 0, TYPEC_CC_RP, TYPEC_CC_RP)); - return tcpci_tcpm_mux_enter_low_power(port); + return tcpci_tcpm_mux_enter_low_power(me); } /* This is meant for mux-only applications */ diff --git a/driver/tcpm/ps8xxx.h b/driver/tcpm/ps8xxx.h index ff78a74041..f865598e34 100644 --- a/driver/tcpm/ps8xxx.h +++ b/driver/tcpm/ps8xxx.h @@ -2,6 +2,7 @@ * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ +#include "usb_mux.h" /* Parade Tech Type-C port controller */ @@ -93,7 +94,8 @@ #endif extern const struct tcpm_drv ps8xxx_tcpm_drv; -void ps8xxx_tcpc_update_hpd_status(int port, int hpd_lvl, int hpd_irq); +void ps8xxx_tcpc_update_hpd_status(const struct usb_mux *me, + int hpd_lvl, int hpd_irq); #ifdef CONFIG_CMD_I2C_STRESS_TEST_TCPC extern struct i2c_stress_test_dev ps8xxx_i2c_stress_test_dev; diff --git a/driver/tcpm/tcpci.c b/driver/tcpm/tcpci.c index 97768e6f1a..f8de27f20b 100644 --- a/driver/tcpm/tcpci.c +++ b/driver/tcpm/tcpci.c @@ -1099,19 +1099,19 @@ int tcpci_tcpm_init(int port) * via mux init because tcpc_init won't run for the device. This is borrowed * from tcpc_init. */ -int tcpci_tcpm_mux_init(int port) +int tcpci_tcpm_mux_init(const struct usb_mux *me) { int error; int power_status; int tries = TCPM_INIT_TRIES; /* If this MUX is also the TCPC, then skip init */ - if (!(usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC)) + if (!(me->flags & USB_MUX_FLAG_NOT_TCPC)) return EC_SUCCESS; /* Wait for the device to exit low power state */ while (1) { - error = mux_read(port, TCPC_REG_POWER_STATUS, &power_status); + error = mux_read(me, TCPC_REG_POWER_STATUS, &power_status); /* * If read succeeds and the uninitialized bit is clear, then * initialization is complete. @@ -1124,28 +1124,28 @@ int tcpci_tcpm_mux_init(int port) } /* Turn off all alerts and acknowledge any pending IRQ */ - error = mux_write16(port, TCPC_REG_ALERT_MASK, 0); - error |= mux_write16(port, TCPC_REG_ALERT, 0xffff); + error = mux_write16(me, TCPC_REG_ALERT_MASK, 0); + error |= mux_write16(me, TCPC_REG_ALERT, 0xffff); return error ? EC_ERROR_UNKNOWN : EC_SUCCESS; } -int tcpci_tcpm_mux_enter_low_power(int port) +int tcpci_tcpm_mux_enter_low_power(const struct usb_mux *me) { /* If this MUX is also the TCPC, then skip low power */ - if (!(usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC)) + if (!(me->flags & USB_MUX_FLAG_NOT_TCPC)) return EC_SUCCESS; - return mux_write(port, TCPC_REG_COMMAND, TCPC_REG_COMMAND_I2CIDLE); + return mux_write(me, TCPC_REG_COMMAND, TCPC_REG_COMMAND_I2CIDLE); } -int tcpci_tcpm_mux_set(int port, mux_state_t mux_state) +int tcpci_tcpm_mux_set(const struct usb_mux *me, mux_state_t mux_state) { - int reg = 0; int rv; + int reg = 0; /* Parameter is port only */ - rv = mux_read(port, TCPC_REG_CONFIG_STD_OUTPUT, ®); + rv = mux_read(me, TCPC_REG_CONFIG_STD_OUTPUT, ®); if (rv != EC_SUCCESS) return rv; @@ -1159,20 +1159,19 @@ int tcpci_tcpm_mux_set(int port, mux_state_t mux_state) reg |= TCPC_REG_CONFIG_STD_OUTPUT_CONNECTOR_FLIPPED; /* Parameter is port only */ - return mux_write(port, TCPC_REG_CONFIG_STD_OUTPUT, reg); + return mux_write(me, TCPC_REG_CONFIG_STD_OUTPUT, reg); } /* Reads control register and updates mux_state accordingly */ -int tcpci_tcpm_mux_get(int port, mux_state_t *mux_state) +int tcpci_tcpm_mux_get(const struct usb_mux *me, mux_state_t *mux_state) { - int reg = 0; int rv; + int reg = 0; *mux_state = 0; /* Parameter is port only */ - rv = mux_read(port, TCPC_REG_CONFIG_STD_OUTPUT, ®); - + rv = mux_read(me, TCPC_REG_CONFIG_STD_OUTPUT, ®); if (rv != EC_SUCCESS) return rv; diff --git a/driver/tcpm/tcpci.h b/driver/tcpm/tcpci.h index 40b25f4fba..a4bc8f6b39 100644 --- a/driver/tcpm/tcpci.h +++ b/driver/tcpm/tcpci.h @@ -231,10 +231,10 @@ void tcpci_tcpc_discharge_vbus(int port, int enable); #endif void tcpci_tcpc_enable_auto_discharge_disconnect(int port, int enable); -int tcpci_tcpm_mux_init(int i2c_addr); -int tcpci_tcpm_mux_set(int i2c_addr, mux_state_t mux_state); -int tcpci_tcpm_mux_get(int i2c_addr, mux_state_t *mux_state); -int tcpci_tcpm_mux_enter_low_power(int port); +int tcpci_tcpm_mux_init(const struct usb_mux *me); +int tcpci_tcpm_mux_set(const struct usb_mux *me, mux_state_t mux_state); +int tcpci_tcpm_mux_get(const struct usb_mux *me, mux_state_t *mux_state); +int tcpci_tcpm_mux_enter_low_power(const struct usb_mux *me); int tcpci_get_chip_info(int port, int live, struct ec_response_pd_chip_info_v1 **chip_info); #ifdef CONFIG_USBC_PPC diff --git a/driver/usb_mux/amd_fp5.c b/driver/usb_mux/amd_fp5.c index 3258552b49..1f61f7c765 100644 --- a/driver/usb_mux/amd_fp5.c +++ b/driver/usb_mux/amd_fp5.c @@ -11,7 +11,7 @@ #include "i2c.h" #include "usb_mux.h" -static inline int amd_fp5_mux_read(int port, uint8_t *val) +static inline int amd_fp5_mux_read(const struct usb_mux *me, uint8_t *val) { uint8_t buf[3] = { 0 }; int rv; @@ -21,23 +21,23 @@ static inline int amd_fp5_mux_read(int port, uint8_t *val) if (rv) return rv; - *val = buf[port + 1]; + *val = buf[me->usb_port + 1]; return EC_SUCCESS; } -static inline int amd_fp5_mux_write(int port, uint8_t val) +static inline int amd_fp5_mux_write(const struct usb_mux *me, uint8_t val) { return i2c_write8(I2C_PORT_USB_MUX, AMD_FP5_MUX_I2C_ADDR_FLAGS, - port, val); + me->usb_port, val); } -static int amd_fp5_init(int port) +static int amd_fp5_init(const struct usb_mux *me) { return EC_SUCCESS; } -static int amd_fp5_set_mux(int port, mux_state_t mux_state) +static int amd_fp5_set_mux(const struct usb_mux *me, mux_state_t mux_state) { uint8_t val = 0; @@ -63,10 +63,10 @@ static int amd_fp5_set_mux(int port, mux_state_t mux_state) val = (mux_state & USB_PD_MUX_POLARITY_INVERTED) ? AMD_FP5_MUX_DP_INVERTED : AMD_FP5_MUX_DP; - return amd_fp5_mux_write(port, val); + return amd_fp5_mux_write(me, val); } -static int amd_fp5_get_mux(int port, mux_state_t *mux_state) +static int amd_fp5_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { uint8_t val = AMD_FP5_MUX_SAFE; @@ -78,12 +78,11 @@ static int amd_fp5_get_mux(int port, mux_state_t *mux_state) if (!chipset_in_state(CHIPSET_STATE_HARD_OFF)) { int rv; - rv = amd_fp5_mux_read(port, &val); + rv = amd_fp5_mux_read(me, &val); if (rv) return rv; } - switch (val) { case AMD_FP5_MUX_USB: *mux_state = USB_PD_MUX_USB_ENABLED; @@ -115,19 +114,8 @@ static int amd_fp5_get_mux(int port, mux_state_t *mux_state) return EC_SUCCESS; } -/* - * The FP5 MUX can look like a retimer or a MUX. So create both tables - * and use them as needed, until retimers become a type of MUX and - * then we will only need one of these tables. - * - * TODO(b:147593660) Cleanup of retimers as muxes in a more - * generalized mechanism - */ -const struct usb_retimer_driver amd_fp5_usb_retimer = { - .set = amd_fp5_set_mux, -}; const struct usb_mux_driver amd_fp5_usb_mux_driver = { - .init = amd_fp5_init, - .set = amd_fp5_set_mux, - .get = amd_fp5_get_mux, + .init = &amd_fp5_init, + .set = &amd_fp5_set_mux, + .get = &amd_fp5_get_mux, }; diff --git a/driver/usb_mux/amd_fp5.h b/driver/usb_mux/amd_fp5.h index ac1a7ce27e..7534ea0d8a 100644 --- a/driver/usb_mux/amd_fp5.h +++ b/driver/usb_mux/amd_fp5.h @@ -18,7 +18,4 @@ #define AMD_FP5_MUX_DP 0x0C #define AMD_FP5_MUX_DP_INVERTED 0x1C -extern const struct usb_mux_driver amd_fp5_usb_mux_driver; -extern const struct usb_retimer_driver amd_fp5_usb_retimer; - #endif /* __CROS_EC_USB_MUX_AMD_FP5_H */ diff --git a/driver/usb_mux/anx7440.c b/driver/usb_mux/anx7440.c index 1c9633c536..df3a9c2682 100644 --- a/driver/usb_mux/anx7440.c +++ b/driver/usb_mux/anx7440.c @@ -16,14 +16,16 @@ #define CPRINTS(format, args...) cprints(CC_USBCHARGE, format, ## args) #define CPRINTF(format, args...) cprintf(CC_USBCHARGE, format, ## args) -static inline int anx7440_read(int port, uint8_t reg, int *val) +static inline int anx7440_read(const struct usb_mux *me, + uint8_t reg, int *val) { - return i2c_read8(I2C_PORT_USB_MUX, MUX_ADDR(port), reg, val); + return i2c_read8(me->i2c_port, me->i2c_addr_flags, reg, val); } -static inline int anx7440_write(int port, uint8_t reg, uint8_t val) +static inline int anx7440_write(const struct usb_mux *me, + uint8_t reg, uint8_t val) { - return i2c_write8(I2C_PORT_USB_MUX, MUX_ADDR(port), reg, val); + return i2c_write8(me->i2c_port, me->i2c_addr_flags, reg, val); } struct anx7440_id_t { @@ -39,7 +41,7 @@ static const struct anx7440_id_t anx7440_device_ids[] = { { ANX7440_DEVICE_VERSION, ANX7440_REG_DEVICE_VERSION }, }; -static int anx7440_init(int port) +static int anx7440_init(const struct usb_mux *me) { int i; int val; @@ -47,7 +49,7 @@ static int anx7440_init(int port) /* Verify device id / version registers */ for (i = 0; i < ARRAY_SIZE(anx7440_device_ids); i++) { - res = anx7440_read(port, anx7440_device_ids[i].reg, &val); + res = anx7440_read(me, anx7440_device_ids[i].reg, &val); if (res) return res; @@ -59,11 +61,11 @@ static int anx7440_init(int port) } /* Writes control register to set switch mode */ -static int anx7440_set_mux(int port, mux_state_t mux_state) +static int anx7440_set_mux(const struct usb_mux *me, mux_state_t mux_state) { int reg, res; - res = anx7440_read(port, ANX7440_REG_CHIP_CTRL, ®); + res = anx7440_read(me, ANX7440_REG_CHIP_CTRL, ®); if (res) return res; @@ -75,16 +77,16 @@ static int anx7440_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) reg |= ANX7440_CHIP_CTRL_SW_FLIP; - return anx7440_write(port, ANX7440_REG_CHIP_CTRL, reg); + return anx7440_write(me, ANX7440_REG_CHIP_CTRL, reg); } /* Reads control register and updates mux_state accordingly */ -static int anx7440_get_mux(int port, mux_state_t *mux_state) +static int anx7440_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { int reg, res; *mux_state = 0; - res = anx7440_read(port, ANX7440_REG_CHIP_CTRL, ®); + res = anx7440_read(me, ANX7440_REG_CHIP_CTRL, ®); if (res) return res; diff --git a/driver/usb_mux/it5205.c b/driver/usb_mux/it5205.c index e7911b80e3..95416547cd 100644 --- a/driver/usb_mux/it5205.c +++ b/driver/usb_mux/it5205.c @@ -14,14 +14,14 @@ #define MUX_STATE_DP_USB_MASK (USB_PD_MUX_USB_ENABLED | USB_PD_MUX_DP_ENABLED) -static int it5205_read(int port, uint8_t reg, int *val) +static int it5205_read(const struct usb_mux *me, uint8_t reg, int *val) { - return i2c_read8(I2C_PORT_USB_MUX, MUX_ADDR(port), reg, val); + return i2c_read8(me->i2c_port, me->i2c_addr_flags, reg, val); } -static int it5205_write(int port, uint8_t reg, uint8_t val) +static int it5205_write(const struct usb_mux *me, uint8_t reg, uint8_t val) { - return i2c_write8(I2C_PORT_USB_MUX, MUX_ADDR(port), reg, val); + return i2c_write8(me->i2c_port, me->i2c_addr_flags, reg, val); } struct mux_chip_id_t { @@ -36,17 +36,17 @@ static const struct mux_chip_id_t mux_chip_id_verify[] = { { '5', IT5205_REG_CHIP_ID0}, }; -static int it5205_init(int port) +static int it5205_init(const struct usb_mux *me) { int i, val, ret; /* bit[0]: mux power on, bit[7-1]: reserved. */ - ret = it5205_write(port, IT5205_REG_MUXPDR, 0); + ret = it5205_write(me, IT5205_REG_MUXPDR, 0); if (ret) return ret; /* Verify chip ID registers. */ for (i = 0; i < ARRAY_SIZE(mux_chip_id_verify); i++) { - ret = it5205_read(port, mux_chip_id_verify[i].reg, &val); + ret = it5205_read(me, mux_chip_id_verify[i].reg, &val); if (ret) return ret; @@ -58,7 +58,7 @@ static int it5205_init(int port) } /* Writes control register to set switch mode */ -static int it5205_set_mux(int port, mux_state_t mux_state) +static int it5205_set_mux(const struct usb_mux *me, mux_state_t mux_state) { uint8_t reg; @@ -80,15 +80,15 @@ static int it5205_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) reg |= IT5205_POLARITY_INVERTED; - return it5205_write(port, IT5205_REG_MUXCR, reg); + return it5205_write(me, IT5205_REG_MUXCR, reg); } /* Reads control register and updates mux_state accordingly */ -static int it5205_get_mux(int port, mux_state_t *mux_state) +static int it5205_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { int reg, ret; - ret = it5205_read(port, IT5205_REG_MUXCR, ®); + ret = it5205_read(me, IT5205_REG_MUXCR, ®); if (ret) return ret; @@ -113,18 +113,18 @@ static int it5205_get_mux(int port, mux_state_t *mux_state) return EC_SUCCESS; } -static int it5205_enter_low_power_mode(int port) +static int it5205_enter_low_power_mode(const struct usb_mux *me) { int rv; /* Turn off all switches */ - rv = it5205_write(port, IT5205_REG_MUXCR, 0); + rv = it5205_write(me, IT5205_REG_MUXCR, 0); if (rv) return rv; /* Power down mux */ - return it5205_write(port, IT5205_REG_MUXPDR, IT5205_MUX_POWER_DOWN); + return it5205_write(me, IT5205_REG_MUXPDR, IT5205_MUX_POWER_DOWN); } const struct usb_mux_driver it5205_usb_mux_driver = { diff --git a/driver/usb_mux/pi3usb3x532.c b/driver/usb_mux/pi3usb3x532.c index bf6d1f5a01..c3d22b8f61 100644 --- a/driver/usb_mux/pi3usb3x532.c +++ b/driver/usb_mux/pi3usb3x532.c @@ -11,7 +11,8 @@ #include "usb_mux.h" #include "util.h" -static int pi3usb3x532_read(int port, uint8_t reg, uint8_t *val) +static int pi3usb3x532_read(const struct usb_mux *me, + uint8_t reg, uint8_t *val) { int read, res; @@ -20,7 +21,7 @@ static int pi3usb3x532_read(int port, uint8_t reg, uint8_t *val) * Second byte read will be vendor ID. * Third byte read will be selection control. */ - res = i2c_read16(MUX_PORT(port), MUX_ADDR(port), 0, &read); + res = i2c_read16(me->i2c_port, me->i2c_addr_flags, 0, &read); if (res) return res; @@ -32,32 +33,33 @@ static int pi3usb3x532_read(int port, uint8_t reg, uint8_t *val) return EC_SUCCESS; } -static int pi3usb3x532_write(int port, uint8_t reg, uint8_t val) +static int pi3usb3x532_write(const struct usb_mux *me, + uint8_t reg, uint8_t val) { if (reg != PI3USB3X532_REG_CONTROL) return EC_ERROR_UNKNOWN; - return i2c_write8(MUX_PORT(port), MUX_ADDR(port), 0, val); + return i2c_write8(me->i2c_port, me->i2c_addr_flags, 0, val); } -static int pi3usb3x532_reset(int port) +static int pi3usb3x532_reset(const struct usb_mux *me) { return pi3usb3x532_write( - port, + me, PI3USB3X532_REG_CONTROL, (PI3USB3X532_MODE_POWERDOWN & PI3USB3X532_CTRL_MASK) | PI3USB3X532_CTRL_RSVD); } -static int pi3usb3x532_init(int port) +static int pi3usb3x532_init(const struct usb_mux *me) { uint8_t val; int res; - res = pi3usb3x532_reset(port); + res = pi3usb3x532_reset(me); if (res) return res; - res = pi3usb3x532_read(port, PI3USB3X532_REG_VENDOR, &val); + res = pi3usb3x532_read(me, PI3USB3X532_REG_VENDOR, &val); if (res) return res; if (val != PI3USB3X532_VENDOR_ID) @@ -67,7 +69,8 @@ static int pi3usb3x532_init(int port) } /* Writes control register to set switch mode */ -static int pi3usb3x532_set_mux(int port, mux_state_t mux_state) +static int pi3usb3x532_set_mux(const struct usb_mux *me, + mux_state_t mux_state) { uint8_t reg = 0; @@ -78,18 +81,19 @@ static int pi3usb3x532_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) reg |= PI3USB3X532_BIT_SWAP; - return pi3usb3x532_write(port, PI3USB3X532_REG_CONTROL, + return pi3usb3x532_write(me, PI3USB3X532_REG_CONTROL, reg | PI3USB3X532_CTRL_RSVD); } /* Reads control register and updates mux_state accordingly */ -static int pi3usb3x532_get_mux(int port, mux_state_t *mux_state) +static int pi3usb3x532_get_mux(const struct usb_mux *me, + mux_state_t *mux_state) { uint8_t reg = 0; uint8_t res; *mux_state = 0; - res = pi3usb3x532_read(port, PI3USB3X532_REG_CONTROL, ®); + res = pi3usb3x532_read(me, PI3USB3X532_REG_CONTROL, ®); if (res) return res; diff --git a/driver/usb_mux/ps874x.c b/driver/usb_mux/ps874x.c index 08f526d28a..fedb06b27c 100644 --- a/driver/usb_mux/ps874x.c +++ b/driver/usb_mux/ps874x.c @@ -11,32 +11,34 @@ #include "usb_mux.h" #include "util.h" -static inline int ps874x_read(int port, uint8_t reg, int *val) +static inline int ps874x_read(const struct usb_mux *me, + uint8_t reg, int *val) { - return i2c_read8(I2C_PORT_USB_MUX, MUX_ADDR(port), + return i2c_read8(me->i2c_port, me->i2c_addr_flags, reg, val); } -static inline int ps874x_write(int port, uint8_t reg, uint8_t val) +static inline int ps874x_write(const struct usb_mux *me, + uint8_t reg, uint8_t val) { - return i2c_write8(I2C_PORT_USB_MUX, MUX_ADDR(port), + return i2c_write8(me->i2c_port, me->i2c_addr_flags, reg, val); } -static int ps874x_init(int port) +static int ps874x_init(const struct usb_mux *me) { int val; int res; /* Reset chip back to power-on state */ - res = ps874x_write(port, PS874X_REG_MODE, PS874X_MODE_POWER_DOWN); + res = ps874x_write(me, PS874X_REG_MODE, PS874X_MODE_POWER_DOWN); if (res) return res; /* * Verify revision / chip ID registers. */ - res = ps874x_read(port, PS874X_REG_REVISION_ID1, &val); + res = ps874x_read(me, PS874X_REG_REVISION_ID1, &val); if (res) return res; @@ -52,19 +54,19 @@ static int ps874x_init(int port) return EC_ERROR_UNKNOWN; #endif - res = ps874x_read(port, PS874X_REG_REVISION_ID2, &val); + res = ps874x_read(me, PS874X_REG_REVISION_ID2, &val); if (res) return res; if (val != PS874X_REVISION_ID2) return EC_ERROR_UNKNOWN; - res = ps874x_read(port, PS874X_REG_CHIP_ID1, &val); + res = ps874x_read(me, PS874X_REG_CHIP_ID1, &val); if (res) return res; if (val != PS874X_CHIP_ID1) return EC_ERROR_UNKNOWN; - res = ps874x_read(port, PS874X_REG_CHIP_ID2, &val); + res = ps874x_read(me, PS874X_REG_CHIP_ID2, &val); if (res) return res; if (val != PS874X_CHIP_ID2) @@ -74,7 +76,7 @@ static int ps874x_init(int port) } /* Writes control register to set switch mode */ -static int ps874x_set_mux(int port, mux_state_t mux_state) +static int ps874x_set_mux(const struct usb_mux *me, mux_state_t mux_state) { uint8_t reg = 0; @@ -85,16 +87,16 @@ static int ps874x_set_mux(int port, mux_state_t mux_state) if (mux_state & USB_PD_MUX_POLARITY_INVERTED) reg |= PS874X_MODE_POLARITY_INVERTED; - return ps874x_write(port, PS874X_REG_MODE, reg); + return ps874x_write(me, PS874X_REG_MODE, reg); } /* Reads control register and updates mux_state accordingly */ -static int ps874x_get_mux(int port, mux_state_t *mux_state) +static int ps874x_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { int reg; int res; - res = ps874x_read(port, PS874X_REG_STATUS, ®); + res = ps874x_read(me, PS874X_REG_STATUS, ®); if (res) return res; @@ -113,9 +115,10 @@ static int ps874x_get_mux(int port, mux_state_t *mux_state) int ps874x_tune_usb_eq(int port, uint8_t tx, uint8_t rx) { int ret; + const struct usb_mux *me = &usb_muxes[port]; - ret = ps874x_write(port, PS874X_REG_USB_EQ_TX, tx); - ret |= ps874x_write(port, PS874X_REG_USB_EQ_RX, rx); + ret = ps874x_write(me, PS874X_REG_USB_EQ_TX, tx); + ret |= ps874x_write(me, PS874X_REG_USB_EQ_RX, rx); return ret; } diff --git a/driver/usb_mux/usb_mux.c b/driver/usb_mux/usb_mux.c index 5bf057ed91..3d629a6ab0 100644 --- a/driver/usb_mux/usb_mux.c +++ b/driver/usb_mux/usb_mux.c @@ -32,100 +32,107 @@ enum mux_config_type { USB_MUX_GET_MODE, }; -/* Configure the retimer */ -static int configure_retimer(int port, enum mux_config_type config, - mux_state_t mux_state) +/* Configure the MUX */ +static int configure_mux(int port, + enum mux_config_type config, + mux_state_t *mux_state) { - int res = 0; + int rv = EC_SUCCESS; + const struct usb_mux *mux_ptr; + + if (config == USB_MUX_SET_MODE || + config == USB_MUX_GET_MODE) { + if (mux_state == NULL) + return EC_ERROR_INVAL; - if (IS_ENABLED(CONFIG_USBC_MUX_RETIMER)) { - const struct usb_retimer *retimer = &usb_retimers[port]; + if (config == USB_MUX_GET_MODE) + *mux_state = USB_PD_MUX_NONE; + } - if (!retimer->driver) - return 0; + /* + * a MUX for a particular port can be a linked list chain of + * MUXes. So when we change one, we traverse the whole list + * to make sure they are all updated appropriately. + */ + for (mux_ptr = &usb_muxes[port]; + rv == EC_SUCCESS && mux_ptr != NULL; + mux_ptr = mux_ptr->next_mux) { + mux_state_t lcl_state; + const struct usb_mux_driver *drv = mux_ptr->driver; switch (config) { case USB_MUX_INIT: - if (retimer->driver->init) - res = retimer->driver->init(port); + if (drv && drv->init) { + rv = drv->init(mux_ptr); + if (rv) + break; + } + + /* Apply board specific initialization */ + if (mux_ptr->board_init) + rv = mux_ptr->board_init(mux_ptr); + break; + case USB_MUX_LOW_POWER: - if (retimer->driver->enter_low_power_mode) - res = retimer->driver->enter_low_power_mode( - port); + if (drv && drv->enter_low_power_mode) + rv = drv->enter_low_power_mode(mux_ptr); + break; + case USB_MUX_SET_MODE: - if (retimer->driver->set) - res = retimer->driver->set(port, mux_state); - break; - default: - break; - } - } + lcl_state = *mux_state; - return res; -} + if (mux_ptr->flags & USB_MUX_FLAG_SET_WITHOUT_FLIP) + lcl_state &= ~USB_PD_MUX_POLARITY_INVERTED; -/* Configure the MUX */ -static int configure_mux(int port, enum mux_config_type config, - mux_state_t *mux_state) -{ - const struct usb_mux *mux = &usb_muxes[port]; - int res; + if (drv && drv->set) { + rv = drv->set(mux_ptr, lcl_state); + if (rv) + break; + } - switch (config) { - case USB_MUX_INIT: - res = mux->driver->init(port); - if (res) - break; + /* Apply board specific setting */ + if (mux_ptr->board_set) + rv = mux_ptr->board_set(mux_ptr, lcl_state); - res = configure_retimer(port, config, USB_PD_MUX_NONE); - if (res) break; - /* Apply board specific initialization */ - if (mux->board_init) - res = mux->board_init(port); - - break; - case USB_MUX_LOW_POWER: - if (mux->driver->enter_low_power_mode) { - res = mux->driver->enter_low_power_mode(port); - if (res) - break; - } - res = configure_retimer(port, config, USB_PD_MUX_NONE); - break; - case USB_MUX_SET_MODE: - res = mux->driver->set(port, *mux_state); - if (res) + case USB_MUX_GET_MODE: + /* + * This is doing a GET_CC on all of the MUXes in the + * chain and ORing them together. This will make sure + * if one of the MUX values has FLIP turned off that + * we will end up with the correct value in the end. + */ + if (drv && drv->get) { + rv = drv->get(mux_ptr, &lcl_state); + if (rv) + break; + *mux_state |= lcl_state; + } break; - res = configure_retimer(port, config, *mux_state); - break; - case USB_MUX_GET_MODE: - res = mux->driver->get(port, mux_state); - break; + } } - if (res) - CPRINTS("mux config:%d, port:%d, res:%d", config, port, res); + if (rv) + CPRINTS("mux config:%d, port:%d, rv:%d", + config, port, rv); - return res; + return rv; } static void enter_low_power_mode(int port) { - mux_state_t mux_state = USB_PD_MUX_NONE; - /* - * Set LPM flag regardless of method presence or method failure. We want - * know know that we tried to put the device in low power mode so we can - * re-initialize the device on the next access. + * Set LPM flag regardless of method presence or method failure. We + * want know know that we tried to put the device in low power mode + * so we can re-initialize the device on the next access. */ flags[port] |= USB_MUX_FLAG_IN_LPM; /* Apply any low power customization if present */ - configure_mux(port, USB_MUX_LOW_POWER, &mux_state); + configure_mux(port, USB_MUX_LOW_POWER, NULL); } static inline void exit_low_power_mode(int port) @@ -137,11 +144,9 @@ static inline void exit_low_power_mode(int port) void usb_mux_init(int port) { - mux_state_t mux_state = USB_PD_MUX_NONE; - ASSERT(port >= 0 && port < CONFIG_USB_PD_PORT_MAX_COUNT); - configure_mux(port, USB_MUX_INIT, &mux_state); + configure_mux(port, USB_MUX_INIT, NULL); /* Device is always out of LPM after initialization. */ flags[port] &= ~USB_MUX_FLAG_IN_LPM; @@ -225,16 +230,17 @@ void usb_mux_flip(int port) void usb_mux_hpd_update(int port, int hpd_lvl, int hpd_irq) { - const struct usb_mux *mux = &usb_muxes[port]; mux_state_t mux_state; + const struct usb_mux *mux_ptr = &usb_muxes[port]; - if (mux->hpd_update) - mux->hpd_update(port, hpd_lvl, hpd_irq); + for (; mux_ptr; mux_ptr = mux_ptr->next_mux) + if (mux_ptr->hpd_update) + mux_ptr->hpd_update(mux_ptr, hpd_lvl, hpd_irq); if (!configure_mux(port, USB_MUX_GET_MODE, &mux_state)) { mux_state |= (hpd_lvl ? USB_PD_MUX_HPD_LVL : 0) | - (hpd_irq ? USB_PD_MUX_HPD_IRQ : 0); - configure_retimer(port, USB_MUX_SET_MODE, mux_state); + (hpd_irq ? USB_PD_MUX_HPD_IRQ : 0); + configure_mux(port, USB_MUX_SET_MODE, &mux_state); } } @@ -297,7 +303,7 @@ static enum ec_status hc_usb_pd_mux_info(struct host_cmd_handler_args *args) const struct ec_params_usb_pd_mux_info *p = args->params; struct ec_response_usb_pd_mux_info *r = args->response; int port = p->port; - const struct usb_mux *mux = &usb_muxes[port]; + const struct usb_mux *me = &usb_muxes[port]; mux_state_t mux_state; if (port >= board_get_usb_pd_port_count()) @@ -311,7 +317,7 @@ static enum ec_status hc_usb_pd_mux_info(struct host_cmd_handler_args *args) /* Clear HPD IRQ event since we're about to inform host of it. */ if (IS_ENABLED(CONFIG_USB_MUX_VIRTUAL) && (r->flags & USB_PD_MUX_HPD_IRQ) && - (mux->hpd_update == &virtual_hpd_update)) { + (me->hpd_update == &virtual_hpd_update)) { usb_mux_hpd_update(port, r->flags & USB_PD_MUX_HPD_LVL, 0); } diff --git a/driver/usb_mux/virtual.c b/driver/usb_mux/virtual.c index 6f80157deb..5a2f4a62d3 100644 --- a/driver/usb_mux/virtual.c +++ b/driver/usb_mux/virtual.c @@ -33,7 +33,7 @@ static inline void virtual_mux_update_state(int port, mux_state_t mux_state) } } -static int virtual_init(int port) +static int virtual_init(const struct usb_mux *me) { return EC_SUCCESS; } @@ -42,8 +42,10 @@ static int virtual_init(int port) * Set the state of our 'virtual' mux. The EC does not actually control this * mux, so update the desired state, then notify the host of the update. */ -static int virtual_set_mux(int port, mux_state_t mux_state) +static int virtual_set_mux(const struct usb_mux *me, mux_state_t mux_state) { + int port = me->usb_port; + /* Current USB & DP mux status + existing HPD related mux status */ mux_state_t new_mux_state = (mux_state & ~USB_PD_MUX_HPD_STATE) | (virtual_mux_state[port] & USB_PD_MUX_HPD_STATE); @@ -58,15 +60,19 @@ static int virtual_set_mux(int port, mux_state_t mux_state) * control this mux, and the EC has no way of knowing its actual status, * we return the desired state here. */ -static int virtual_get_mux(int port, mux_state_t *mux_state) +static int virtual_get_mux(const struct usb_mux *me, mux_state_t *mux_state) { + int port = me->usb_port; + *mux_state = virtual_mux_state[port]; return EC_SUCCESS; } -void virtual_hpd_update(int port, int hpd_lvl, int hpd_irq) +void virtual_hpd_update(const struct usb_mux *me, int hpd_lvl, int hpd_irq) { + int port = me->usb_port; + /* Current HPD related mux status + existing USB & DP mux status */ mux_state_t new_mux_state = (hpd_lvl ? USB_PD_MUX_HPD_LVL : 0) | (hpd_irq ? USB_PD_MUX_HPD_IRQ : 0) | diff --git a/include/config.h b/include/config.h index 1e59237b5e..92c38fbc91 100644 --- a/include/config.h +++ b/include/config.h @@ -3974,15 +3974,6 @@ #undef CONFIG_USB_PD_TCPM_DRIVER_IT8XXX2 /* - * Type-C retimer mux configuration tends to be set on a specific - * driver's need basis. After including the board/baseboard.h files - * the drivers will be checked and if one of these are needed it will - * automatically be included. This does not stop a board/basebord.h - * configration from defining these as well. - */ -#undef CONFIG_USBC_MUX_RETIMER - -/* * Type-C retimer drivers to be used. */ #undef CONFIG_USBC_RETIMER_INTEL_BB @@ -4336,6 +4327,9 @@ /******************************************************************************/ /* USB port switch */ +/* Allow run-time completion of the usb mux driver structure */ +#undef CONFIG_USB_MUX_RUNTIME_CONFIG + /* Support the AMD FP5 USB/DP Mux */ #undef CONFIG_USB_MUX_AMD_FP5 @@ -4960,19 +4954,6 @@ /*****************************************************************************/ /* - * Define derived config options for Retimer chips. There are - * for convenience. Any retimer driver that also needs USBC MUX Retimers - * will not have to include it in their own board/baseboard.h file. - */ -#if defined(CONFIG_USBC_RETIMER_INTEL_BB) || \ - defined(CONFIG_USBC_RETIMER_PI3DPX1207) || \ - defined(CONFIG_USBC_RETIMER_PS8802) || \ - defined(CONFIG_USBC_RETIMER_PS8818) -#define CONFIG_USBC_MUX_RETIMER -#endif - -/*****************************************************************************/ -/* * Define CONFIG_LIBCRYPTOC if a board needs to read secret data from the * anti-rollback block. */ diff --git a/include/usb_mux.h b/include/usb_mux.h index 35350222f0..b606656b61 100644 --- a/include/usb_mux.h +++ b/include/usb_mux.h @@ -9,10 +9,15 @@ #define __CROS_EC_USB_MUX_H #include "ec_commands.h" +#include "i2c.h" #include "tcpm.h" #include "usb_charge.h" #include "usb_pd.h" +/* Flags used for usb_mux.flags */ +#define USB_MUX_FLAG_NOT_TCPC BIT(0) /* TCPC/MUX device used only as MUX */ +#define USB_MUX_FLAG_SET_WITHOUT_FLIP BIT(1) /* SET should not flip */ + /* * USB-C mux state * @@ -21,42 +26,36 @@ */ typedef uint8_t mux_state_t; -/* - * Packing and Unpacking defines used with USB_MUX_FLAG_NOT_TCPC - * MUX_PORT takes in a USB-C port number and returns the I2C port number - */ -#define MUX_PORT_AND_ADDR(port, addr) ((port << 8) | (addr & 0xFF)) -#define MUX_PORT(port) (usb_muxes[port].port_addr >> 8) -#define MUX_ADDR(port) (usb_muxes[port].port_addr & 0xFF) - /* Mux driver function pointers */ +struct usb_mux; struct usb_mux_driver { /** - * Initialize USB mux. This is called every time the MUX is access after - * being put in a fully disconnected state (low power mode). + * Initialize USB mux. This is called every time the MUX is + * access after being put in a fully disconnected state (low + * power mode). * - * @param port usb port of mux (not port_addr) + * @param me usb_mux * @return EC_SUCCESS on success, non-zero error code on failure. */ - int (*init)(int port); + int (*init)(const struct usb_mux *me); /** * Set USB mux state. * - * @param port usb port of mux (not port_addr) + * @param me usb_mux * @param mux_state State to set mux to. * @return EC_SUCCESS on success, non-zero error code on failure. */ - int (*set)(int port, mux_state_t mux_state); + int (*set)(const struct usb_mux *me, mux_state_t mux_state); /** * Get current state of USB mux. * - * @param port usb port of mux (not port_addr) + * @param me usb_mux * @param mux_state Gets set to current state of mux. * @return EC_SUCCESS on success, non-zero error code on failure. */ - int (*get)(int port, mux_state_t *mux_state); + int (*get)(const struct usb_mux *me, mux_state_t *mux_state); /** * Optional method that is called after the mux fully disconnects. @@ -65,46 +64,69 @@ struct usb_mux_driver { * where the TCPC is actively used since the PD state machine * will put the chip into lower power mode. * - * @param port usb port of mux (not port_addr) + * @param me usb_mux * @return EC_SUCCESS on success, non-zero error code on failure. */ - int (*enter_low_power_mode)(int port); + int (*enter_low_power_mode)(const struct usb_mux *me); }; -/* Flags used for usb_mux.flags */ -#define USB_MUX_FLAG_NOT_TCPC BIT(0) /* TCPC/MUX device used only as MUX */ - /* Describes a USB mux present in the system */ struct usb_mux { /* - * Used by driver. Muxes that are also the TCPC do not need to specify - * anything for this as they will use the values from tcpc_config_t. If - * this mux is also a TCPC but not used as the TCPC then use the - * MUX_PORT_AND_ADDR to pack the i2c port and i2c address into this - * field and use the USB_MUX_FLAG_NOT_TCPC flag. + * This is index into usb_muxes that points to the start of the + * possible chain of usb_mux entries that this entry is on. */ - const int port_addr; + int usb_port; + + /* + * I2C port and address. This is optional if your MUX is not + * an I2C interface. If this is the case, use usb_port to + * index an exernal array to track your connection parameters, + * if they are needed. One case of this would be a driver + * that will use usb_port as an index into tcpc_config_t to + * gather the necessary information to communicate with the MUX + */ + uint16_t i2c_port; + uint16_t i2c_addr_flags; /* Run-time flags with prefix USB_MUX_FLAG_ */ - const uint32_t flags; + uint32_t flags; /* Mux driver */ const struct usb_mux_driver *driver; + /* Linked list chain of secondary MUXes. NULL terminated */ + const struct usb_mux *next_mux; + /** * Optional method for tuning for USB mux during mux->driver->init(). * - * @param port usb port of mux (not port_addr) + * @param me usb_mux * @return EC_SUCCESS on success, non-zero error code on failure. */ - int (*board_init)(int port); + int (*board_init)(const struct usb_mux *me); /* + * USB mux/retimer board specific set mux_state. + * + * @param me usb_mux + * @param mux_state State to set mode to. + * @return EC_SUCCESS on success, non-zero error code on failure. + */ + int (*board_set)(const struct usb_mux *me, mux_state_t mux_state); + + /* + * TODO: Consider moving this to usb_mux_driver struct + * * USB Type-C DP alt mode support. Notify Type-C controller * there is DP dongle hot-plug. - * TODO: Move this function to usb_mux_driver struct. + * + * @param me usb_mux + * @param hpd_lvl Level + * @param hpd_irq IRQ */ - void (*hpd_update)(int port, int hpd_lvl, int hpd_irq); + void (*hpd_update)(const struct usb_mux *me, + int hpd_lvl, int hpd_irq); }; /* Supported USB mux drivers */ @@ -116,114 +138,47 @@ extern const struct usb_mux_driver ps874x_usb_mux_driver; extern const struct usb_mux_driver tcpm_usb_mux_driver; extern const struct usb_mux_driver virtual_usb_mux_driver; -/* Supported hpd_update functions */ -void virtual_hpd_update(int port, int hpd_lvl, int hpd_irq); - /* USB muxes present in system, ordered by PD port #, defined at board-level */ +#ifdef CONFIG_USB_MUX_RUNTIME_CONFIG extern struct usb_mux usb_muxes[]; +#else +extern const struct usb_mux usb_muxes[]; +#endif -/* - * Retimer driver function pointers - * - * The retimer driver is driven by calls to the MUX API. These are not - * called directly anywhere else in the code. - */ -struct usb_retimer_driver { - /** - * Initialize USB retimer. This is called every time the MUX is - * access after being put in a fully disconnected state (low power - * mode). - * - * @param port usb port of redriver (not port_addr) - * @return EC_SUCCESS on success, non-zero error code on failure. - */ - int (*init)(int port); - - /** - * Put USB retimer in low power mode. This is called when the MUX - * is put into low power mode). - * - * @param port usb port of redriver (not port_addr) - * @return EC_SUCCESS on success, non-zero error code on failure. - */ - int (*enter_low_power_mode)(int port); - - /** - * Set USB retimer state. - * - * @param port usb port of retimer (not port_addr) - * @param mux_state State to set retimer mode to. - * @return EC_SUCCESS on success, non-zero error code on failure. - */ - int (*set)(int port, mux_state_t mux_state); -}; - -/* Describes a USB retimer present in the system */ -struct usb_retimer { - /* - * All of the fields are provided on an as needed basis. - * If your retimer does not use the provided machanism then - * values would not be set (defaulted to 0/NULL). This - * defaulting includes the driver field, which would indicate - * no retimer driver is to be called. - */ - - /* I2C port and slave address */ - const int i2c_port; - uint16_t i2c_addr_flags; - - /* Driver interfaces for this retimer */ - const struct usb_retimer_driver *driver; - - /* - * USB retimer board specific tune on set mux_state. - * - * @param port usb port of retimer (not port_addr) - * @param mux_state State to set retimer mode to. - * @return EC_SUCCESS on success, non-zero error code on failure. - */ - int (*tune)(int port, mux_state_t mux_state); -}; - -/* - * USB retimers present in system, ordered by PD port #, defined at - * board-level - */ -extern struct usb_retimer usb_retimers[]; +/* Supported hpd_update functions */ +void virtual_hpd_update(const struct usb_mux *me, int hpd_lvl, int hpd_irq); /* * Helper methods that either use tcpc communication or direct i2c * communication depending on how the TCPC/MUX device is configured. */ #ifdef CONFIG_USB_PD_TCPM_MUX -static inline int mux_write(int port, int reg, int val) +static inline int mux_write(const struct usb_mux *me, int reg, int val) { - return usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC - ? i2c_write8(MUX_PORT(port), MUX_ADDR(port), reg, val) - : tcpc_write(port, reg, val); + return me->flags & USB_MUX_FLAG_NOT_TCPC + ? i2c_write8(me->i2c_port, me->i2c_addr_flags, reg, val) + : tcpc_write(me->usb_port, reg, val); } -static inline int mux_read(int port, int reg, int *val) +static inline int mux_read(const struct usb_mux *me, int reg, int *val) { - return usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC - ? i2c_read8(MUX_PORT(port), MUX_ADDR(port), reg, val) - : tcpc_read(port, reg, val); + return me->flags & USB_MUX_FLAG_NOT_TCPC + ? i2c_read8(me->i2c_port, me->i2c_addr_flags, reg, val) + : tcpc_read(me->usb_port, reg, val); } -static inline int mux_write16(int port, int reg, int val) +static inline int mux_write16(const struct usb_mux *me, int reg, int val) { - return usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC - ? i2c_write16(MUX_PORT(port), MUX_ADDR(port), - reg, val) - : tcpc_write16(port, reg, val); + return me->flags & USB_MUX_FLAG_NOT_TCPC + ? i2c_write16(me->i2c_port, me->i2c_addr_flags, reg, val) + : tcpc_write16(me->usb_port, reg, val); } -static inline int mux_read16(int port, int reg, int *val) +static inline int mux_read16(const struct usb_mux *me, int reg, int *val) { - return usb_muxes[port].flags & USB_MUX_FLAG_NOT_TCPC - ? i2c_read16(MUX_PORT(port), MUX_ADDR(port), - reg, val) - : tcpc_read16(port, reg, val); + return me->flags & USB_MUX_FLAG_NOT_TCPC + ? i2c_read16(me->i2c_port, me->i2c_addr_flags, reg, val) + : tcpc_read16(me->usb_port, reg, val); } #endif /* CONFIG_USB_PD_TCPM_MUX */ diff --git a/test/usb_pd_int.c b/test/usb_pd_int.c index b1701c5f96..280c7c192f 100644 --- a/test/usb_pd_int.c +++ b/test/usb_pd_int.c @@ -19,7 +19,7 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { .driver = &mock_usb_mux_driver, } diff --git a/test/usb_typec_drp_acc_trysrc.c b/test/usb_typec_drp_acc_trysrc.c index c7a0790d1e..479e103c38 100644 --- a/test/usb_typec_drp_acc_trysrc.c +++ b/test/usb_typec_drp_acc_trysrc.c @@ -23,7 +23,7 @@ const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_MAX_COUNT] = { }, }; -struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { +const struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_MAX_COUNT] = { { .driver = &mock_usb_mux_driver, } diff --git a/util/ectool.c b/util/ectool.c index 97e44779fe..2426d3ba3b 100644 --- a/util/ectool.c +++ b/util/ectool.c @@ -16,7 +16,6 @@ #include <signal.h> #include <stdbool.h> -#include "anx74xx.h" #include "battery.h" #include "comm-host.h" #include "chipset.h" @@ -31,7 +30,6 @@ #include "lock/gec_lock.h" #include "misc_util.h" #include "panic.h" -#include "ps8xxx.h" #include "usb_pd.h" /* Maximum flash size (16 MB, conservative) */ |