diff options
Diffstat (limited to 'raiden_debug_spi.c')
| -rw-r--r-- | raiden_debug_spi.c | 684 |
1 files changed, 672 insertions, 12 deletions
diff --git a/raiden_debug_spi.c b/raiden_debug_spi.c index d6773845..b8e19fe3 100644 --- a/raiden_debug_spi.c +++ b/raiden_debug_spi.c @@ -110,6 +110,222 @@ * of bytes unless this is the final packet. * * + * USB SPI Version 2: + * + * USB SPI version 2 adds support for larger SPI transfers and reduces the + * number of USB packets transferred. This improves performance when + * writing or reading large chunks of memory from a device. A packet ID + * field is used to distinguish the different packet types. Additional + * packets have been included to query the device for its configuration + * allowing the interface to be used on platforms with different SPI + * limitations. It includes validation and a packet to recover from the + * situations where USB packets are lost. + * + * The USB SPI hosts which support packet version 2 are backwards compatible + * and use the bInterfaceProtocol field to identify which type of target + * they are connected to. + * + * + * Example: USB SPI request with 128 byte write and 0 byte read. + * + * Packet #1 Host to Device: + * packet id = USB_SPI_PKT_ID_CMD_TRANSFER_START + * write count = 128 + * read count = 0 + * payload = First 58 bytes from the write buffer, + * starting at byte 0 in the buffer + * packet size = 64 bytes + * + * Packet #2 Host to Device: + * packet id = USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE + * data index = 58 + * payload = Next 60 bytes from the write buffer, + * starting at byte 58 in the buffer + * packet size = 64 bytes + * + * Packet #3 Host to Device: + * packet id = USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE + * data index = 118 + * payload = Next 10 bytes from the write buffer, + * starting at byte 118 in the buffer + * packet size = 14 bytes + * + * Packet #4 Device to Host: + * packet id = USB_SPI_PKT_ID_RSP_TRANSFER_START + * status code = status code from device + * payload = 0 bytes + * packet size = 4 bytes + * + * Example: USB SPI request with 2 byte write and 100 byte read. + * + * Packet #1 Host to Device: + * packet id = USB_SPI_PKT_ID_CMD_TRANSFER_START + * write count = 2 + * read count = 100 + * payload = The 2 byte write buffer + * packet size = 8 bytes + * + * Packet #2 Device to Host: + * packet id = USB_SPI_PKT_ID_RSP_TRANSFER_START + * status code = status code from device + * payload = First 60 bytes from the read buffer, + * starting at byte 0 in the buffer + * packet size = 64 bytes + * + * Packet #3 Device to Host: + * packet id = USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE + * data index = 60 + * payload = Next 40 bytes from the read buffer, + * starting at byte 60 in the buffer + * packet size = 44 bytes + * + * + * Message Packets: + * + * Command Start Packet (Host to Device): + * + * Start of the USB SPI command, contains the number of bytes to write + * and read on SPI and up to the first 58 bytes of write payload. + * Longer writes will use the continue packets with packet id + * USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE to transmit the remaining data. + * + * +----------------+------------------+-----------------+---------------+ + * | packet id : 2B | write count : 2B | read count : 2B | w.p. : <= 58B | + * +----------------+------------------+-----------------+---------------+ + * + * packet id: 2 byte enum defined by packet_id_type + * Valid values packet id = USB_SPI_PKT_ID_CMD_TRANSFER_START + * + * write count: 2 byte, zero based count of bytes to write + * + * read count: 2 byte, zero based count of bytes to read + * UINT16_MAX indicates full duplex mode with a read count + * equal to the write count. + * + * write payload: Up to 58 bytes of data to write to SPI, the total + * length of all TX packets must match write count. + * Due to data alignment constraints, this must be an + * even number of bytes unless this is the final packet. + * + * + * Response Start Packet (Device to Host): + * + * Start of the USB SPI response, contains the status code and up to + * the first 60 bytes of read payload. Longer reads will use the + * continue packets with packet id USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE + * to transmit the remaining data. + * + * +----------------+------------------+-----------------------+ + * | packet id : 2B | status code : 2B | read payload : <= 60B | + * +----------------+------------------+-----------------------+ + * + * packet id: 2 byte enum defined by packet_id_type + * Valid values packet id = USB_SPI_PKT_ID_RSP_TRANSFER_START + * + * status code: 2 byte status code + * 0x0000: Success + * 0x0001: SPI timeout + * 0x0002: Busy, try again + * This can happen if someone else has acquired the shared memory + * buffer that the SPI driver uses as /dev/null + * 0x0003: Write count invalid. The byte limit is platform specific + * and is set during the configure USB SPI response. + * 0x0004: Read count invalid. The byte limit is platform specific + * and is set during the configure USB SPI response. + * 0x0005: The SPI bridge is disabled. + * 0x0006: The RX continue packet's data index is invalid. This + * can indicate a USB transfer failure to the device. + * 0x0007: The RX endpoint has received more data than write count. + * This can indicate a USB transfer failure to the device. + * 0x0008: An unexpected packet arrived that the device could not + * process. + * 0x0009: The device does not support full duplex mode. + * 0x8000: Unknown error mask + * The bottom 15 bits will contain the bottom 15 bits from the EC + * error code. + * + * read payload: Up to 60 bytes of data read from SPI, the total + * length of all RX packets must match read count + * unless an error status was returned. Due to data + * alignment constraints, this must be a even number + * of bytes unless this is the final packet. + * + * + * Continue Packet (Bidirectional): + * + * Continuation packet for the writes and read buffers. Both packets + * follow the same format, a data index counts the number of bytes + * previously transferred in the USB SPI transfer and a payload of bytes. + * + * +----------------+-----------------+-------------------------------+ + * | packet id : 2B | data index : 2B | write / read payload : <= 60B | + * +----------------+-----------------+-------------------------------+ + * + * packet id: 2 byte enum defined by packet_id_type + * The packet id has 2 values depending on direction: + * packet id = USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE + * indicates the packet is being transmitted from the host + * to the device and contains SPI write payload. + * packet id = USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE + * indicates the packet is being transmitted from the device + * to the host and contains SPI read payload. + * + * data index: The data index indicates the number of bytes in the + * read or write buffers that have already been transmitted. + * It is used to validate that no packets have been dropped + * and that the prior packets have been correctly decoded. + * This value corresponds to the offset bytes in the buffer + * to start copying the payload into. + * + * read and write payload: + * Contains up to 60 bytes of payload data to transfer to + * the SPI write buffer or from the SPI read buffer. + * + * + * Command Get Configuration Packet (Host to Device): + * + * Query the device to request its USB SPI configuration indicating + * the number of bytes it can write and read. + * + * +----------------+ + * | packet id : 2B | + * +----------------+ + * + * packet id: 2 byte enum USB_SPI_PKT_ID_CMD_GET_USB_SPI_CONFIG + * + * Response Configuration Packet (Device to Host): + * + * Response packet form the device to report the maximum write and + * read size supported by the device. + * + * +----------------+----------------+---------------+----------------+ + * | packet id : 2B | max write : 2B | max read : 2B | feature bitmap | + * +----------------+----------------+---------------+----------------+ + * + * packet id: 2 byte enum USB_SPI_PKT_ID_RSP_USB_SPI_CONFIG + * + * max write count: 2 byte count of the maximum number of bytes + * the device can write to SPI in one transaction. + * + * max read count: 2 byte count of the maximum number of bytes + * the device can read from SPI in one transaction. + * + * feature bitmap: Bitmap of supported features. + * BIT(0): Full duplex SPI mode is supported + * BIT(1:15): Reserved for future use + * + * Command Restart Response Packet (Host to Device): + * + * Command to restart the response transfer from the device. This enables + * the host to recover from a lost packet when reading the response + * without restarting the SPI transfer. + * + * +----------------+ + * | packet id : 2B | + * +----------------+ + * + * packet id: 2 byte enum USB_SPI_PKT_ID_CMD_RESTART_RESPONSE + * * USB Error Codes: * * send_command return codes have the following format: @@ -171,6 +387,14 @@ enum usb_spi_error { USB_SPI_WRITE_COUNT_INVALID = 0x0003, USB_SPI_READ_COUNT_INVALID = 0x0004, USB_SPI_DISABLED = 0x0005, + /* The RX continue packet's data index is invalid. */ + USB_SPI_RX_BAD_DATA_INDEX = 0x0006, + /* The RX endpoint has received more data than write count. */ + USB_SPI_RX_DATA_OVERFLOW = 0x0007, + /* An unexpected packet arrived on the device. */ + USB_SPI_RX_UNEXPECTED_PACKET = 0x0008, + /* The device does not support full duplex mode. */ + USB_SPI_UNSUPPORTED_FULL_DUPLEX = 0x0009, USB_SPI_UNKNOWN_ERROR = 0x8000, }; @@ -181,20 +405,16 @@ enum raiden_debug_spi_request { RAIDEN_DEBUG_SPI_REQ_ENABLE_EC = 0x0003, }; -#define PACKET_HEADER_SIZE (2) -#define USB_MAX_PACKET_SIZE (64) -#define PAYLOAD_SIZE_V1 (USB_MAX_PACKET_SIZE - PACKET_HEADER_SIZE) -#define SPI_TRANSFER_V1_MAX (PAYLOAD_SIZE_V1) - /* * Servo Micro has an error where it is capable of acknowledging USB packets * without loading it into the USB endpoint buffers or triggering interrupts. * See crbug.com/952494. Retry mechanisms have been implemented to recover * from these rare failures allowing the process to continue. */ -#define WRITE_RETRY_ATTEMPTS (3) -#define READ_RETRY_ATTEMPTS (3) -#define RETRY_INTERVAL_US (100 * 1000) +#define WRITE_RETRY_ATTEMPTS (3) +#define READ_RETRY_ATTEMPTS (3) +#define GET_CONFIG_RETRY_ATTEMPTS (3) +#define RETRY_INTERVAL_US (100 * 1000) /* * This timeout is so large because the Raiden SPI timeout is 800ms. @@ -215,6 +435,18 @@ struct raiden_debug_spi_data { uint16_t max_spi_write_count; uint16_t max_spi_read_count; }; +/* + * USB permits a maximum bulk transfer of 64B. + */ +#define USB_MAX_PACKET_SIZE (64) +#define PACKET_HEADER_SIZE (2) + +/* + * All of the USB SPI packets have size equal to the max USB packet size of 64B + */ +#define PAYLOAD_SIZE_V1 (62) + +#define SPI_TRANSFER_V1_MAX (PAYLOAD_SIZE_V1) /* * Version 1 protocol specific attributes @@ -237,10 +469,90 @@ union usb_spi_packet_v1 { struct usb_spi_response_v1 response; } __attribute__((packed)); +/* + * Version 2 protocol specific attributes + */ + +#define USB_SPI_FULL_DUPLEX_ENABLED_V2 (UINT16_MAX) + +#define USB_SPI_PAYLOAD_SIZE_V2_START (58) + +#define USB_SPI_PAYLOAD_SIZE_V2_RESPONSE (60) + +#define USB_SPI_PAYLOAD_SIZE_V2_CONTINUE (60) + +enum packet_id_type { + /* Request USB SPI configuration data from device. */ + USB_SPI_PKT_ID_CMD_GET_USB_SPI_CONFIG = 0, + /* USB SPI configuration data from device. */ + USB_SPI_PKT_ID_RSP_USB_SPI_CONFIG = 1, + /* + * Start a USB SPI transfer specifying number of bytes to write, + * read and deliver first packet of data to write. + */ + USB_SPI_PKT_ID_CMD_TRANSFER_START = 2, + /* Additional packets containing write payload. */ + USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE = 3, + /* + * Request the device restart the response enabling us to recover + * from packet loss without another SPI transfer. + */ + USB_SPI_PKT_ID_CMD_RESTART_RESPONSE = 4, + /* + * First packet of USB SPI response with the status code + * and read payload if it was successful. + */ + USB_SPI_PKT_ID_RSP_TRANSFER_START = 5, + /* Additional packets containing read payload. */ + USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE = 6, +}; + +enum feature_bitmap { + /* Indicates the platform supports full duplex mode. */ + USB_SPI_FEATURE_FULL_DUPLEX_SUPPORTED = 0x01 +}; + +struct usb_spi_response_configuration_v2 { + uint16_t packet_id; + uint16_t max_write_count; + uint16_t max_read_count; + uint16_t feature_bitmap; +} __attribute__((packed)); + +struct usb_spi_command_v2 { + uint16_t packet_id; + uint16_t write_count; + /* UINT16_MAX Indicates readback all on halfduplex compliant devices. */ + uint16_t read_count; + uint8_t data[USB_SPI_PAYLOAD_SIZE_V2_START]; +} __attribute__((packed)); + +struct usb_spi_response_v2 { + uint16_t packet_id; + uint16_t status_code; + uint8_t data[USB_SPI_PAYLOAD_SIZE_V2_RESPONSE]; +} __attribute__((packed)); + +struct usb_spi_continue_v2 { + uint16_t packet_id; + uint16_t data_index; + uint8_t data[USB_SPI_PAYLOAD_SIZE_V2_CONTINUE]; +} __attribute__((packed)); + +union usb_spi_packet_v2 { + uint16_t packet_id; + struct usb_spi_command_v2 cmd_start; + struct usb_spi_continue_v2 cmd_continue; + struct usb_spi_response_configuration_v2 rsp_config; + struct usb_spi_response_v2 rsp_start; + struct usb_spi_continue_v2 rsp_continue; +} __attribute__((packed)); + struct usb_spi_packet_ctx { union { uint8_t bytes[USB_MAX_PACKET_SIZE]; union usb_spi_packet_v1 packet_v1; + union usb_spi_packet_v2 packet_v2; }; /* * By storing the number of bytes in the header and knowing that the @@ -549,12 +861,13 @@ static int send_command_v1(const struct flashctx *flash, if (status) { /* Write operation failed. */ msg_perr("Raiden: Write command failed\n" + " protocol = %u\n" " write count = %u\n" " read count = %u\n" " transmitted bytes = %zu\n" " write attempt = %u\n" " status = 0x%05x\n", - + ctx_data->protocol_version, write_count, read_count, write_ctx.transmit_index, write_attempt + 1, status); if (!retry_recovery(status)) { @@ -564,6 +877,7 @@ static int send_command_v1(const struct flashctx *flash, programmer_delay(RETRY_INTERVAL_US); continue; } + for (unsigned int read_attempt = 0; read_attempt < READ_RETRY_ATTEMPTS; read_attempt++) { @@ -579,21 +893,356 @@ static int send_command_v1(const struct flashctx *flash, } } + /* Read operation failed. */ + msg_perr("Raiden: Read response failed\n" + " protocol = %u\n" + " write count = %u\n" + " read count = %u\n" + " received bytes = %zu\n" + " write attempt = %u\n" + " read attempt = %u\n" + " status = 0x%05x\n", + ctx_data->protocol_version, + write_count, read_count, read_ctx.receive_index, + write_attempt + 1, read_attempt + 1, status); + if (!retry_recovery(status)) { + /* Reattempting will not result in a recovery. */ + return status; + } + programmer_delay(RETRY_INTERVAL_US); + } + } + + return status; +} + +/* + * Get the USB SPI configuration with the maximum write and read counts, and + * any enabled features. + * + * @param ctx_data Raiden SPI config. + * + * @returns Returns status code with 0 on success. + */ +static int get_spi_config_v2(struct raiden_debug_spi_data *ctx_data) +{ + int status; + unsigned int config_attempt; + struct usb_spi_packet_ctx rsp_config; + + struct usb_spi_packet_ctx cmd_get_config = { + .header_size = PACKET_HEADER_SIZE, + .packet_size = PACKET_HEADER_SIZE, + .packet_v2.packet_id = USB_SPI_PKT_ID_CMD_GET_USB_SPI_CONFIG + }; + + for (config_attempt = 0; config_attempt < GET_CONFIG_RETRY_ATTEMPTS; config_attempt++) { + + status = transmit_packet(ctx_data, &cmd_get_config); + if (status) { + msg_perr("Raiden: Failed to transmit get config\n" + " config attempt = %d\n" + " status = 0x%05x\n", + config_attempt + 1, status); + programmer_delay(RETRY_INTERVAL_US); + continue; + } + + status = receive_packet(ctx_data, &rsp_config); + if (status) { + msg_perr("Raiden: Failed to receive packet\n" + " config attempt = %d\n" + " status = 0x%05x\n", + config_attempt + 1, status); + programmer_delay(RETRY_INTERVAL_US); + continue; + } + + /* + * Perform validation on the packet received to verify it is a valid + * configuration. If it is, we are ready to perform transfers. + */ + if ((rsp_config.packet_v2.packet_id == + USB_SPI_PKT_ID_RSP_USB_SPI_CONFIG) || + (rsp_config.packet_size == + sizeof(struct usb_spi_response_configuration_v2))) { + + /* Set the parameters from the configuration. */ + ctx_data->max_spi_write_count = + rsp_config.packet_v2.rsp_config.max_write_count; + ctx_data->max_spi_read_count = + rsp_config.packet_v2.rsp_config.max_read_count; + return status; + } + + msg_perr("Raiden: Packet is not a valid config\n" + " config attempt = %d\n" + " packet id = %u\n" + " packet size = %zu\n", + config_attempt + 1, + rsp_config.packet_v2.packet_id, + rsp_config.packet_size); + programmer_delay(RETRY_INTERVAL_US); + } + return USB_SPI_HOST_INIT_FAILURE; +} + +/* + * Version 2 protocol restart the SPI response. This allows us to recover from + * USB packet errors without restarting the SPI transfer. + * + * @param ctx_data Raiden SPI config. + * + * @returns Returns status code with 0 on success. + */ +static int restart_response_v2(const struct raiden_debug_spi_data *ctx_data) +{ + struct usb_spi_packet_ctx restart_response = { + .header_size = PACKET_HEADER_SIZE, + .packet_size = PACKET_HEADER_SIZE, + .packet_v2.packet_id = USB_SPI_PKT_ID_CMD_RESTART_RESPONSE + }; + + return transmit_packet(ctx_data, &restart_response); +} + +/* + * Version 2 Protocol: command to start a USB SPI transfer and write the payload. + * + * @param ctx_data Raiden SPI config. + * @param write Write context of data to transmit and write payload. + * @param read Read context of data to receive and read buffer. + * + * @returns Returns status code with 0 on success. + */ +static int write_command_v2(const struct raiden_debug_spi_data *ctx_data, + struct usb_spi_transmit_ctx *write, + struct usb_spi_receive_ctx *read) +{ + int status; + struct usb_spi_packet_ctx continue_packet; + + struct usb_spi_packet_ctx start_usb_spi_packet = { + .header_size = offsetof(struct usb_spi_command_v2, data), + .packet_v2.cmd_start.packet_id = USB_SPI_PKT_ID_CMD_TRANSFER_START, + .packet_v2.cmd_start.write_count = write->transmit_size, + .packet_v2.cmd_start.read_count = read->receive_size + }; + + /* Reset the write context to the start. */ + write->transmit_index = 0; + + fill_usb_packet(&start_usb_spi_packet, write); + status = transmit_packet(ctx_data, &start_usb_spi_packet); + if (status) { + return status; + } + + while (write->transmit_index < write->transmit_size) { + /* Transmit any continue packets. */ + continue_packet.header_size = offsetof(struct usb_spi_continue_v2, data); + continue_packet.packet_v2.cmd_continue.packet_id = + USB_SPI_PKT_ID_CMD_TRANSFER_CONTINUE; + continue_packet.packet_v2.cmd_continue.data_index = + write->transmit_index; + + fill_usb_packet(&continue_packet, write); + + status = transmit_packet(ctx_data, &continue_packet); + if (status) { + return status; + } + } + + return status; +} + +/* + * Version 2 Protocol: Command to read a USB SPI transfer response and read the payload. + * + * @param ctx_data Raiden SPI config. + * @param write Write context of data to transmit and write payload. + * @param read Read context of data to receive and read buffer. + * + * @returns Returns status code with 0 on success. + */ +static int read_response_v2(const struct raiden_debug_spi_data *ctx_data, + struct usb_spi_transmit_ctx *write, + struct usb_spi_receive_ctx *read) +{ + int status = -1; + struct usb_spi_packet_ctx response; + + /* Reset the read context to the start. */ + read->receive_index = 0; + + /* Receive the payload to the servo micro. */ + do { + status = receive_packet(ctx_data, &response); + if (status) { + /* Return the transfer error. */ + return status; + } + if (response.packet_v2.packet_id == USB_SPI_PKT_ID_RSP_TRANSFER_START) { + /* + * The host should only see this packet if an error occurs + * on the device or if it's the first response packet. + */ + if (response.packet_v2.rsp_start.status_code) { + return response.packet_v2.rsp_start.status_code; + } + if (read->receive_index) { + msg_perr("Raiden: Unexpected start packet id = %u\n", + response.packet_v2.rsp_start.packet_id); + return USB_SPI_HOST_RX_UNEXPECTED_PACKET; + } + response.header_size = offsetof(struct usb_spi_response_v2, data); + } else if (response.packet_v2.packet_id == + USB_SPI_PKT_ID_RSP_TRANSFER_CONTINUE) { + + /* We validate that no packets were missed. */ + if (read->receive_index != + response.packet_v2.rsp_continue.data_index) { + msg_perr("Raiden: Bad Index = %u Expected = %zu\n", + response.packet_v2.rsp_continue.data_index, + read->receive_index); + return USB_SPI_HOST_RX_BAD_DATA_INDEX; + } + response.header_size = offsetof(struct usb_spi_continue_v2, data); + } else { + msg_perr("Raiden: Unexpected packet id = %u\n", + response.packet_v2.packet_id); + return USB_SPI_HOST_RX_UNEXPECTED_PACKET; + } + status = read_usb_packet(read, &response); + if (status) { + return status; + } + } while (read->receive_index < read->receive_size); + + return status; +} + +/* + * Version 2 Protocol: Sets up a USB SPI transfer, transmits data to the device, + * reads the status code and any payload from the device. This will also handle + * recovery if an error has occurred. + * + * In order to avoid having the v2 protocol held back by requiring + * backwards compatibility with v1 we are duplicating the send_command + * function. This will allow the 2 versions to diverge in the future + * so fixes in one do not need to be compatible with the legacy. + * + * @param flash Flash context storing SPI capabilities and USB device + * information. + * @param write_count Number of bytes to write + * @param read_count Number of bytes to read + * @param write_buffer Address of write buffer + * @param read_buffer Address of buffer to store read data + * + * @returns Returns status code with 0 on success. + */ +static int send_command_v2(const struct flashctx *flash, + unsigned int write_count, + unsigned int read_count, + const unsigned char *write_buffer, + unsigned char *read_buffer) +{ + const struct raiden_debug_spi_data *ctx_data = + get_raiden_data_from_context(flash); + int status = -1; + unsigned int write_attempt; + unsigned int read_attempt; + + struct usb_spi_transmit_ctx write_ctx = { + .buffer = write_buffer, + .transmit_size = write_count + }; + struct usb_spi_receive_ctx read_ctx = { + .buffer = read_buffer, + .receive_size = read_count + }; + + if (write_count > ctx_data->max_spi_write_count) { + msg_perr("Raiden: Invalid write count\n" + " write count = %u\n" + " max write = %u\n", + write_count, ctx_data->max_spi_write_count); + return SPI_INVALID_LENGTH; + } + + if (read_count > ctx_data->max_spi_read_count) { + msg_perr("Raiden: Invalid read count\n" + " read count = %u\n" + " max read = %u\n", + read_count, ctx_data->max_spi_read_count); + return SPI_INVALID_LENGTH; + } + + for (write_attempt = 0; write_attempt < WRITE_RETRY_ATTEMPTS; + write_attempt++) { + + status = write_command_v2(ctx_data, &write_ctx, &read_ctx); + + if (!status && + (write_ctx.transmit_index != write_ctx.transmit_size)) { + /* No errors were reported, but write is incomplete. */ + status = USB_SPI_HOST_TX_WRITE_FAILURE; + } + + if (status) { + /* Write operation failed. */ + msg_perr("Raiden: Write command failed\n" + " protocol = %u\n" + " write count = %u\n" + " read count = %u\n" + " transmitted bytes = %zu\n" + " write attempt = %u\n" + " status = 0x%05x\n", + ctx_data->protocol_version, + write_count, read_count, write_ctx.transmit_index, + write_attempt + 1, status); + if (!retry_recovery(status)) { + /* Reattempting will not result in a recovery. */ + return status; + } + programmer_delay(RETRY_INTERVAL_US); + continue; + } + for (read_attempt = 0; read_attempt < READ_RETRY_ATTEMPTS; + read_attempt++) { + + status = read_response_v2(ctx_data, &write_ctx, &read_ctx); + + if (!status) { + if (read_ctx.receive_size == read_ctx.receive_index) { + /* Successful transfer. */ + return status; + } else { + /* Report the error from the failed read. */ + status = USB_SPI_HOST_RX_READ_FAILURE; + } + } + if (status) { /* Read operation failed. */ msg_perr("Raiden: Read response failed\n" + " protocol = %u\n" " write count = %u\n" " read count = %u\n" " received bytes = %zu\n" " write attempt = %u\n" " read attempt = %u\n" " status = 0x%05x\n", + ctx_data->protocol_version, write_count, read_count, read_ctx.receive_index, write_attempt + 1, read_attempt + 1, status); if (!retry_recovery(status)) { /* Reattempting will not result in a recovery. */ return status; } + /* Device needs to reset its transmit index. */ + restart_response_v2(ctx_data); programmer_delay(RETRY_INTERVAL_US); } } @@ -666,6 +1315,7 @@ static int find_endpoints(struct usb_device *dev, uint8_t *in_ep, uint8_t *out_e */ static int configure_protocol(struct spi_master *spi_config) { + int status = 0; struct raiden_debug_spi_data *ctx_data = (struct raiden_debug_spi_data *)spi_config->data; @@ -682,9 +1332,20 @@ static int configure_protocol(struct spi_master *spi_config) ctx_data->max_spi_write_count = SPI_TRANSFER_V1_MAX; ctx_data->max_spi_read_count = SPI_TRANSFER_V1_MAX; break; + case GOOGLE_RAIDEN_SPI_PROTOCOL_V2: + /* + * Protocol V2 requires the host to query the device for + * its maximum read and write sizes + */ + spi_config->command = send_command_v2; + status = get_spi_config_v2(ctx_data); + if (status) { + return status; + } + break; default: - msg_pdbg("Raiden: Unknown USB SPI protocol version = %d", - ctx_data->protocol_version); + msg_pdbg("Raiden: Unknown USB SPI protocol version = %u\n", + ctx_data->protocol_version); return USB_SPI_HOST_INIT_FAILURE; } @@ -788,7 +1449,6 @@ int raiden_debug_spi_init(void) usb_match_value_default(&match.vid, GOOGLE_VID); usb_match_value_default(&match.class, LIBUSB_CLASS_VENDOR_SPEC); usb_match_value_default(&match.subclass, GOOGLE_RAIDEN_SPI_SUBCLASS); - usb_match_value_default(&match.protocol, GOOGLE_RAIDEN_SPI_PROTOCOL_V1); ret = LIBUSB(libusb_init(NULL)); if (ret != 0) { |