zephyr: test: usb_mux: Split struct usb_mux in tests

Update tests to use new struct usb_mux_chain.

BUG=b:236274003
TEST=zmake build -a
TEST=./twister -T zephyr/test
BRANCH=None

Cq-Depend: chromium:3779618
Signed-off-by: Tomasz Michalec <tm@semihalf.com>
Change-Id: I393fe86a94816a98eaf413244884e6aa082f906a
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/3780421
Reviewed-by: Keith Short <keithshort@chromium.org>
Commit-Queue: Tomasz Michalec <tmichalec@google.com>
Tested-by: Tomasz Michalec <tmichalec@google.com>
Code-Coverage: Zoss <zoss-cl-coverage@prod.google.com>

6 files changed, 132 insertions, 94 deletions

diff --git a/zephyr/test/drivers/common/include/test/drivers/stubs.h b/zephyr/test/drivers/common/include/test/drivers/stubs.h
index 41d0fb9547..98f3fa1d15 100644
--- a/zephyr/test/drivers/common/include/test/drivers/stubs.h
+++ b/zephyr/test/drivers/common/include/test/drivers/stubs.h
@@ -13,6 +13,7 @@ enum usbc_port { USBC_PORT_C0 = 0, USBC_PORT_C1, USBC_PORT_COUNT };
 
 /* Structure used by usb_mux test. It is part of usb_muxes chain. */
 extern struct usb_mux usbc1_virtual_usb_mux;
+extern struct usb_mux usbc0_mux0;
 
 /**
  * @brief Set product ID that should be returned by board_get_ps8xxx_product_id
diff --git a/zephyr/test/drivers/common/src/stubs.c b/zephyr/test/drivers/common/src/stubs.c
index 6d3b56dccb..2683b326a8 100644
--- a/zephyr/test/drivers/common/src/stubs.c
+++ b/zephyr/test/drivers/common/src/stubs.c
@@ -149,10 +149,13 @@ int board_is_sourcing_vbus(int port)
 }
 
 /* TODO(b/239457738): Move to dts */
-struct usb_mux usbc0_virtual_usb_mux = {
-	.usb_port = USBC_PORT_C0,
-	.driver = &virtual_usb_mux_driver,
-	.hpd_update = &virtual_hpd_update,
+struct usb_mux_chain usbc0_virtual_usb_mux_chain = {
+	.mux =
+		&(const struct usb_mux){
+			.usb_port = USBC_PORT_C0,
+			.driver = &virtual_usb_mux_driver,
+			.hpd_update = &virtual_hpd_update,
+		},
 };
 
 struct usb_mux usbc1_virtual_usb_mux = {
@@ -161,22 +164,32 @@ struct usb_mux usbc1_virtual_usb_mux = {
 	.hpd_update = &virtual_hpd_update,
 };
 
-struct usb_mux usb_muxes[] = {
+struct usb_mux_chain usbc1_virtual_usb_mux_chain = {
+	.mux = &usbc1_virtual_usb_mux,
+};
+
+struct usb_mux usbc0_mux0 = {
+	.usb_port = USBC_PORT_C0,
+	.driver = &tcpci_tcpm_usb_mux_driver,
+	.i2c_port = I2C_PORT_USB_C0,
+	.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(tcpci_emul)),
+};
+
+struct usb_mux_chain usb_muxes[] = {
 	[USBC_PORT_C0] = {
-		.usb_port = USBC_PORT_C0,
-		.driver = &tcpci_tcpm_usb_mux_driver,
-		.next_mux = &usbc0_virtual_usb_mux,
-		.i2c_port = I2C_PORT_USB_C0,
-		.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(tcpci_emul)),
+		.mux = &usbc0_mux0,
+		.next = &usbc0_virtual_usb_mux_chain,
 	},
 	[USBC_PORT_C1] = {
-		.usb_port = USBC_PORT_C1,
-		.driver = &bb_usb_retimer,
-		.hpd_update = bb_retimer_hpd_update,
-		.next_mux = &usbc1_virtual_usb_mux,
-		.i2c_port = I2C_PORT_USB_C1,
-		.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(
-					usb_c1_bb_retimer_emul)),
+		.mux = &(const struct usb_mux){
+			.usb_port = USBC_PORT_C1,
+			.driver = &bb_usb_retimer,
+			.hpd_update = bb_retimer_hpd_update,
+			.i2c_port = I2C_PORT_USB_C1,
+			.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(
+						usb_c1_bb_retimer_emul)),
+		},
+		.next = &usbc1_virtual_usb_mux_chain,
 	},
 };
 BUILD_ASSERT(ARRAY_SIZE(usb_muxes) == USBC_PORT_COUNT);
diff --git a/zephyr/test/drivers/default/src/bb_retimer.c b/zephyr/test/drivers/default/src/bb_retimer.c
index b6a3f6774e..74d8fa86a2 100644
--- a/zephyr/test/drivers/default/src/bb_retimer.c
+++ b/zephyr/test/drivers/default/src/bb_retimer.c
@@ -55,7 +55,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 
 	/* Test fail on reset register write */
 	zassert_equal(EC_ERROR_INVAL,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_NONE, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -71,7 +71,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 	/* Test none mode */
 	bb_emul_set_reg(emul, BB_RETIMER_REG_CONNECTION_STATE, 0x12144678);
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_NONE, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -84,7 +84,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 	/* Test USB3 gen1 mode */
 	prl_set_rev(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME, PD_REV10);
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_USB_ENABLED, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -101,7 +101,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 	disc->identity.product_t1.p_rev30.ss = USB_R30_SS_U32_U40_GEN2;
 	prl_set_rev(USBC_PORT_C1, TCPCI_MSG_SOP_PRIME, PD_REV30);
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_USB_ENABLED, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -114,7 +114,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 
 	/* Test TBT mode */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -128,7 +128,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 
 	/* Test USB4 mode */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_USB4_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -141,7 +141,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 
 	/* Test USB4 mode with polarity inverted */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_USB4_ENABLED |
 						 USB_PD_MUX_POLARITY_INVERTED,
 					 &ack_required),
@@ -156,7 +156,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 
 	/* Test DP mode */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_DP_ENABLED, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -167,7 +167,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 		      exp_conn, conn);
 
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_DP_ENABLED |
 						 USB_PD_MUX_HPD_IRQ,
 					 &ack_required),
@@ -180,7 +180,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_state)
 		      exp_conn, conn);
 
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_DP_ENABLED |
 						 USB_PD_MUX_HPD_LVL,
 					 &ack_required),
@@ -211,7 +211,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	/* Test PD mux none mode with DFP should clear all bits in state */
 	bb_emul_set_reg(emul, BB_RETIMER_REG_CONNECTION_STATE, 0x12144678);
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_NONE, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -258,7 +258,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 
 	/* Test USB mode with active cable */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_USB_ENABLED, &ack_required),
 		      NULL);
 	zassert_false(ack_required, "ACK is never required for BB retimer");
@@ -271,7 +271,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 
 	/* Test TBT mode with active cable */
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -286,7 +286,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.retimer_type = USB_RETIMER;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -303,7 +303,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.tbt_cable = TBT_CABLE_OPTICAL;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -320,7 +320,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.lsrx_comm = UNIDIR_LSRX_COMM;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -337,7 +337,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.tbt_cable_speed = TBT_SS_U31_GEN1;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -353,7 +353,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.tbt_cable_speed = TBT_SS_U32_GEN1_GEN2;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -369,7 +369,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.tbt_cable_speed = TBT_SS_TBT_GEN3;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -387,7 +387,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	cable_resp.tbt_rounded = TBT_GEN3_GEN4_ROUNDED_NON_ROUNDED;
 	disc->svids[0].mode_vdo[0] = cable_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -405,7 +405,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	device_resp.tbt_adapter = TBT_ADAPTER_TBT2_LEGACY;
 	dev_disc->svids[0].mode_vdo[0] = device_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -422,7 +422,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	device_resp.intel_spec_b0 = VENDOR_SPECIFIC_SUPPORTED;
 	dev_disc->svids[0].mode_vdo[0] = device_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -442,7 +442,7 @@ ZTEST_USER(bb_retimer_no_tasks, test_bb_set_dfp_state)
 	device_resp.vendor_spec_b1 = VENDOR_SPECIFIC_SUPPORTED;
 	dev_disc->svids[0].mode_vdo[0] = device_resp.raw_value;
 	zassert_equal(EC_SUCCESS,
-		      bb_usb_retimer.set(&usb_muxes[USBC_PORT_C1],
+		      bb_usb_retimer.set(usb_muxes[USBC_PORT_C1].mux,
 					 USB_PD_MUX_TBT_COMPAT_ENABLED,
 					 &ack_required),
 		      NULL);
@@ -474,7 +474,7 @@ ZTEST_USER(bb_retimer, test_bb_init)
 					  BB_RETIMER_REG_VENDOR_ID);
 	/* Test fail on vendor ID read */
 	zassert_equal(EC_ERROR_INVAL,
-		      bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]), NULL);
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	/* Enable pins should be set always after init, when AP is on */
 	zassert_equal(1, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
@@ -488,7 +488,7 @@ ZTEST_USER(bb_retimer, test_bb_init)
 	bb_emul_set_reg(emul, BB_RETIMER_REG_VENDOR_ID, 0x12144678);
 	/* Test fail on wrong vendor ID */
 	zassert_equal(EC_ERROR_INVAL,
-		      bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]), NULL);
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	zassert_equal(1, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
 	zassert_equal(
@@ -501,7 +501,7 @@ ZTEST_USER(bb_retimer, test_bb_init)
 	bb_emul_set_reg(emul, BB_RETIMER_REG_VENDOR_ID, BB_RETIMER_VENDOR_ID_1);
 	/* Test fail on device ID read */
 	zassert_equal(EC_ERROR_INVAL,
-		      bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]), NULL);
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	zassert_equal(1, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
 	zassert_equal(
@@ -514,7 +514,7 @@ ZTEST_USER(bb_retimer, test_bb_init)
 	bb_emul_set_reg(emul, BB_RETIMER_REG_DEVICE_ID, 0x12144678);
 	/* Test fail on wrong device ID */
 	zassert_equal(EC_ERROR_INVAL,
-		      bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]), NULL);
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	zassert_equal(1, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
 	zassert_equal(
@@ -523,8 +523,8 @@ ZTEST_USER(bb_retimer, test_bb_init)
 
 	/* Test successful init */
 	bb_emul_set_reg(emul, BB_RETIMER_REG_DEVICE_ID, BB_RETIMER_DEVICE_ID);
-	zassert_equal(EC_SUCCESS, bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]),
-		      NULL);
+	zassert_equal(EC_SUCCESS,
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	zassert_equal(1, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
 	zassert_equal(
@@ -536,7 +536,7 @@ ZTEST_USER(bb_retimer, test_bb_init)
 
 	/* With AP off, init should fail and pins should be unset */
 	zassert_equal(EC_ERROR_NOT_POWERED,
-		      bb_usb_retimer.init(&usb_muxes[USBC_PORT_C1]), NULL);
+		      bb_usb_retimer.init(usb_muxes[USBC_PORT_C1].mux), NULL);
 	zassert_equal(0, gpio_emul_output_get(gpio_dev, GPIO_USB_C1_LS_EN_PORT),
 		      NULL);
 
diff --git a/zephyr/test/drivers/default/src/tcpci.c b/zephyr/test/drivers/default/src/tcpci.c
index 9a0b65ec0d..e549e5056a 100644
--- a/zephyr/test/drivers/default/src/tcpci.c
+++ b/zephyr/test/drivers/default/src/tcpci.c
@@ -288,13 +288,13 @@ ZTEST(tcpci, test_generic_tcpci_debug_accessory)
 /* Setup TCPCI usb mux to behave as it is used only for usb mux */
 static void set_usb_mux_not_tcpc(void)
 {
-	usb_muxes[USBC_PORT_C0].flags = USB_MUX_FLAG_NOT_TCPC;
+	usbc0_mux0.flags = USB_MUX_FLAG_NOT_TCPC;
 }
 
 /* Setup TCPCI usb mux to behave as it is used for usb mux and TCPC */
 static void set_usb_mux_tcpc(void)
 {
-	usb_muxes[USBC_PORT_C0].flags = 0;
+	usbc0_mux0.flags = 0;
 }
 
 /** Test TCPCI mux init */
@@ -303,7 +303,7 @@ ZTEST(tcpci, test_generic_tcpci_mux_init)
 	const struct emul *emul = EMUL_DT_GET(TCPCI_EMUL_NODE);
 	struct i2c_common_emul_data *common_data =
 		emul_tcpci_generic_get_i2c_common_data(emul);
-	struct usb_mux *tcpci_usb_mux = &usb_muxes[USBC_PORT_C0];
+	const struct usb_mux *tcpci_usb_mux = usb_muxes[USBC_PORT_C0].mux;
 
 	/* Set as usb mux with TCPC for first init call */
 	set_usb_mux_tcpc();
@@ -360,7 +360,7 @@ ZTEST(tcpci, test_generic_tcpci_mux_enter_low_power)
 	const struct emul *emul = EMUL_DT_GET(TCPCI_EMUL_NODE);
 	struct i2c_common_emul_data *common_data =
 		emul_tcpci_generic_get_i2c_common_data(emul);
-	struct usb_mux *tcpci_usb_mux = &usb_muxes[USBC_PORT_C0];
+	const struct usb_mux *tcpci_usb_mux = usb_muxes[USBC_PORT_C0].mux;
 
 	/* Set as usb mux with TCPC for first enter_low_power call */
 	set_usb_mux_tcpc();
@@ -393,7 +393,7 @@ static void test_generic_tcpci_mux_set_get(void)
 	const struct emul *emul = EMUL_DT_GET(TCPCI_EMUL_NODE);
 	struct i2c_common_emul_data *common_data =
 		emul_tcpci_generic_get_i2c_common_data(emul);
-	struct usb_mux *tcpci_usb_mux = &usb_muxes[USBC_PORT_C0];
+	const struct usb_mux *tcpci_usb_mux = usb_muxes[USBC_PORT_C0].mux;
 	mux_state_t mux_state, mux_state_get;
 	uint16_t exp_val, initial_val;
 	bool ack;
@@ -508,7 +508,8 @@ ZTEST(tcpci, test_generic_tcpci_hard_reset_reinit)
 static void *tcpci_setup(void)
 {
 	/* This test suite assumes that first usb mux for port C0 is TCPCI */
-	__ASSERT(usb_muxes[USBC_PORT_C0].driver == &tcpci_tcpm_usb_mux_driver,
+	__ASSERT(usb_muxes[USBC_PORT_C0].mux->driver ==
+			 &tcpci_tcpm_usb_mux_driver,
 		 "Invalid config of usb_muxes in test/drivers/src/stubs.c");
 
 	return NULL;
diff --git a/zephyr/test/drivers/default/src/usb_mux.c b/zephyr/test/drivers/default/src/usb_mux.c
index 14a17aa683..45b81d6ea5 100644
--- a/zephyr/test/drivers/default/src/usb_mux.c
+++ b/zephyr/test/drivers/default/src/usb_mux.c
@@ -29,7 +29,7 @@
 #include "test/drivers/utils.h"
 
 /** Copy of original usb_muxes[USB_PORT_C1] */
-struct usb_mux usb_mux_c1;
+struct usb_mux_chain usb_mux_c1;
 
 /** Number of usb mux proxies in chain */
 #define NUM_OF_PROXY 3
@@ -280,39 +280,51 @@ static void reset_proxy_fakes(void)
 }
 
 /** Chain of 3 proxy usb muxes */
-struct usb_mux proxy_chain_2 = {
+struct usb_mux proxy_mux_2 = {
 	.usb_port = USBC_PORT_C1,
 	.driver = &proxy_usb_mux,
-	.next_mux = NULL,
 	.i2c_addr_flags = 2,
 	.hpd_update = &proxy_hpd_update,
 };
 
-struct usb_mux proxy_chain_1 = {
+struct usb_mux_chain proxy_chain_2 = {
+	.mux = &proxy_mux_2,
+};
+
+struct usb_mux proxy_mux_1 = {
 	.usb_port = USBC_PORT_C1,
 	.driver = &proxy_usb_mux,
-	.next_mux = &proxy_chain_2,
 	.i2c_addr_flags = 1,
 	.hpd_update = &proxy_hpd_update,
 };
 
-struct usb_mux proxy_chain_0 = {
+struct usb_mux_chain proxy_chain_1 = {
+	.mux = &proxy_mux_1,
+	.next = &proxy_chain_2,
+};
+
+struct usb_mux proxy_mux_0 = {
 	.usb_port = USBC_PORT_C1,
 	.driver = &proxy_usb_mux,
-	.next_mux = &proxy_chain_1,
 	.i2c_addr_flags = 0,
 	.hpd_update = &proxy_hpd_update,
 };
 
+struct usb_mux_chain proxy_chain_0 = {
+	.mux = &proxy_mux_0,
+	.next = &proxy_chain_1,
+};
+
 /** Setup first 3 usb muxes of port 1 with proxy */
 static void setup_usb_mux_proxy_chain(void)
 {
-	const struct usb_mux *t;
+	const struct usb_mux_chain *t;
 	int i;
 
-	memcpy(&usb_mux_c1, &usb_muxes[USBC_PORT_C1], sizeof(struct usb_mux));
+	memcpy(&usb_mux_c1, &usb_muxes[USBC_PORT_C1],
+	       sizeof(struct usb_mux_chain));
 	memcpy(&usb_muxes[USBC_PORT_C1], &proxy_chain_0,
-	       sizeof(struct usb_mux));
+	       sizeof(struct usb_mux_chain));
 
 	/*
 	 * Setup org_mux array to point real driver which should be called by
@@ -320,28 +332,31 @@ static void setup_usb_mux_proxy_chain(void)
 	 */
 	t = &usb_mux_c1;
 	for (i = 0; i < NUM_OF_PROXY; i++) {
-		org_mux[i] = t;
 		if (t != NULL) {
-			t = t->next_mux;
+			org_mux[i] = t->mux;
+			t = t->next;
+		} else {
+			org_mux[i] = NULL;
 		}
 	}
 
-	if (org_mux[2] != NULL) {
-		proxy_chain_2.next_mux = org_mux[2]->next_mux;
+	if (t != NULL) {
+		proxy_chain_2.next = t;
 	} else {
-		proxy_chain_2.next_mux = NULL;
+		proxy_chain_2.next = NULL;
 	}
 }
 
 /** Restore original usb_mux chain without proxy */
 static void restore_usb_mux_chain(void)
 {
-	memcpy(&usb_muxes[USBC_PORT_C1], &usb_mux_c1, sizeof(struct usb_mux));
+	memcpy(&usb_muxes[USBC_PORT_C1], &usb_mux_c1,
+	       sizeof(struct usb_mux_chain));
 
 	/* Reset flags to default */
-	proxy_chain_0.flags = 0;
-	proxy_chain_1.flags = 0;
-	proxy_chain_2.flags = 0;
+	proxy_mux_0.flags = 0;
+	proxy_mux_1.flags = 0;
+	proxy_mux_2.flags = 0;
 }
 
 /**
@@ -354,15 +369,15 @@ static void restore_usb_mux_chain(void)
 		zassert_equal(num, proxy##_fake.call_count, "%d != %d", num, \
 			      proxy##_fake.call_count);                      \
 		if (num >= 1) {                                              \
-			zassert_equal(&usb_muxes[USBC_PORT_C1],              \
+			zassert_equal(usb_muxes[USBC_PORT_C1].mux,           \
 				      proxy##_fake.arg0_history[0], NULL);   \
 		}                                                            \
 		if (num >= 2) {                                              \
-			zassert_equal(&proxy_chain_1,                        \
+			zassert_equal(proxy_chain_1.mux,                     \
 				      proxy##_fake.arg0_history[1], NULL);   \
 		}                                                            \
 		if (num >= 3) {                                              \
-			zassert_equal(&proxy_chain_2,                        \
+			zassert_equal(proxy_chain_2.mux,                     \
 				      proxy##_fake.arg0_history[2], NULL);   \
 		}                                                            \
 	} while (0)
@@ -414,16 +429,16 @@ ZTEST(usb_uninit_mux, test_usb_mux_init)
 	CHECK_PROXY_FAKE_CALL_CNT(proxy_init, 2);
 
 	/* Test board init callback */
-	proxy_chain_1.board_init = &mock_board_init;
+	proxy_mux_1.board_init = &mock_board_init;
 	reset_proxy_fakes();
 	usb_mux_init(USBC_PORT_C1);
 	CHECK_PROXY_FAKE_CALL_CNT(proxy_init, NUM_OF_PROXY);
 	/* Check if board_init was called for proxy 1 */
 	zassert_equal(1, mock_board_init_fake.call_count, NULL);
-	zassert_equal(&proxy_chain_1, mock_board_init_fake.arg0_history[0],
+	zassert_equal(proxy_chain_1.mux, mock_board_init_fake.arg0_history[0],
 		      NULL);
 
-	proxy_chain_1.board_init = NULL;
+	proxy_mux_1.board_init = NULL;
 }
 
 /** Test usb_mux setting mux mode */
@@ -433,7 +448,7 @@ ZTEST(usb_uninit_mux, test_usb_mux_set)
 	mux_state_t exp_mode;
 
 	/* Set flag for usb mux 1 to disable polarity setting */
-	proxy_chain_1.flags = USB_MUX_FLAG_SET_WITHOUT_FLIP;
+	proxy_mux_1.flags = USB_MUX_FLAG_SET_WITHOUT_FLIP;
 
 	/* Test setting mux mode without polarity inversion */
 	reset_proxy_fakes();
@@ -460,14 +475,14 @@ ZTEST(usb_uninit_mux, test_usb_mux_set)
 
 	/* Test board set callback */
 	reset_proxy_fakes();
-	proxy_chain_1.board_set = &mock_board_set;
+	proxy_mux_1.board_set = &mock_board_set;
 	usb_mux_set(USBC_PORT_C1, exp_mode, USB_SWITCH_CONNECT,
 		    0 /* = polarity */);
 	CHECK_PROXY_FAKE_CALL_CNT(proxy_init, 0);
 	CHECK_PROXY_FAKE_CALL_CNT_MUX_STATE(proxy_set, NUM_OF_PROXY, exp_mode);
 	/* Check if board_set was called for proxy 1 */
 	zassert_equal(1, mock_board_set_fake.call_count, NULL);
-	zassert_equal(&proxy_chain_1, mock_board_set_fake.arg0_history[0],
+	zassert_equal(proxy_chain_1.mux, mock_board_set_fake.arg0_history[0],
 		      NULL);
 	zassert_equal(exp_mode, mock_board_set_fake.arg1_history[0], NULL);
 
@@ -481,7 +496,7 @@ ZTEST(usb_uninit_mux, test_usb_mux_set)
 	/* board_set shouldn't be called after fail */
 	zassert_equal(0, mock_board_set_fake.call_count, NULL);
 
-	proxy_chain_1.board_set = NULL;
+	proxy_mux_1.board_set = NULL;
 }
 
 /** Test usb_mux reset in g3 when required flag is set */
@@ -497,7 +512,7 @@ ZTEST(usb_uninit_mux, test_usb_mux_reset_in_g3)
 	CHECK_PROXY_FAKE_CALL_CNT_MUX_STATE(proxy_set, NUM_OF_PROXY, exp_mode);
 
 	/* Usb muxes of port 1 should stay initialised */
-	usb_muxes[USBC_PORT_C1].flags = 0;
+	proxy_mux_0.flags = 0;
 	hook_notify(HOOK_CHIPSET_HARD_OFF);
 
 	/* Test that init is not called */
@@ -617,7 +632,7 @@ ZTEST(usb_uninit_mux, test_usb_mux_flip)
 	mux_state_t exp_mode;
 
 	/* Set flag for usb mux 1 to disable polarity setting */
-	proxy_chain_1.flags = USB_MUX_FLAG_SET_WITHOUT_FLIP;
+	proxy_mux_1.flags = USB_MUX_FLAG_SET_WITHOUT_FLIP;
 
 	/* Test flip port without polarity inverted */
 	exp_mode = USB_PD_MUX_USB_ENABLED;
@@ -701,15 +716,21 @@ ZTEST(usb_uninit_mux, test_usb_mux_hpd_update)
 					    exp_mode);
 
 	/* Test ps8xxx hpd update */
-	usb_muxes[USBC_PORT_C1].usb_port = 1;
-	usb_muxes[USBC_PORT_C1].driver = &tcpci_tcpm_usb_mux_driver;
-	usb_muxes[USBC_PORT_C1].hpd_update = &ps8xxx_tcpc_update_hpd_status;
+	proxy_mux_0.usb_port = 1;
+	proxy_mux_0.driver = &tcpci_tcpm_usb_mux_driver;
+	proxy_mux_0.hpd_update = &ps8xxx_tcpc_update_hpd_status;
 
 	reset_proxy_fakes();
 	exp_mode = virt_mode | USB_PD_MUX_HPD_LVL | USB_PD_MUX_HPD_IRQ;
 	usb_mux_hpd_update(USBC_PORT_C1, exp_mode);
 	/* Check if PS8xxx mux mode is updated correctly */
-	tcpci_tcpm_usb_mux_driver.get(&usb_muxes[USBC_PORT_C1], &mode);
+	tcpci_tcpm_usb_mux_driver.get(usb_muxes[USBC_PORT_C1].mux, &mode);
+
+	/* Restore proxy chain 0 */
+	proxy_mux_0.usb_port = USBC_PORT_C1;
+	proxy_mux_0.driver = &proxy_usb_mux;
+	proxy_mux_0.hpd_update = &proxy_hpd_update;
+
 	zassert_equal(0, mode, "mux mode is 0x%x (!= 0x%x)", mode, 0);
 }
 
@@ -855,7 +876,7 @@ void usb_uninit_mux_before(void *state)
 	set_test_runner_tid();
 
 	/* Makes sure that usb muxes of port 1 are not init */
-	usb_muxes[USBC_PORT_C1].flags = USB_MUX_FLAG_RESETS_IN_G3;
+	proxy_mux_0.flags = USB_MUX_FLAG_RESETS_IN_G3;
 	hook_notify(HOOK_CHIPSET_HARD_OFF);
 	reset_proxy_fakes();
 }
diff --git a/zephyr/test/vboot_efs2/src/main.c b/zephyr/test/vboot_efs2/src/main.c
index ae923855f2..6d4a9661bd 100644
--- a/zephyr/test/vboot_efs2/src/main.c
+++ b/zephyr/test/vboot_efs2/src/main.c
@@ -315,12 +315,14 @@ const struct pi3usb9201_config_t pi3usb9201_bc12_chips[] = {
 	},
 };
 
-struct usb_mux usb_muxes[] = {
+struct usb_mux_chain usb_muxes[] = {
 	[USBC_PORT_C0] = {
-		.usb_port = USBC_PORT_C0,
-		.driver = &tcpci_tcpm_usb_mux_driver,
-		.i2c_port = I2C_PORT_USB_C0,
-		.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(tcpci_emul)),
+		.mux = &(struct usb_mux) {
+			.usb_port = USBC_PORT_C0,
+			.driver = &tcpci_tcpm_usb_mux_driver,
+			.i2c_port = I2C_PORT_USB_C0,
+			.i2c_addr_flags = DT_REG_ADDR(DT_NODELABEL(tcpci_emul)),
+		},
 	},
 };