X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Frlink.c;h=d0b18b1ba94b0013c9ce4d29c6df859e7f8959f1;hp=a3fad358e37f56678564b052dada93dd1ed7731a;hb=5812ef2b73db2f513f9c42d6cf4b695268d04d69;hpb=740b9e25b410c164e661d0334a9ea4168406726b diff --git a/src/jtag/drivers/rlink.c b/src/jtag/drivers/rlink.c index a3fad358e3..d0b18b1ba9 100644 --- a/src/jtag/drivers/rlink.c +++ b/src/jtag/drivers/rlink.c @@ -110,9 +110,9 @@ static usb_dev_handle *pHDev; static int ep1_generic_commandl( - usb_dev_handle *pHDev_param, - size_t length, - ... + usb_dev_handle *pHDev_param, + size_t length, + ... ) { uint8_t usb_buffer[USB_EP1OUT_SIZE]; uint8_t *usb_buffer_p; @@ -132,17 +132,17 @@ ep1_generic_commandl( } memset( - usb_buffer_p, - 0, - sizeof(usb_buffer) - (usb_buffer_p - usb_buffer) -); + usb_buffer_p, + 0, + sizeof(usb_buffer) - (usb_buffer_p - usb_buffer) + ); usb_ret = usb_bulk_write( - pHDev_param, - USB_EP1OUT_ADDR, - (char *)usb_buffer, sizeof(usb_buffer), - USB_TIMEOUT_MS -); + pHDev_param, + USB_EP1OUT_ADDR, + (char *)usb_buffer, sizeof(usb_buffer), + USB_TIMEOUT_MS + ); return(usb_ret); } @@ -153,10 +153,10 @@ ep1_generic_commandl( static ssize_t ep1_memory_read( - usb_dev_handle *pHDev, - uint16_t addr, - size_t length, - uint8_t *buffer + usb_dev_handle *pHDev, + uint16_t addr, + size_t length, + uint8_t *buffer ) { uint8_t usb_buffer[USB_EP1OUT_SIZE]; int usb_ret; @@ -165,10 +165,10 @@ ep1_memory_read( usb_buffer[0] = EP1_CMD_MEMORY_READ; memset( - usb_buffer + 4, - 0, - sizeof(usb_buffer) - 4 -); + usb_buffer + 4, + 0, + sizeof(usb_buffer) - 4 + ); remain = length; count = 0; @@ -184,21 +184,21 @@ ep1_memory_read( usb_buffer[2] = addr; usb_buffer[3] = length; - usb_ret = usb_bulk_write( - pHDev, USB_EP1OUT_ADDR, - usb_buffer, sizeof(usb_buffer), - USB_TIMEOUT_MS -); + usb_ret = usb_bulk_write( + pHDev, USB_EP1OUT_ADDR, + usb_buffer, sizeof(usb_buffer), + USB_TIMEOUT_MS + ); if (usb_ret < sizeof(usb_buffer)) { break; } usb_ret = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - buffer, length, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + buffer, length, + USB_TIMEOUT_MS + ); if (usb_ret < length) { break; @@ -219,10 +219,10 @@ ep1_memory_read( static ssize_t ep1_memory_write( - usb_dev_handle *pHDev_param, - uint16_t addr, - size_t length, - uint8_t const *buffer + usb_dev_handle *pHDev_param, + uint16_t addr, + size_t length, + uint8_t const *buffer ) { uint8_t usb_buffer[USB_EP1OUT_SIZE]; int usb_ret; @@ -245,21 +245,21 @@ ep1_memory_write( usb_buffer[2] = addr; usb_buffer[3] = length; memcpy( - usb_buffer + 4, - buffer, - length -); + usb_buffer + 4, + buffer, + length + ); memset( - usb_buffer + 4 + length, - 0, - sizeof(usb_buffer) - 4 - length -); + usb_buffer + 4 + length, + 0, + sizeof(usb_buffer) - 4 - length + ); - usb_ret = usb_bulk_write( - pHDev_param, USB_EP1OUT_ADDR, - (char *)usb_buffer, sizeof(usb_buffer), - USB_TIMEOUT_MS -); + usb_ret = usb_bulk_write( + pHDev_param, USB_EP1OUT_ADDR, + (char *)usb_buffer, sizeof(usb_buffer), + USB_TIMEOUT_MS + ); if ((size_t)usb_ret < sizeof(usb_buffer)) { break; @@ -279,10 +279,10 @@ ep1_memory_write( static ssize_t ep1_memory_writel( - usb_dev_handle *pHDev, - uint16_t addr, - size_t length, - ... + usb_dev_handle *pHDev, + uint16_t addr, + size_t length, + ... ) { uint8_t buffer[USB_EP1OUT_SIZE - 4]; uint8_t *buffer_p; @@ -324,9 +324,9 @@ static uint8_t dtc_entry_download; static int dtc_load_from_buffer( - usb_dev_handle *pHDev_param, - const uint8_t *buffer, - size_t length + usb_dev_handle *pHDev_param, + const uint8_t *buffer, + size_t length ) { struct header_s { uint8_t type; @@ -341,14 +341,14 @@ dtc_load_from_buffer( /* Stop the DTC before loading anything. */ usb_err = ep1_generic_commandl( - pHDev_param, 1, - EP1_CMD_DTC_STOP -); + pHDev_param, 1, + EP1_CMD_DTC_STOP + ); if (usb_err < 0) return(usb_err); while (length) { if (length < sizeof(*header)) { - LOG_ERROR("Malformed DTC image\n"); + LOG_ERROR("Malformed DTC image"); exit(1); } @@ -357,69 +357,69 @@ dtc_load_from_buffer( length -= sizeof(*header); if (length < (size_t)header->length + 1) { - LOG_ERROR("Malformed DTC image\n"); + LOG_ERROR("Malformed DTC image"); exit(1); } switch (header->type) { - case DTCLOAD_COMMENT: - break; + case DTCLOAD_COMMENT: + break; - case DTCLOAD_ENTRY: - /* store entry addresses somewhere */ - if (!strncmp("download", (char *)buffer + 1, 8)) { - dtc_entry_download = buffer[0]; - } - break; + case DTCLOAD_ENTRY: + /* store entry addresses somewhere */ + if (!strncmp("download", (char *)buffer + 1, 8)) { + dtc_entry_download = buffer[0]; + } + break; - case DTCLOAD_LOAD: - /* Send the DTC program to ST7 RAM. */ - usb_err = ep1_memory_write( + case DTCLOAD_LOAD: + /* Send the DTC program to ST7 RAM. */ + usb_err = ep1_memory_write( pHDev_param, DTC_LOAD_BUFFER, header->length + 1, buffer -); - if (usb_err < 0) return(usb_err); + ); + if (usb_err < 0) return(usb_err); - /* Load it into the DTC. */ - usb_err = ep1_generic_commandl( + /* Load it into the DTC. */ + usb_err = ep1_generic_commandl( pHDev_param, 3, EP1_CMD_DTC_LOAD, - (DTC_LOAD_BUFFER >> 8), - DTC_LOAD_BUFFER -); - if (usb_err < 0) return(usb_err); + (DTC_LOAD_BUFFER >> 8), + DTC_LOAD_BUFFER + ); + if (usb_err < 0) return(usb_err); - break; + break; - case DTCLOAD_RUN: - usb_err = ep1_generic_commandl( + case DTCLOAD_RUN: + usb_err = ep1_generic_commandl( pHDev_param, 3, EP1_CMD_DTC_CALL, - buffer[0], + buffer[0], EP1_CMD_DTC_WAIT -); - if (usb_err < 0) return(usb_err); + ); + if (usb_err < 0) return(usb_err); - break; + break; - case DTCLOAD_LUT_START: - lut_start = buffer[0]; - break; + case DTCLOAD_LUT_START: + lut_start = buffer[0]; + break; - case DTCLOAD_LUT: - usb_err = ep1_memory_write( + case DTCLOAD_LUT: + usb_err = ep1_memory_write( pHDev_param, ST7_USB_BUF_EP0OUT + lut_start, header->length + 1, buffer -); - if (usb_err < 0) return(usb_err); - break; + ); + if (usb_err < 0) return(usb_err); + break; - default: - LOG_ERROR("Invalid DTC image record type: 0x%02x\n", header->type); - exit(1); - break; + default: + LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type); + exit(1); + break; } buffer += (header->length + 1); @@ -441,51 +441,51 @@ dtc_start_download(void) { /* set up for download mode and make sure EP2 is set up to transmit */ usb_err = ep1_generic_commandl( - pHDev, 7, + pHDev, 7, - EP1_CMD_DTC_STOP, - EP1_CMD_SET_UPLOAD, - EP1_CMD_SET_DOWNLOAD, - EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */ + EP1_CMD_DTC_STOP, + EP1_CMD_SET_UPLOAD, + EP1_CMD_SET_DOWNLOAD, + EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */ ST7_EP2TXR >> 8, ST7_EP2TXR, 1 -); + ); if (usb_err < 0) return(usb_err); /* read back ep2txr */ usb_err = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)&ep2txr, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)&ep2txr, 1, + USB_TIMEOUT_MS + ); if (usb_err < 0) return(usb_err); usb_err = ep1_generic_commandl( - pHDev, 13, + pHDev, 13, - EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */ + EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */ DTC_STATUS_POLL_BYTE >> 8, DTC_STATUS_POLL_BYTE, 1, 0x00, - EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */ + EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */ ST7_EP2TXR >> 8, ST7_EP2TXR, 1, (ep2txr & ST7_EP2TXR_DTOG_TX) | ST7_EP2TXR_STAT_VALID, - EP1_CMD_DTC_CALL, /* start running the DTC */ + EP1_CMD_DTC_CALL, /* start running the DTC */ dtc_entry_download, - EP1_CMD_DTC_GET_CACHED_STATUS -); + EP1_CMD_DTC_GET_CACHED_STATUS + ); if (usb_err < 0) return(usb_err); /* wait for completion */ usb_err = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)&ep2txr, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)&ep2txr, 1, + USB_TIMEOUT_MS + ); return(usb_err); } @@ -494,53 +494,53 @@ dtc_start_download(void) { static int dtc_run_download( - usb_dev_handle *pHDev_param, - uint8_t *command_buffer, - int command_buffer_size, - uint8_t *reply_buffer, - int reply_buffer_size + usb_dev_handle *pHDev_param, + uint8_t *command_buffer, + int command_buffer_size, + uint8_t *reply_buffer, + int reply_buffer_size ) { uint8_t ep2_buffer[USB_EP2IN_SIZE]; int usb_err; int i; - LOG_DEBUG(": %d/%d\n", command_buffer_size, reply_buffer_size); + LOG_DEBUG(": %d/%d", command_buffer_size, reply_buffer_size); usb_err = usb_bulk_write( - pHDev_param, - USB_EP2OUT_ADDR, - (char *)command_buffer, USB_EP2BANK_SIZE, - USB_TIMEOUT_MS -); + pHDev_param, + USB_EP2OUT_ADDR, + (char *)command_buffer, USB_EP2BANK_SIZE, + USB_TIMEOUT_MS + ); if (usb_err < 0) return(usb_err); /* Wait for DTC to finish running command buffer */ for (i = 10;;) { usb_err = ep1_generic_commandl( - pHDev_param, 4, + pHDev_param, 4, - EP1_CMD_MEMORY_READ, + EP1_CMD_MEMORY_READ, DTC_STATUS_POLL_BYTE >> 8, DTC_STATUS_POLL_BYTE, 1 -); + ); if (usb_err < 0) return(usb_err); usb_err = usb_bulk_read( - pHDev_param, - USB_EP1IN_ADDR, - (char *)ep2_buffer, 1, - USB_TIMEOUT_MS -); + pHDev_param, + USB_EP1IN_ADDR, + (char *)ep2_buffer, 1, + USB_TIMEOUT_MS + ); if (usb_err < 0) return(usb_err); if (ep2_buffer[0] & 0x01) break; if (!--i) { - LOG_ERROR("%s, %d: too many retries waiting for DTC status\n", - __FILE__, __LINE__ -); + LOG_ERROR("%s, %d: too many retries waiting for DTC status", + __FILE__, __LINE__ + ); return(-ETIMEDOUT); } } @@ -549,16 +549,16 @@ dtc_run_download( if (!reply_buffer) reply_buffer_size = 0; if (reply_buffer_size) { usb_err = usb_bulk_read( - pHDev_param, - USB_EP2IN_ADDR, - (char *)ep2_buffer, sizeof(ep2_buffer), - USB_TIMEOUT_MS -); + pHDev_param, + USB_EP2IN_ADDR, + (char *)ep2_buffer, sizeof(ep2_buffer), + USB_TIMEOUT_MS + ); if (usb_err < (int)sizeof(ep2_buffer)) { - LOG_ERROR("%s, %d: Read of endpoint 2 returned %d\n", - __FILE__, __LINE__, usb_err -); + LOG_ERROR("%s, %d: Read of endpoint 2 returned %d", + __FILE__, __LINE__, usb_err + ); return(usb_err); } @@ -630,12 +630,12 @@ static inline struct dtc_reply_queue_entry * dtc_queue_enqueue_reply( - enum scan_type type, - uint8_t *buffer, - int size, - int offset, - int length, - struct jtag_command *cmd + enum scan_type type, + uint8_t *buffer, + int size, + int offset, + int length, + struct jtag_command *cmd ) { struct dtc_reply_queue_entry *rq_entry; @@ -664,7 +664,7 @@ dtc_queue_enqueue_reply( /* * Running the queue means that any pending command buffer is run and any reply data dealt with. The command buffer is then cleared for subsequent processing. * The queue is automatically run by append when it is necessary to get space for the append. -*/ + */ static int @@ -678,6 +678,10 @@ dtc_queue_run(void) { uint8_t dtc_mask, tdo_mask; uint8_t reply_buffer[USB_EP2IN_SIZE]; + assert((dtc_queue.rq_head != 0) == (dtc_queue.reply_index > 0)); + assert(dtc_queue.cmd_index < USB_EP2BANK_SIZE); + assert(dtc_queue.reply_index <= USB_EP2IN_SIZE); + retval = ERROR_OK; if (dtc_queue.cmd_index < 1) return(retval); @@ -687,117 +691,116 @@ dtc_queue_run(void) { /* run the cmd */ if (dtc_queue.rq_head == NULL) { usb_err = dtc_run_download(pHDev, - dtc_queue.cmd_buffer, dtc_queue.cmd_index, - NULL, 0 -); + dtc_queue.cmd_buffer, dtc_queue.cmd_index, + NULL, 0 + ); if (usb_err < 0) { - LOG_ERROR("dtc_run_download: %s\n", usb_strerror()); + LOG_ERROR("dtc_run_download: %s", usb_strerror()); exit(1); } } else { usb_err = dtc_run_download(pHDev, - dtc_queue.cmd_buffer, dtc_queue.cmd_index, - reply_buffer, dtc_queue.reply_index -); + dtc_queue.cmd_buffer, dtc_queue.cmd_index, + reply_buffer, dtc_queue.reply_index + ); if (usb_err < 0) { - LOG_ERROR("dtc_run_download: %s\n", usb_strerror()); + LOG_ERROR("dtc_run_download: %s", usb_strerror()); exit(1); - } else { - /* process the reply, which empties the reply queue and frees its entries */ - dtc_p = reply_buffer; + } + + /* process the reply, which empties the reply queue and frees its entries */ + dtc_p = reply_buffer; - /* The rigamarole with the masks and doing it bit-by-bit is due to the fact that the scan buffer is LSb-first and the DTC code is MSb-first for hardware reasons. It was that or craft a function to do the reversal, and that wouldn't work with bit-stuffing (supplying extra bits to use mostly byte operations), or any other scheme which would throw the byte alignment off. */ + /* The rigamarole with the masks and doing it bit-by-bit is due to the fact that the scan buffer is LSb-first and the DTC code is MSb-first for hardware reasons. It was that or craft a function to do the reversal, and that wouldn't work with bit-stuffing (supplying extra bits to use mostly byte operations), or any other scheme which would throw the byte alignment off. */ - for ( + for ( rq_p = dtc_queue.rq_head; rq_p != NULL; rq_p = rq_next -) { - tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8); - tdo_mask = 1 << (rq_p->scan.offset % 8); + ) { + tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8); + tdo_mask = 1 << (rq_p->scan.offset % 8); - bit_cnt = rq_p->scan.length; - if (bit_cnt >= 8) { - /* bytes */ + bit_cnt = rq_p->scan.length; + if (bit_cnt >= 8) { + /* bytes */ - dtc_mask = 1 << (8 - 1); + dtc_mask = 1 << (8 - 1); - for ( + for ( ; bit_cnt; bit_cnt-- -) { - if (*dtc_p & dtc_mask) { - *tdo_p |= tdo_mask; - } else { - *tdo_p &=~ tdo_mask; - } - - dtc_mask >>= 1; - if (dtc_mask == 0) { - dtc_p++; - dtc_mask = 1 << (8 - 1); - } - - tdo_mask <<= 1; - if (tdo_mask == 0) { - tdo_p++; - tdo_mask = 1; - } + ) { + if (*dtc_p & dtc_mask) { + *tdo_p |= tdo_mask; + } else { + *tdo_p &=~ tdo_mask; } - } else { - /* extra bits or last bit */ - x = *dtc_p++; - if (( - rq_p->scan.type == SCAN_IN -) && ( - rq_p->scan.offset != rq_p->scan.size - 1 -)) { - /* extra bits were sent as a full byte with padding on the end */ + dtc_mask >>= 1; + if (dtc_mask == 0) { + dtc_p++; dtc_mask = 1 << (8 - 1); - } else { - dtc_mask = 1 << (bit_cnt - 1); } - for ( + tdo_mask <<= 1; + if (tdo_mask == 0) { + tdo_p++; + tdo_mask = 1; + } + } + } else { + /* extra bits or last bit */ + + x = *dtc_p++; + if (( + rq_p->scan.type == SCAN_IN + ) && ( + rq_p->scan.offset != rq_p->scan.size - 1 + )) { + /* extra bits were sent as a full byte with padding on the end */ + dtc_mask = 1 << (8 - 1); + } else { + dtc_mask = 1 << (bit_cnt - 1); + } + + for ( ; bit_cnt; bit_cnt-- -) { - if (x & dtc_mask) { - *tdo_p |= tdo_mask; - } else { - *tdo_p &=~ tdo_mask; - } - - dtc_mask >>= 1; + ) { + if (x & dtc_mask) { + *tdo_p |= tdo_mask; + } else { + *tdo_p &=~ tdo_mask; + } - tdo_mask <<= 1; - if (tdo_mask == 0) { - tdo_p++; - tdo_mask = 1; - } + dtc_mask >>= 1; + tdo_mask <<= 1; + if (tdo_mask == 0) { + tdo_p++; + tdo_mask = 1; } - } - if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) { - /* feed scan buffer back into openocd and free it */ - if (jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) { - retval = ERROR_JTAG_QUEUE_FAILED; - } - free(rq_p->scan.buffer); } + } - rq_next = rq_p->next; - free(rq_p); + if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) { + /* feed scan buffer back into openocd and free it */ + if (jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) { + retval = ERROR_JTAG_QUEUE_FAILED; + } + free(rq_p->scan.buffer); } - dtc_queue.rq_head = NULL; - dtc_queue.rq_tail = NULL; - } + rq_next = rq_p->next; + free(rq_p); + } + dtc_queue.rq_head = NULL; + dtc_queue.rq_tail = NULL; } @@ -808,8 +811,6 @@ dtc_queue_run(void) { return(retval); } - - static int tap_state_queue_init(void) { @@ -843,24 +844,24 @@ tap_state_queue_run(void) { /* make sure there's room for stop, byte op, and one byte */ if (dtc_queue.cmd_index >= (sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))) { dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_STOP; + DTC_CMD_STOP; dtc_queue_run(); } #ifdef USE_HARDWARE_SHIFTER_FOR_TMS if (bits == 8) { dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TMS_BYTES(1); + DTC_CMD_SHIFT_TMS_BYTES(1); } else { #endif dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TMS_BITS(bits); + DTC_CMD_SHIFT_TMS_BITS(bits); #ifdef USE_HARDWARE_SHIFTER_FOR_TMS } #endif dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - byte_param; + byte_param; byte_param = 0; bits = 1; @@ -878,7 +879,7 @@ tap_state_queue_run(void) { static int tap_state_queue_append( - uint8_t tms + uint8_t tms ) { int retval; @@ -996,22 +997,22 @@ void rlink_reset(int trst, int srst) /* Read port A for bit op */ usb_err = ep1_generic_commandl( - pHDev, 4, - EP1_CMD_MEMORY_READ, + pHDev, 4, + EP1_CMD_MEMORY_READ, ST7_PADR >> 8, ST7_PADR, 1 -); + ); if (usb_err < 0) { LOG_ERROR("%s", usb_strerror()); exit(1); } usb_err = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)&bitmap, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)&bitmap, 1, + USB_TIMEOUT_MS + ); if (usb_err < 1) { LOG_ERROR("%s", usb_strerror()); exit(1); @@ -1026,27 +1027,27 @@ void rlink_reset(int trst, int srst) /* Write port A and read port B for bit op */ /* port B has no OR, and we want to emulate open drain on NSRST, so we initialize DR to 0 and assert NSRST by setting DDR to 1. */ usb_err = ep1_generic_commandl( - pHDev, 9, - EP1_CMD_MEMORY_WRITE, + pHDev, 9, + EP1_CMD_MEMORY_WRITE, ST7_PADR >> 8, ST7_PADR, 1, - bitmap, - EP1_CMD_MEMORY_READ, + bitmap, + EP1_CMD_MEMORY_READ, ST7_PBDDR >> 8, ST7_PBDDR, 1 -); + ); if (usb_err < 0) { LOG_ERROR("%s", usb_strerror()); exit(1); } usb_err = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)&bitmap, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)&bitmap, 1, + USB_TIMEOUT_MS + ); if (usb_err < 1) { LOG_ERROR("%s", usb_strerror()); exit(1); @@ -1060,24 +1061,24 @@ void rlink_reset(int trst, int srst) /* write port B and read dummy to ensure completion before returning */ usb_err = ep1_generic_commandl( - pHDev, 6, - EP1_CMD_MEMORY_WRITE, + pHDev, 6, + EP1_CMD_MEMORY_WRITE, ST7_PBDDR >> 8, ST7_PBDDR, 1, bitmap, - EP1_CMD_DTC_GET_CACHED_STATUS -); + EP1_CMD_DTC_GET_CACHED_STATUS + ); if (usb_err < 0) { LOG_ERROR("%s", usb_strerror()); exit(1); } usb_err = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)&bitmap, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)&bitmap, 1, + USB_TIMEOUT_MS + ); if (usb_err < 1) { LOG_ERROR("%s", usb_strerror()); exit(1); @@ -1088,10 +1089,10 @@ void rlink_reset(int trst, int srst) static int rlink_scan( - struct jtag_command *cmd, - enum scan_type type, - uint8_t *buffer, - int scan_size + struct jtag_command *cmd, + enum scan_type type, + uint8_t *buffer, + int scan_size ) { bool ir_scan; tap_state_t saved_end_state; @@ -1106,7 +1107,7 @@ rlink_scan( uint8_t dtc_mask; if (scan_size < 1) { - LOG_ERROR("scan_size cannot be less than 1 bit\n"); + LOG_ERROR("scan_size cannot be less than 1 bit"); exit(1); } @@ -1114,10 +1115,10 @@ rlink_scan( /* Move to the proper state before starting to shift TDI/TDO. */ if (!( - (!ir_scan && (tap_get_state() == TAP_DRSHIFT)) - || - (ir_scan && (tap_get_state() == TAP_IRSHIFT)) -)) { + (!ir_scan && (tap_get_state() == TAP_DRSHIFT)) + || + (ir_scan && (tap_get_state() == TAP_IRSHIFT)) + )) { saved_end_state = tap_get_end_state(); rlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); rlink_state_move(); @@ -1158,8 +1159,8 @@ rlink_scan( /* For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will fall off the end */ /* make sure there's room for stop, byte op, and one byte */ if ( - (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1)) -) { + (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1)) + ) { dtc_queue_run(); } @@ -1181,7 +1182,7 @@ rlink_scan( } dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TDI_BYTES(1); + DTC_CMD_SHIFT_TDI_BYTES(1); dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x; } @@ -1226,13 +1227,14 @@ rlink_scan( if (type != SCAN_OUT) { if (dtc_queue_enqueue_reply( - type, buffer, scan_size, tdi_bit_offset, - chunk_bits, - cmd -) == NULL) { - LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); + type, buffer, scan_size, tdi_bit_offset, + chunk_bits, + cmd + ) == NULL) { + LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno)); exit(1); } + dtc_queue.reply_index += (chunk_bits + 7) / 8; tdi_bit_offset += chunk_bits; } @@ -1241,15 +1243,15 @@ rlink_scan( chunk_bytes = chunk_bits / 8; switch (type) { - case SCAN_IN: - x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes); - break; - case SCAN_OUT: - x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes); - break; - default: - x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes); - break; + case SCAN_IN: + x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes); + break; + case SCAN_OUT: + x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes); + break; + default: + x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes); + break; } dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x; @@ -1265,7 +1267,6 @@ rlink_scan( dtc_mask >>= 1; if (dtc_mask == 0) { dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x; - dtc_queue.reply_index++; x = 0; dtc_mask = 1 << (8 - 1); } @@ -1283,31 +1284,33 @@ rlink_scan( /* Schedule any extra bits into the DTC command buffer */ /* make sure there's room for stop, byte op, and one byte */ if ( - (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1)) - || - (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1)) -) { + (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1)) + || + (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1)) + ) { dtc_queue_run(); } if (dtc_queue_enqueue_reply( - type, buffer, scan_size, tdi_bit_offset, - extra_bits, - cmd -) == NULL) { - LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); + type, buffer, scan_size, tdi_bit_offset, + extra_bits, + cmd + ) == NULL) { + LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno)); exit(1); } + dtc_queue.reply_index++; + tdi_bit_offset += extra_bits; if (type == SCAN_IN) { dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TDO_BYTES(1); + DTC_CMD_SHIFT_TDO_BYTES(1); } else { dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TDIO_BITS(extra_bits); + DTC_CMD_SHIFT_TDIO_BITS(extra_bits); x = 0; dtc_mask = 1 << (8 - 1); @@ -1328,40 +1331,36 @@ rlink_scan( dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x; } - - dtc_queue.reply_index++; } /* Schedule the last bit into the DTC command buffer */ - { - /* make sure there's room for stop, and bit pair command */ - if ( + /* make sure there's room for stop, and bit pair command */ + if ( (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1)) || (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1)) -) { - dtc_queue_run(); - } + ) { + dtc_queue_run(); + } - if (type == SCAN_OUT) { - dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = + if (type == SCAN_OUT) { + dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0); - } else { - if (dtc_queue_enqueue_reply( + } else { + if (dtc_queue_enqueue_reply( type, buffer, scan_size, tdi_bit_offset, 1, cmd -) == NULL) { - LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno)); - exit(1); - } + ) == NULL) { + LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno)); + exit(1); + } - dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = - DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1); + dtc_queue.reply_index++; - dtc_queue.reply_index++; - } + dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = + DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1); } /* Move to pause state */ @@ -1388,83 +1387,83 @@ int rlink_execute_queue(void) #ifndef AUTOMATIC_BUSY_LED /* turn LED on */ ep1_generic_commandl(pHDev, 2, - EP1_CMD_SET_PORTD_LEDS, - ~(ST7_PD_NBUSY_LED) -); + EP1_CMD_SET_PORTD_LEDS, + ~(ST7_PD_NBUSY_LED) + ); #endif while (cmd) { switch (cmd->type) { - case JTAG_RUNTEST: - case JTAG_TLR_RESET: - case JTAG_PATHMOVE: - case JTAG_SCAN: - break; - - default: - /* some events, such as resets, need a queue flush to ensure consistency */ - tap_state_queue_run(); - dtc_queue_run(); - break; + case JTAG_RUNTEST: + case JTAG_TLR_RESET: + case JTAG_PATHMOVE: + case JTAG_SCAN: + break; + + default: + /* some events, such as resets, need a queue flush to ensure consistency */ + tap_state_queue_run(); + dtc_queue_run(); + break; } switch (cmd->type) { - case JTAG_RESET: + case JTAG_RESET: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); + LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); #endif - if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) - { - tap_set_state(TAP_RESET); - } - rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); - break; - case JTAG_RUNTEST: + if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) + { + tap_set_state(TAP_RESET); + } + rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + break; + case JTAG_RUNTEST: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); + LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); #endif - if (cmd->cmd.runtest->end_state != -1) - rlink_end_state(cmd->cmd.runtest->end_state); - rlink_runtest(cmd->cmd.runtest->num_cycles); - break; - case JTAG_TLR_RESET: + if (cmd->cmd.runtest->end_state != -1) + rlink_end_state(cmd->cmd.runtest->end_state); + rlink_runtest(cmd->cmd.runtest->num_cycles); + break; + case JTAG_TLR_RESET: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); + LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); #endif - if (cmd->cmd.statemove->end_state != -1) - rlink_end_state(cmd->cmd.statemove->end_state); - rlink_state_move(); - break; - case JTAG_PATHMOVE: + if (cmd->cmd.statemove->end_state != -1) + rlink_end_state(cmd->cmd.statemove->end_state); + rlink_state_move(); + break; + case JTAG_PATHMOVE: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); + LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); #endif - rlink_path_move(cmd->cmd.pathmove); - break; - case JTAG_SCAN: + rlink_path_move(cmd->cmd.pathmove); + break; + case JTAG_SCAN: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state); + LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state); #endif - if (cmd->cmd.scan->end_state != -1) - rlink_end_state(cmd->cmd.scan->end_state); - scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); - type = jtag_scan_type(cmd->cmd.scan); - if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) { - retval = ERROR_FAIL; - } - break; - case JTAG_SLEEP: + if (cmd->cmd.scan->end_state != -1) + rlink_end_state(cmd->cmd.scan->end_state); + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); + type = jtag_scan_type(cmd->cmd.scan); + if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) { + retval = ERROR_FAIL; + } + break; + case JTAG_SLEEP: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); #endif - jtag_sleep(cmd->cmd.sleep->us); - break; - default: - LOG_ERROR("BUG: unknown JTAG command type encountered"); - exit(-1); + jtag_sleep(cmd->cmd.sleep->us); + break; + default: + LOG_ERROR("BUG: unknown JTAG command type encountered"); + exit(-1); } cmd = cmd->next; } @@ -1479,9 +1478,9 @@ int rlink_execute_queue(void) #ifndef AUTOMATIC_BUSY_LED /* turn LED onff */ ep1_generic_commandl(pHDev, 2, - EP1_CMD_SET_PORTD_LEDS, - ~0 -); + EP1_CMD_SET_PORTD_LEDS, + ~0 + ); #endif return retval; @@ -1503,15 +1502,15 @@ int rlink_speed(int speed) for (i = rlink_speed_table_size; i--;) { if (rlink_speed_table[i].prescaler == speed) { if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) { - LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".\n", speed); + LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".", speed); exit(1); } if (dtc_start_download() < 0) { LOG_ERROR("%s, %d: starting DTC: %s", - __FILE__, __LINE__, - usb_strerror() -); + __FILE__, __LINE__, + usb_strerror() + ); exit(1); } @@ -1526,8 +1525,8 @@ int rlink_speed(int speed) static int rlink_speed_div( - int speed, - int *khz + int speed, + int *khz ) { int i; @@ -1545,8 +1544,8 @@ int rlink_speed_div( static int rlink_khz( - int khz, - int *speed + int khz, + int *speed ) { int i; @@ -1583,16 +1582,16 @@ int rlink_init(void) struct usb_device *dev = usb_device(pHDev); if (dev->descriptor.bNumConfigurations > 1) { - LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...\n"); + LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do..."); return ERROR_FAIL; } if (dev->config->bNumInterfaces > 1) { - LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...\n"); + LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do..."); return ERROR_FAIL; } - LOG_DEBUG("Opened device, pHDev = %p\n", pHDev); + LOG_DEBUG("Opened device, pHDev = %p", pHDev); /* usb_set_configuration required under win32 */ usb_set_configuration(pHDev, dev->config[0].bConfigurationValue); @@ -1612,7 +1611,7 @@ int rlink_init(void) } else { - LOG_DEBUG("interface claimed!\n"); + LOG_DEBUG("interface claimed!"); break; } } while (--retries); @@ -1624,7 +1623,7 @@ int rlink_init(void) } if (usb_set_altinterface(pHDev,0) != 0) { - LOG_ERROR("Failed to set interface.\n"); + LOG_ERROR("Failed to set interface."); return ERROR_FAIL; } @@ -1639,18 +1638,18 @@ int rlink_init(void) */ for (i = 0; i < 5; i++) { j = ep1_generic_commandl( - pHDev, 1, - EP1_CMD_GET_FWREV -); + pHDev, 1, + EP1_CMD_GET_FWREV + ); if (j < USB_EP1OUT_SIZE) { LOG_ERROR("USB write error: %s", usb_strerror()); return(ERROR_FAIL); } j = usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)reply_buffer, sizeof(reply_buffer), - 200 -); + pHDev, USB_EP1IN_ADDR, + (char *)reply_buffer, sizeof(reply_buffer), + 200 + ); if (j != -ETIMEDOUT) break; } @@ -1658,124 +1657,119 @@ int rlink_init(void) LOG_ERROR("USB read error: %s", usb_strerror()); return(ERROR_FAIL); } - LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d\n", reply_buffer[0], reply_buffer[1], reply_buffer[2]); + LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d", reply_buffer[0], reply_buffer[1], reply_buffer[2]); if ((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) { - LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.\n"); + LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work."); } /* Probe port E for adapter presence */ ep1_generic_commandl( - pHDev, 16, - EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */ + pHDev, 16, + EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */ ST7_PEDR >> 8, ST7_PEDR, 3, 0x00, /* DR */ ST7_PE_ADAPTER_SENSE_OUT, /* DDR */ ST7_PE_ADAPTER_SENSE_OUT, /* OR */ - EP1_CMD_MEMORY_READ, /* Read back */ + EP1_CMD_MEMORY_READ, /* Read back */ ST7_PEDR >> 8, ST7_PEDR, 1, - EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */ + EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */ ST7_PEDR >> 8, ST7_PEDR, 1, ST7_PE_ADAPTER_SENSE_OUT -); + ); usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)reply_buffer, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)reply_buffer, 1, + USB_TIMEOUT_MS + ); if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) { - LOG_WARNING("target detection problem\n"); + LOG_WARNING("target detection problem"); } ep1_generic_commandl( - pHDev, 11, - EP1_CMD_MEMORY_READ, /* Read back */ + pHDev, 11, + EP1_CMD_MEMORY_READ, /* Read back */ ST7_PEDR >> 8, ST7_PEDR, 1, - EP1_CMD_MEMORY_WRITE, /* float port E */ + EP1_CMD_MEMORY_WRITE, /* float port E */ ST7_PEDR >> 8, ST7_PEDR, 3, 0x00, /* DR */ 0x00, /* DDR */ 0x00 /* OR */ -); + ); usb_bulk_read( - pHDev, USB_EP1IN_ADDR, - (char *)reply_buffer, 1, - USB_TIMEOUT_MS -); + pHDev, USB_EP1IN_ADDR, + (char *)reply_buffer, 1, + USB_TIMEOUT_MS + ); if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) { - LOG_WARNING("target not plugged in\n"); + LOG_WARNING("target not plugged in"); } /* float ports A and B */ ep1_generic_commandl( - pHDev, 11, - EP1_CMD_MEMORY_WRITE, + pHDev, 11, + EP1_CMD_MEMORY_WRITE, ST7_PADDR >> 8, ST7_PADDR, 2, 0x00, 0x00, - EP1_CMD_MEMORY_WRITE, + EP1_CMD_MEMORY_WRITE, ST7_PBDDR >> 8, ST7_PBDDR, 1, 0x00 -); + ); /* make sure DTC is stopped, set VPP control, set up ports A and B */ ep1_generic_commandl( - pHDev, 14, - EP1_CMD_DTC_STOP, - EP1_CMD_SET_PORTD_VPP, + pHDev, 14, + EP1_CMD_DTC_STOP, + EP1_CMD_SET_PORTD_VPP, ~(ST7_PD_VPP_SHDN), - EP1_CMD_MEMORY_WRITE, + EP1_CMD_MEMORY_WRITE, ST7_PADR >> 8, ST7_PADR, 2, ((~(0)) & (ST7_PA_NTRST)), - (ST7_PA_NTRST), - /* port B has no OR, and we want to emulate open drain on NSRST, so we set DR to 0 here and later assert NSRST by setting DDR bit to 1. */ - EP1_CMD_MEMORY_WRITE, + (ST7_PA_NTRST), + /* port B has no OR, and we want to emulate open drain on NSRST, so we set DR to 0 here and later assert NSRST by setting DDR bit to 1. */ + EP1_CMD_MEMORY_WRITE, ST7_PBDR >> 8, ST7_PBDR, 1, 0x00 -); + ); /* set LED updating mode and make sure they're unlit */ ep1_generic_commandl( - pHDev, 3, + pHDev, 3, #ifdef AUTOMATIC_BUSY_LED - EP1_CMD_LEDUE_BUSY, + EP1_CMD_LEDUE_BUSY, #else - EP1_CMD_LEDUE_NONE, + EP1_CMD_LEDUE_NONE, #endif - EP1_CMD_SET_PORTD_LEDS, + EP1_CMD_SET_PORTD_LEDS, ~0 -); + ); tap_state_queue_init(); dtc_queue_init(); - int jtag_speed_var; - int retval = jtag_get_speed(&jtag_speed_var); - if (retval != ERROR_OK) - return retval; - rlink_speed(jtag_speed_var); rlink_reset(0, 0); return ERROR_OK; @@ -1787,14 +1781,14 @@ int rlink_quit(void) { /* stop DTC and make sure LEDs are off */ ep1_generic_commandl( - pHDev, 6, - EP1_CMD_DTC_STOP, - EP1_CMD_LEDUE_NONE, - EP1_CMD_SET_PORTD_LEDS, + pHDev, 6, + EP1_CMD_DTC_STOP, + EP1_CMD_LEDUE_NONE, + EP1_CMD_SET_PORTD_LEDS, ~0, - EP1_CMD_SET_PORTD_VPP, + EP1_CMD_SET_PORTD_VPP, ~0 -); + ); usb_release_interface(pHDev,0); usb_close(pHDev); @@ -1806,11 +1800,11 @@ int rlink_quit(void) struct jtag_interface rlink_interface = { - .name = "rlink", - .init = rlink_init, - .quit = rlink_quit, - .speed = rlink_speed, - .speed_div = rlink_speed_div, - .khz = rlink_khz, - .execute_queue = rlink_execute_queue, + .name = "rlink", + .init = rlink_init, + .quit = rlink_quit, + .speed = rlink_speed, + .speed_div = rlink_speed_div, + .khz = rlink_khz, + .execute_queue = rlink_execute_queue, };