chip/stm32: Eliminate support for multiple USB->SPI instances

For some reason, all methods in usb_spi.c pass along pointers to config
and state, as if prepared to have multiple USB interfaces each
implementing their own instance of the SPI->USB bridge protocol.  Doing
so would make little sense, as a single instance is already able to
manipulate multiple SPI busses.

This CL eliminates the pointer parameters, for a tiny performance
improvement, and code simplification.

BUG=b:273601311
TEST=none

Change-Id: Ifbfdb18b4a2ba656732e4eb143de9f678416067a
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/4352128
Reviewed-by: Brian Nemec <bnemec@google.com>
Tested-by: Jes Klinke <jbk@chromium.org>
Commit-Queue: Jes Klinke <jbk@chromium.org>

2 files changed, 175 insertions, 197 deletions

diff --git a/chip/stm32/usb_spi.c b/chip/stm32/usb_spi.c
index a350415dab..36f28dbbb0 100644
--- a/chip/stm32/usb_spi.c
+++ b/chip/stm32/usb_spi.c
@@ -14,12 +14,10 @@
 #include "util.h"
 
 /* Forward declare platform specific functions. */
-static bool usb_spi_received_packet(struct usb_spi_config const *config);
-static bool usb_spi_transmitted_packet(struct usb_spi_config const *config);
-static void usb_spi_read_packet(struct usb_spi_config const *config,
-				struct usb_spi_packet_ctx *packet);
-static void usb_spi_write_packet(struct usb_spi_config const *config,
-				 struct usb_spi_packet_ctx *packet);
+static bool usb_spi_received_packet(void);
+static bool usb_spi_transmitted_packet(void);
+static void usb_spi_read_packet(struct usb_spi_packet_ctx *packet);
+static void usb_spi_write_packet(struct usb_spi_packet_ctx *packet);
 
 /*
  * Map EC error codes to USB_SPI error codes.
@@ -100,17 +98,16 @@ static void usb_spi_fill_usb_packet(struct usb_spi_packet_ctx *dst,
  * @param write_count   Number of bytes to write in the SPI transfer
  * @param read_count    Number of bytes to read in the SPI transfer
  */
-static void usb_spi_setup_transfer(struct usb_spi_config const *config,
-				   size_t write_count, size_t read_count)
+static void usb_spi_setup_transfer(size_t write_count, size_t read_count)
 {
 	/* Reset any status code. */
-	config->state->status_code = USB_SPI_SUCCESS;
+	usb_spi_state.status_code = USB_SPI_SUCCESS;
 
 	/* Reset the write and read counts. */
-	config->state->spi_write_ctx.transfer_size = write_count;
-	config->state->spi_write_ctx.transfer_index = 0;
-	config->state->spi_read_ctx.transfer_size = read_count;
-	config->state->spi_read_ctx.transfer_index = 0;
+	usb_spi_state.spi_write_ctx.transfer_size = write_count;
+	usb_spi_state.spi_write_ctx.transfer_index = 0;
+	usb_spi_state.spi_read_ctx.transfer_size = read_count;
+	usb_spi_state.spi_read_ctx.transfer_index = 0;
 }
 
 /*
@@ -118,10 +115,10 @@ static void usb_spi_setup_transfer(struct usb_spi_config const *config,
  *
  * @param config        USB SPI config
  */
-static void usb_spi_reset_interface(struct usb_spi_config const *config)
+static void usb_spi_reset_interface(void)
 {
 	/* Setup a 0 byte transfer to clear the contexts. */
-	usb_spi_setup_transfer(config, 0, 0);
+	usb_spi_setup_transfer(0, 0);
 }
 
 /*
@@ -131,10 +128,10 @@ static void usb_spi_reset_interface(struct usb_spi_config const *config)
  *
  * @returns         	True if a response transfer is in progress.
  */
-static bool usb_spi_response_in_progress(struct usb_spi_config const *config)
+static bool usb_spi_response_in_progress(void)
 {
-	if ((config->state->mode == USB_SPI_MODE_START_RESPONSE) ||
-	    (config->state->mode == USB_SPI_MODE_CONTINUE_RESPONSE)) {
+	if ((usb_spi_state.mode == USB_SPI_MODE_START_RESPONSE) ||
+	    (usb_spi_state.mode == USB_SPI_MODE_CONTINUE_RESPONSE)) {
 		return true;
 	}
 	return false;
@@ -148,16 +145,15 @@ static bool usb_spi_response_in_progress(struct usb_spi_config const *config)
  * @param config        USB SPI config
  * @param status_code	status code to set for the response.
  */
-static void setup_transfer_response(struct usb_spi_config const *config,
-				    uint16_t status_code)
+static void setup_transfer_response(uint16_t status_code)
 {
-	config->state->status_code = status_code;
-	config->state->spi_read_ctx.transfer_index = 0;
-	config->state->mode = USB_SPI_MODE_START_RESPONSE;
+	usb_spi_state.status_code = status_code;
+	usb_spi_state.spi_read_ctx.transfer_index = 0;
+	usb_spi_state.mode = USB_SPI_MODE_START_RESPONSE;
 
 	/* If an error occurred, transmit an empty start packet. */
 	if (status_code != USB_SPI_SUCCESS)
-		config->state->spi_read_ctx.transfer_size = 0;
+		usb_spi_state.spi_read_ctx.transfer_size = 0;
 }
 
 /*
@@ -166,8 +162,7 @@ static void setup_transfer_response(struct usb_spi_config const *config,
  * @param config        USB SPI config
  * @param packet        Packet buffer we will be transmitting.
  */
-static void create_spi_config_response(struct usb_spi_config const *config,
-				       struct usb_spi_packet_ctx *packet)
+static void create_spi_config_response(struct usb_spi_packet_ctx *packet)
 {
 	/* Construct the response packet. */
 	packet->rsp_config.packet_id = USB_SPI_PKT_ID_RSP_USB_SPI_CONFIG;
@@ -182,8 +177,7 @@ static void create_spi_config_response(struct usb_spi_config const *config,
 	packet->packet_size = sizeof(struct usb_spi_response_configuration_v2);
 }
 
-static void create_spi_chip_select_response(struct usb_spi_config const *config,
-					    struct usb_spi_packet_ctx *packet)
+static void create_spi_chip_select_response(struct usb_spi_packet_ctx *packet)
 {
 	/* Construct the response packet. */
 	packet->rsp_cs.packet_id = USB_SPI_PKT_ID_RSP_CHIP_SELECT;
@@ -200,41 +194,40 @@ static void create_spi_chip_select_response(struct usb_spi_config const *config,
  * @param packet        Packet buffer we will be transmitting.
  */
 static void
-usb_spi_create_spi_transfer_response(struct usb_spi_config const *config,
-				     struct usb_spi_packet_ctx *transmit_packet)
+usb_spi_create_spi_transfer_response(struct usb_spi_packet_ctx *transmit_packet)
 {
-	if (!usb_spi_response_in_progress(config))
+	if (!usb_spi_response_in_progress())
 		return;
 
-	if (config->state->spi_read_ctx.transfer_index == 0) {
+	if (usb_spi_state.spi_read_ctx.transfer_index == 0) {
 		/* Transmit the first packet with the status code. */
 		transmit_packet->header_size =
 			offsetof(struct usb_spi_response_v2, data);
 		transmit_packet->rsp_start.packet_id =
 			USB_SPI_PKT_ID_RSP_TRANSFER_START;
 		transmit_packet->rsp_start.status_code =
-			config->state->status_code;
+			usb_spi_state.status_code;
 
 		usb_spi_fill_usb_packet(transmit_packet,
-					&config->state->spi_read_ctx);
-	} else if (config->state->spi_read_ctx.transfer_index <
-		   config->state->spi_read_ctx.transfer_size) {
+					&usb_spi_state.spi_read_ctx);
+	} else if (usb_spi_state.spi_read_ctx.transfer_index <
+		   usb_spi_state.spi_read_ctx.transfer_size) {
 		/* Transmit the continue packets. */
 		transmit_packet->header_size =
 			offsetof(struct usb_spi_continue_v2, data);
 		transmit_packet->rsp_continue.packet_id =
 			USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE;
 		transmit_packet->rsp_continue.data_index =
-			config->state->spi_read_ctx.transfer_index;
+			usb_spi_state.spi_read_ctx.transfer_index;
 
 		usb_spi_fill_usb_packet(transmit_packet,
-					&config->state->spi_read_ctx);
+					&usb_spi_state.spi_read_ctx);
 	}
-	if (config->state->spi_read_ctx.transfer_index <
-	    config->state->spi_read_ctx.transfer_size) {
-		config->state->mode = USB_SPI_MODE_CONTINUE_RESPONSE;
+	if (usb_spi_state.spi_read_ctx.transfer_index <
+	    usb_spi_state.spi_read_ctx.transfer_size) {
+		usb_spi_state.mode = USB_SPI_MODE_CONTINUE_RESPONSE;
 	} else {
-		config->state->mode = USB_SPI_MODE_IDLE;
+		usb_spi_state.mode = USB_SPI_MODE_IDLE;
 	}
 }
 
@@ -244,21 +237,20 @@ usb_spi_create_spi_transfer_response(struct usb_spi_config const *config,
  * @param config        USB SPI config
  * @param packet        Received packet to process.
  */
-static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
-				      struct usb_spi_packet_ctx *packet)
+static void usb_spi_process_rx_packet(struct usb_spi_packet_ctx *packet)
 {
 	if (packet->packet_size < USB_SPI_MIN_PACKET_SIZE) {
 		/* No valid packet exists smaller than the packet id. */
-		setup_transfer_response(config, USB_SPI_RX_UNEXPECTED_PACKET);
+		setup_transfer_response(USB_SPI_RX_UNEXPECTED_PACKET);
 		return;
 	}
 	/* Reset the mode until we've processed the packet. */
-	config->state->mode = USB_SPI_MODE_IDLE;
+	usb_spi_state.mode = USB_SPI_MODE_IDLE;
 
 	switch (packet->packet_id) {
 	case USB_SPI_PKT_ID_CMD_GET_USB_SPI_CONFIG: {
 		/* The host requires the SPI configuration. */
-		config->state->mode = USB_SPI_MODE_SEND_CONFIGURATION;
+		usb_spi_state.mode = USB_SPI_MODE_SEND_CONFIGURATION;
 		break;
 	}
 	case USB_SPI_PKT_ID_CMD_RESTART_RESPONSE: {
@@ -267,7 +259,7 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
 		 * This is used to recover from lost USB packets without
 		 * duplicating SPI transfers.
 		 */
-		setup_transfer_response(config, config->state->status_code);
+		setup_transfer_response(usb_spi_state.status_code);
 		break;
 	}
 	case USB_SPI_PKT_ID_CMD_TRANSFER_START: {
@@ -275,40 +267,37 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
 		size_t write_count = packet->cmd_start.write_count;
 		size_t read_count = packet->cmd_start.read_count;
 
-		if (!config->state->enabled) {
-			setup_transfer_response(config, USB_SPI_DISABLED);
+		if (!usb_spi_state.enabled) {
+			setup_transfer_response(USB_SPI_DISABLED);
 		} else if (write_count > USB_SPI_MAX_WRITE_COUNT) {
-			setup_transfer_response(config,
-						USB_SPI_WRITE_COUNT_INVALID);
+			setup_transfer_response(USB_SPI_WRITE_COUNT_INVALID);
 #ifdef CONFIG_SPI_HALFDUPLEX
 		} else if (read_count == USB_SPI_FULL_DUPLEX_ENABLED) {
 			/* Full duplex mode is not supported on this device. */
 			setup_transfer_response(
-				config, USB_SPI_UNSUPPORTED_FULL_DUPLEX);
+				USB_SPI_UNSUPPORTED_FULL_DUPLEX);
 #endif
 		} else if (read_count > USB_SPI_MAX_READ_COUNT &&
 			   read_count != USB_SPI_FULL_DUPLEX_ENABLED) {
-			setup_transfer_response(config,
-						USB_SPI_READ_COUNT_INVALID);
+			setup_transfer_response(USB_SPI_READ_COUNT_INVALID);
 		} else {
-			usb_spi_setup_transfer(config, write_count, read_count);
+			usb_spi_setup_transfer(write_count, read_count);
 			packet->header_size =
 				offsetof(struct usb_spi_command_v2, data);
-			config->state->status_code = usb_spi_read_usb_packet(
-				&config->state->spi_write_ctx, packet);
+			usb_spi_state.status_code = usb_spi_read_usb_packet(
+				&usb_spi_state.spi_write_ctx, packet);
 		}
 
 		/* Send responses if we encountered an error. */
-		if (config->state->status_code != USB_SPI_SUCCESS) {
-			setup_transfer_response(config,
-						config->state->status_code);
+		if (usb_spi_state.status_code != USB_SPI_SUCCESS) {
+			setup_transfer_response(usb_spi_state.status_code);
 			break;
 		}
 
 		/* Start the SPI transfer when we've read all data. */
-		if (config->state->spi_write_ctx.transfer_index ==
-		    config->state->spi_write_ctx.transfer_size) {
-			config->state->mode = USB_SPI_MODE_START_SPI;
+		if (usb_spi_state.spi_write_ctx.transfer_index ==
+		    usb_spi_state.spi_write_ctx.transfer_size) {
+			usb_spi_state.mode = USB_SPI_MODE_START_SPI;
 		}
 
 		break;
@@ -320,22 +309,21 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
 		 */
 		packet->header_size =
 			offsetof(struct usb_spi_continue_v2, data);
-		if (config->state->status_code == USB_SPI_SUCCESS) {
-			config->state->status_code = usb_spi_read_usb_packet(
-				&config->state->spi_write_ctx, packet);
+		if (usb_spi_state.status_code == USB_SPI_SUCCESS) {
+			usb_spi_state.status_code = usb_spi_read_usb_packet(
+				&usb_spi_state.spi_write_ctx, packet);
 		}
 
 		/* Send responses if we encountered an error. */
-		if (config->state->status_code != USB_SPI_SUCCESS) {
-			setup_transfer_response(config,
-						config->state->status_code);
+		if (usb_spi_state.status_code != USB_SPI_SUCCESS) {
+			setup_transfer_response(usb_spi_state.status_code);
 			break;
 		}
 
 		/* Start the SPI transfer when we've read all data. */
-		if (config->state->spi_write_ctx.transfer_index ==
-		    config->state->spi_write_ctx.transfer_size) {
-			config->state->mode = USB_SPI_MODE_START_SPI;
+		if (usb_spi_state.spi_write_ctx.transfer_index ==
+		    usb_spi_state.spi_write_ctx.transfer_size) {
+			usb_spi_state.mode = USB_SPI_MODE_START_SPI;
 		}
 
 		break;
@@ -347,7 +335,7 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
 		 */
 		uint16_t flags = packet->cmd_cs.flags;
 		const struct spi_device_t *current_device =
-			&spi_devices[config->state->current_spi_device_idx];
+			&spi_devices[usb_spi_state.current_spi_device_idx];
 
 		if (flags & USB_SPI_CHIP_SELECT) {
 			/* Set chip select low (asserted). */
@@ -356,12 +344,12 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
 			/* Set chip select high (adesserted). */
 			gpio_set_level(current_device->gpio_cs, 1);
 		}
-		config->state->mode = USB_SPI_MODE_SEND_CHIP_SELECT_RESPONSE;
+		usb_spi_state.mode = USB_SPI_MODE_SEND_CHIP_SELECT_RESPONSE;
 		break;
 	}
 	default: {
 		/* An unknown USB packet was delivered. */
-		setup_transfer_response(config, USB_SPI_RX_UNEXPECTED_PACKET);
+		setup_transfer_response(USB_SPI_RX_UNEXPECTED_PACKET);
 		break;
 	}
 	}
@@ -372,72 +360,72 @@ static void usb_spi_process_rx_packet(struct usb_spi_config const *config,
  *
  * @param config        USB SPI config
  */
-void usb_spi_deferred(struct usb_spi_config const *config)
+void usb_spi_deferred(void)
 {
 	int enabled;
 	struct usb_spi_packet_ctx *receive_packet =
-		&config->state->receive_packet;
+		&usb_spi_state.receive_packet;
 	struct usb_spi_packet_ctx *transmit_packet =
-		&config->state->transmit_packet;
+		&usb_spi_state.transmit_packet;
 	transmit_packet->packet_size = 0;
 
-	if (config->flags & USB_SPI_CONFIG_FLAGS_IGNORE_HOST_SIDE_ENABLE)
-		enabled = config->state->enabled_device;
+	if (usb_spi.flags & USB_SPI_CONFIG_FLAGS_IGNORE_HOST_SIDE_ENABLE)
+		enabled = usb_spi_state.enabled_device;
 	else
-		enabled = config->state->enabled_device &&
-			  config->state->enabled_host;
+		enabled = usb_spi_state.enabled_device &&
+			  usb_spi_state.enabled_host;
 
 	/*
 	 * If our overall enabled state has changed we call the board specific
 	 * enable or disable routines and save our new state.
 	 */
-	if (enabled != config->state->enabled) {
+	if (enabled != usb_spi_state.enabled) {
 		if (enabled)
-			usb_spi_board_enable(config);
+			usb_spi_board_enable();
 		else
-			usb_spi_board_disable(config);
+			usb_spi_board_disable();
 
-		config->state->enabled = enabled;
+		usb_spi_state.enabled = enabled;
 	}
 
 	/* Read any packets from the endpoint. */
 
-	usb_spi_read_packet(config, receive_packet);
+	usb_spi_read_packet(receive_packet);
 	if (receive_packet->packet_size) {
-		usb_spi_process_rx_packet(config, receive_packet);
+		usb_spi_process_rx_packet(receive_packet);
 	}
 
 	/* Need to send the USB SPI configuration */
-	if (config->state->mode == USB_SPI_MODE_SEND_CONFIGURATION) {
-		create_spi_config_response(config, transmit_packet);
-		usb_spi_write_packet(config, transmit_packet);
-		config->state->mode = USB_SPI_MODE_IDLE;
+	if (usb_spi_state.mode == USB_SPI_MODE_SEND_CONFIGURATION) {
+		create_spi_config_response(transmit_packet);
+		usb_spi_write_packet(transmit_packet);
+		usb_spi_state.mode = USB_SPI_MODE_IDLE;
 		return;
 	}
 	/* Need to send response to USB SPI chip select. */
-	if (config->state->mode == USB_SPI_MODE_SEND_CHIP_SELECT_RESPONSE) {
-		create_spi_chip_select_response(config, transmit_packet);
-		usb_spi_write_packet(config, transmit_packet);
-		config->state->mode = USB_SPI_MODE_IDLE;
+	if (usb_spi_state.mode == USB_SPI_MODE_SEND_CHIP_SELECT_RESPONSE) {
+		create_spi_chip_select_response(transmit_packet);
+		usb_spi_write_packet(transmit_packet);
+		usb_spi_state.mode = USB_SPI_MODE_IDLE;
 		return;
 	}
 
 	/* Start a new SPI transfer. */
-	if (config->state->mode == USB_SPI_MODE_START_SPI) {
+	if (usb_spi_state.mode == USB_SPI_MODE_START_SPI) {
 		const struct spi_device_t *current_device =
-			&spi_devices[config->state->current_spi_device_idx];
+			&spi_devices[usb_spi_state.current_spi_device_idx];
 		bool custom_board_driver = current_device->usb_flags &
 					   USB_SPI_CUSTOM_SPI_DEVICE;
 		uint16_t status_code;
-		int read_count = config->state->spi_read_ctx.transfer_size;
+		int read_count = usb_spi_state.spi_read_ctx.transfer_size;
 #ifndef CONFIG_SPI_HALFDUPLEX
 		/*
 		 * Handle the full duplex mode on supported platforms.
 		 * The read count is equal to the write count.
 		 */
 		if (read_count == USB_SPI_FULL_DUPLEX_ENABLED) {
-			config->state->spi_read_ctx.transfer_size =
-				config->state->spi_write_ctx.transfer_size;
+			usb_spi_state.spi_read_ctx.transfer_size =
+				usb_spi_state.spi_write_ctx.transfer_size;
 			read_count = SPI_READBACK_ALL;
 		}
 #endif
@@ -445,26 +433,25 @@ void usb_spi_deferred(struct usb_spi_config const *config)
 		if (custom_board_driver) {
 			status_code = usb_spi_board_transaction(
 				current_device, 0 /* flash_flags */,
-				config->state->spi_write_ctx.buffer,
-				config->state->spi_write_ctx.transfer_size,
-				config->state->spi_read_ctx.buffer, read_count);
+				usb_spi_state.spi_write_ctx.buffer,
+				usb_spi_state.spi_write_ctx.transfer_size,
+				usb_spi_state.spi_read_ctx.buffer, read_count);
 		} else {
 			status_code = spi_transaction(
 				current_device,
-				config->state->spi_write_ctx.buffer,
-				config->state->spi_write_ctx.transfer_size,
-				config->state->spi_read_ctx.buffer, read_count);
+				usb_spi_state.spi_write_ctx.buffer,
+				usb_spi_state.spi_write_ctx.transfer_size,
+				usb_spi_state.spi_read_ctx.buffer, read_count);
 		}
 
 		/* Cast the EC status code to USB SPI and start the response. */
 		status_code = usb_spi_map_error(status_code);
-		setup_transfer_response(config, status_code);
+		setup_transfer_response(status_code);
 	}
 
-	if (usb_spi_response_in_progress(config) &&
-	    usb_spi_transmitted_packet(config)) {
-		usb_spi_create_spi_transfer_response(config, transmit_packet);
-		usb_spi_write_packet(config, transmit_packet);
+	if (usb_spi_response_in_progress() && usb_spi_transmitted_packet()) {
+		usb_spi_create_spi_transfer_response(transmit_packet);
+		usb_spi_write_packet(transmit_packet);
 	}
 }
 
@@ -474,11 +461,11 @@ void usb_spi_deferred(struct usb_spi_config const *config)
  * @param config        USB SPI config
  * @param enabled       usb_spi_request indicating which SPI mode is enabled.
  */
-void usb_spi_enable(struct usb_spi_config const *config, int enabled)
+void usb_spi_enable(int enabled)
 {
-	config->state->enabled_device = enabled;
+	usb_spi_state.enabled_device = enabled;
 
-	hook_call_deferred(config->deferred, 0);
+	hook_call_deferred(usb_spi.deferred, 0);
 }
 
 /*
@@ -488,25 +475,24 @@ void usb_spi_enable(struct usb_spi_config const *config, int enabled)
  * @param config        USB SPI config
  * @param packet        Destination packet used to store the endpoint data.
  */
-static void usb_spi_read_packet(struct usb_spi_config const *config,
-				struct usb_spi_packet_ctx *packet)
+static void usb_spi_read_packet(struct usb_spi_packet_ctx *packet)
 {
 	size_t packet_size;
 
-	if (!usb_spi_received_packet(config)) {
+	if (!usb_spi_received_packet()) {
 		/* No data is present on the endpoint. */
 		packet->packet_size = 0;
 		return;
 	}
 
 	/* Copy bytes from endpoint memory. */
-	packet_size = btable_ep[config->endpoint].rx_count & RX_COUNT_MASK;
+	packet_size = btable_ep[usb_spi.endpoint].rx_count & RX_COUNT_MASK;
 	memcpy_from_usbram(packet->bytes,
-			   (void *)usb_sram_addr(config->ep_rx_ram),
+			   (void *)usb_sram_addr(usb_spi.ep_rx_ram),
 			   packet_size);
 	packet->packet_size = packet_size;
 	/* Set endpoint as valid for accepting new packet. */
-	STM32_TOGGLE_EP(config->endpoint, EP_RX_MASK, EP_RX_VALID, 0);
+	STM32_TOGGLE_EP(usb_spi.endpoint, EP_RX_MASK, EP_RX_VALID, 0);
 }
 
 /*
@@ -516,22 +502,21 @@ static void usb_spi_read_packet(struct usb_spi_config const *config,
  * @param config        USB SPI config
  * @param packet        Source packet we will write to the endpoint data.
  */
-static void usb_spi_write_packet(struct usb_spi_config const *config,
-				 struct usb_spi_packet_ctx *packet)
+static void usb_spi_write_packet(struct usb_spi_packet_ctx *packet)
 {
 	if (packet->packet_size == 0)
 		return;
 
 	/* Copy bytes to endpoint memory. */
-	memcpy_to_usbram((void *)usb_sram_addr(config->ep_tx_ram),
+	memcpy_to_usbram((void *)usb_sram_addr(usb_spi.ep_tx_ram),
 			 packet->bytes, packet->packet_size);
-	btable_ep[config->endpoint].tx_count = packet->packet_size;
+	btable_ep[usb_spi.endpoint].tx_count = packet->packet_size;
 
 	/* Mark the packet as having no data. */
 	packet->packet_size = 0;
 
 	/* Set endpoint as valid for transmitting new packet. */
-	STM32_TOGGLE_EP(config->endpoint, EP_TX_MASK, EP_TX_VALID, 0);
+	STM32_TOGGLE_EP(usb_spi.endpoint, EP_TX_MASK, EP_TX_VALID, 0);
 }
 
 /*
@@ -541,9 +526,9 @@ static void usb_spi_write_packet(struct usb_spi_config const *config,
  *
  * @returns             Returns true when the RX endpoint has a packet.
  */
-static bool usb_spi_received_packet(struct usb_spi_config const *config)
+static bool usb_spi_received_packet(void)
 {
-	return (STM32_USB_EP(config->endpoint) & EP_RX_MASK) != EP_RX_VALID;
+	return (STM32_USB_EP(usb_spi.endpoint) & EP_RX_MASK) != EP_RX_VALID;
 }
 
 /* STM32 Platform: Returns the TX endpoint status
@@ -553,16 +538,16 @@ static bool usb_spi_received_packet(struct usb_spi_config const *config)
  * @returns             Returns true when the TX endpoint transmitted
  *                      the packet written.
  */
-static bool usb_spi_transmitted_packet(struct usb_spi_config const *config)
+static bool usb_spi_transmitted_packet(void)
 {
-	return (STM32_USB_EP(config->endpoint) & EP_TX_MASK) != EP_TX_VALID;
+	return (STM32_USB_EP(usb_spi.endpoint) & EP_TX_MASK) != EP_TX_VALID;
 }
 
 /* STM32 Platform: Handle interrupt for USB data received.
  *
  * @param config        USB SPI config
  */
-void usb_spi_rx(struct usb_spi_config const *config)
+void usb_spi_rx(void)
 {
 	/*
 	 * We need to set both the TX and RX endpoints to NAK to prevent
@@ -575,9 +560,9 @@ void usb_spi_rx(struct usb_spi_config const *config)
 	 * This has a side effect of disabling the endpoint interrupts until
 	 * they are set to valid or a USB reset events occurs.
 	 */
-	STM32_TOGGLE_EP(config->endpoint, EP_TX_RX_MASK, EP_TX_RX_NAK, 0);
+	STM32_TOGGLE_EP(usb_spi.endpoint, EP_TX_RX_MASK, EP_TX_RX_NAK, 0);
 
-	hook_call_deferred(config->deferred, 0);
+	hook_call_deferred(usb_spi.deferred, 0);
 }
 
 /*
@@ -585,11 +570,11 @@ void usb_spi_rx(struct usb_spi_config const *config)
  *
  * @param config        USB SPI config
  */
-void usb_spi_tx(struct usb_spi_config const *config)
+void usb_spi_tx(void)
 {
-	STM32_TOGGLE_EP(config->endpoint, EP_TX_MASK, EP_TX_NAK, 0);
+	STM32_TOGGLE_EP(usb_spi.endpoint, EP_TX_MASK, EP_TX_NAK, 0);
 
-	hook_call_deferred(config->deferred, 0);
+	hook_call_deferred(usb_spi.deferred, 0);
 }
 
 /*
@@ -598,21 +583,21 @@ void usb_spi_tx(struct usb_spi_config const *config)
  * @param config        USB SPI config
  * @param evt           USB event
  */
-void usb_spi_event(struct usb_spi_config const *config, enum usb_ep_event evt)
+void usb_spi_event(enum usb_ep_event evt)
 {
 	int endpoint;
 
 	if (evt != USB_EVENT_RESET)
 		return;
 
-	endpoint = config->endpoint;
+	endpoint = usb_spi.endpoint;
 
-	usb_spi_reset_interface(config);
+	usb_spi_reset_interface();
 
-	btable_ep[endpoint].tx_addr = usb_sram_addr(config->ep_tx_ram);
+	btable_ep[endpoint].tx_addr = usb_sram_addr(usb_spi.ep_tx_ram);
 	btable_ep[endpoint].tx_count = 0;
 
-	btable_ep[endpoint].rx_addr = usb_sram_addr(config->ep_rx_ram);
+	btable_ep[endpoint].rx_addr = usb_sram_addr(usb_spi.ep_rx_ram);
 	btable_ep[endpoint].rx_count = 0x8000 |
 				       ((USB_MAX_PACKET_SIZE / 32 - 1) << 10);
 
@@ -629,8 +614,7 @@ void usb_spi_event(struct usb_spi_config const *config, enum usb_ep_event evt)
  * @param rx_buf        Contains setup packet
  * @param tx_buf        unused
  */
-int usb_spi_interface(struct usb_spi_config const *config, usb_uint *rx_buf,
-		      usb_uint *tx_buf)
+int usb_spi_interface(usb_uint *rx_buf, usb_uint *tx_buf)
 {
 	struct usb_setup_packet setup;
 
@@ -642,19 +626,19 @@ int usb_spi_interface(struct usb_spi_config const *config, usb_uint *rx_buf,
 
 	if (setup.wValue >= spi_devices_used ||
 	    !(spi_devices[setup.wValue].usb_flags & USB_SPI_ENABLED) ||
-	    setup.wIndex != config->interface || setup.wLength != 0)
+	    setup.wIndex != usb_spi.interface || setup.wLength != 0)
 		return 1;
 
 	/* Record which SPI device the host wished to manipulate. */
-	config->state->current_spi_device_idx = setup.wValue;
+	usb_spi_state.current_spi_device_idx = setup.wValue;
 
 	switch (setup.bRequest) {
 	case USB_SPI_REQ_ENABLE:
-		config->state->enabled_host = 1;
+		usb_spi_state.enabled_host = 1;
 		break;
 
 	case USB_SPI_REQ_DISABLE:
-		config->state->enabled_host = 0;
+		usb_spi_state.enabled_host = 0;
 		break;
 
 	default:
@@ -665,10 +649,10 @@ int usb_spi_interface(struct usb_spi_config const *config, usb_uint *rx_buf,
 	 * Our state has changed, call the deferred function to handle the
 	 * state change.
 	 */
-	if (!(config->flags & USB_SPI_CONFIG_FLAGS_IGNORE_HOST_SIDE_ENABLE))
-		hook_call_deferred(config->deferred, 0);
+	if (!(usb_spi.flags & USB_SPI_CONFIG_FLAGS_IGNORE_HOST_SIDE_ENABLE))
+		hook_call_deferred(usb_spi.deferred, 0);
 
-	usb_spi_reset_interface(config);
+	usb_spi_reset_interface();
 
 	btable_ep[0].tx_count = 0;
 	STM32_TOGGLE_EP(0, EP_TX_RX_MASK, EP_TX_RX_VALID, EP_STATUS_OUT);
diff --git a/chip/stm32/usb_spi.h b/chip/stm32/usb_spi.h
index 34d69225cf..a8f7f7e280 100644
--- a/chip/stm32/usb_spi.h
+++ b/chip/stm32/usb_spi.h
@@ -521,9 +521,6 @@ struct usb_spi_state {
  * together all information required to operate a USB gpio.
  */
 struct usb_spi_config {
-	/* In RAM state of the USB SPI bridge. */
-	struct usb_spi_state *state;
-
 	/* Interface and endpoint indices. */
 	int interface;
 	int endpoint;
@@ -539,6 +536,10 @@ struct usb_spi_config {
 	uint32_t flags;
 };
 
+/* Storage of configuration and state of USB->SPI bridge. */
+extern struct usb_spi_state usb_spi_state;
+extern struct usb_spi_config const usb_spi;
+
 /*
  * Use when you want the SPI subsystem to be enabled even when the USB SPI
  * endpoint is not enabled by the host. This means that when this firmware
@@ -550,9 +551,6 @@ struct usb_spi_config {
 /*
  * Convenience macro for defining a USB SPI bridge driver.
  *
- * NAME is used to construct the names of the trampoline functions and the
- * usb_spi_config struct, the latter is just called NAME.
- *
  * INTERFACE is the index of the USB interface to associate with this
  * SPI driver.
  *
@@ -562,30 +560,28 @@ struct usb_spi_config {
  * FLAGS encodes different run-time control parameters. See
  * USB_SPI_CONFIG_FLAGS_* for definitions.
  */
-#define USB_SPI_CONFIG(NAME, INTERFACE, ENDPOINT, FLAGS)                    \
-	static uint16_t CONCAT2(NAME,                                       \
-				_buffer_)[(USB_SPI_BUFFER_SIZE + 1) / 2];   \
-	static usb_uint CONCAT2(                                            \
-		NAME, _ep_rx_buffer_)[USB_MAX_PACKET_SIZE / 2] __usb_ram;   \
-	static usb_uint CONCAT2(                                            \
-		NAME, _ep_tx_buffer_)[USB_MAX_PACKET_SIZE / 2] __usb_ram;   \
-	static void CONCAT2(NAME, _deferred_)(void);                        \
-	DECLARE_DEFERRED(CONCAT2(NAME, _deferred_));                        \
-	struct usb_spi_state CONCAT2(NAME, _state_) = {                     \
+#define USB_SPI_CONFIG(INTERFACE, ENDPOINT, FLAGS)                          \
+	static uint16_t usb_spi_buffer_[(USB_SPI_BUFFER_SIZE + 1) / 2];     \
+	static usb_uint                                                     \
+		usb_spi_ep_rx_buffer_[USB_MAX_PACKET_SIZE / 2] __usb_ram;   \
+	static usb_uint                                                     \
+		usb_spi_ep_tx_buffer_[USB_MAX_PACKET_SIZE / 2] __usb_ram;   \
+	static void usb_spi_deferred_(void);                                \
+	DECLARE_DEFERRED(usb_spi_deferred_);                                \
+	struct usb_spi_state usb_spi_state = {                              \
 		.enabled_host = 0,                                          \
 		.enabled_device = 0,                                        \
 		.enabled = 0,                                               \
 		.current_spi_device_idx = 0,                                \
-		.spi_write_ctx.buffer = (uint8_t *)CONCAT2(NAME, _buffer_), \
-		.spi_read_ctx.buffer = (uint8_t *)CONCAT2(NAME, _buffer_),  \
+		.spi_write_ctx.buffer = (uint8_t *)usb_spi_buffer_,         \
+		.spi_read_ctx.buffer = (uint8_t *)usb_spi_buffer_,          \
 	};                                                                  \
-	struct usb_spi_config const NAME = {                                \
-		.state = &CONCAT2(NAME, _state_),                           \
+	struct usb_spi_config const usb_spi = {                             \
 		.interface = INTERFACE,                                     \
 		.endpoint = ENDPOINT,                                       \
-		.deferred = &CONCAT2(NAME, _deferred__data),                \
-		.ep_rx_ram = CONCAT2(NAME, _ep_rx_buffer_),                 \
-		.ep_tx_ram = CONCAT2(NAME, _ep_tx_buffer_),                 \
+		.deferred = &usb_spi_deferred__data,                        \
+		.ep_rx_ram = usb_spi_ep_rx_buffer_,                         \
+		.ep_tx_ram = usb_spi_ep_tx_buffer_,                         \
 		.flags = FLAGS,                                             \
 	};                                                                  \
 	const struct usb_interface_descriptor USB_IFACE_DESC(INTERFACE) = { \
@@ -615,35 +611,34 @@ struct usb_spi_config {
 		.wMaxPacketSize = USB_MAX_PACKET_SIZE,                      \
 		.bInterval = 0,                                             \
 	};                                                                  \
-	static void CONCAT2(NAME, _ep_tx_)(void)                            \
+	static void usb_spi_ep_tx_(void)                                    \
 	{                                                                   \
-		usb_spi_tx(&NAME);                                          \
+		usb_spi_tx();                                               \
 	}                                                                   \
-	static void CONCAT2(NAME, _ep_rx_)(void)                            \
+	static void usb_spi_ep_rx_(void)                                    \
 	{                                                                   \
-		usb_spi_rx(&NAME);                                          \
+		usb_spi_rx();                                               \
 	}                                                                   \
-	static void CONCAT2(NAME, _ep_event_)(enum usb_ep_event evt)        \
+	static void usb_spi_ep_event_(enum usb_ep_event evt)                \
 	{                                                                   \
-		usb_spi_event(&NAME, evt);                                  \
+		usb_spi_event(evt);                                         \
 	}                                                                   \
-	USB_DECLARE_EP(ENDPOINT, CONCAT2(NAME, _ep_tx_),                    \
-		       CONCAT2(NAME, _ep_rx_), CONCAT2(NAME, _ep_event_));  \
-	static int CONCAT2(NAME, _interface_)(usb_uint * rx_buf,            \
-					      usb_uint * tx_buf)            \
+	USB_DECLARE_EP(ENDPOINT, usb_spi_ep_tx_, usb_spi_ep_rx_,            \
+		       usb_spi_ep_event_);                                  \
+	static int usb_spi_interface_(usb_uint *rx_buf, usb_uint *tx_buf)   \
 	{                                                                   \
-		return usb_spi_interface(&NAME, rx_buf, tx_buf);            \
+		return usb_spi_interface(rx_buf, tx_buf);                   \
 	}                                                                   \
-	USB_DECLARE_IFACE(INTERFACE, CONCAT2(NAME, _interface_));           \
-	static void CONCAT2(NAME, _deferred_)(void)                         \
+	USB_DECLARE_IFACE(INTERFACE, usb_spi_interface_);                   \
+	static void usb_spi_deferred_(void)                                 \
 	{                                                                   \
-		usb_spi_deferred(&NAME);                                    \
+		usb_spi_deferred();                                         \
 	}
 
 /*
  * Handle SPI request in a deferred callback.
  */
-void usb_spi_deferred(struct usb_spi_config const *config);
+void usb_spi_deferred(void);
 
 /*
  * Set the enable state for the USB-SPI bridge.
@@ -653,24 +648,23 @@ void usb_spi_deferred(struct usb_spi_config const *config);
  * available for host tools to use without forcing the device to
  * disconnect or disable whatever else might be using the SPI bus.
  */
-void usb_spi_enable(struct usb_spi_config const *config, int enabled);
+void usb_spi_enable(int enabled);
 
 /*
  * These functions are used by the trampoline functions defined above to
  * connect USB endpoint events with the generic USB GPIO driver.
  */
-void usb_spi_tx(struct usb_spi_config const *config);
-void usb_spi_rx(struct usb_spi_config const *config);
-void usb_spi_event(struct usb_spi_config const *config, enum usb_ep_event evt);
-int usb_spi_interface(struct usb_spi_config const *config, usb_uint *rx_buf,
-		      usb_uint *tx_buf);
+void usb_spi_tx(void);
+void usb_spi_rx(void);
+void usb_spi_event(enum usb_ep_event evt);
+int usb_spi_interface(usb_uint *rx_buf, usb_uint *tx_buf);
 
 /*
  * These functions should be implemented by the board to provide any board
  * specific operations required to enable or disable access to the SPI device.
  */
-void usb_spi_board_enable(struct usb_spi_config const *config);
-void usb_spi_board_disable(struct usb_spi_config const *config);
+void usb_spi_board_enable(void);
+void usb_spi_board_disable(void);
 
 /*
  * In order to facilitate special SPI busses not covered by standard EC