diff options
Diffstat (limited to 'chip/stm32/usb_spi.c')
| -rw-r--r-- | chip/stm32/usb_spi.c | 286 |
1 files changed, 135 insertions, 151 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); |