From 3d67ca20c4432a7258d4710c0be07d344998c992 Mon Sep 17 00:00:00 2001 From: "Jes B. Klinke" Date: Sun, 19 Mar 2023 20:19:33 -0700 Subject: 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 Tested-by: Jes Klinke Commit-Queue: Jes Klinke --- chip/stm32/usb_spi.c | 286 ++++++++++++++++++++++++--------------------------- chip/stm32/usb_spi.h | 86 +++++++--------- 2 files changed, 175 insertions(+), 197 deletions(-) (limited to 'chip') 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 -- cgit v1.2.1