#endif
/* project specific includes */
-#include "jtag.h"
+#include "interface.h"
+#include "commands.h"
#include "rlink.h"
#include "st7.h"
#include "ep1_cmd.h"
va_list ap;
int usb_ret;
- if(length > sizeof(usb_buffer)) {
+ if (length > sizeof(usb_buffer)) {
length = sizeof(usb_buffer);
}
usb_buffer_p = usb_buffer;
va_start(ap, length);
- while(length > 0) {
+ while (length > 0) {
*usb_buffer_p++ = va_arg(ap, int);
length--;
}
remain = length;
count = 0;
- while(remain) {
- if(remain > sizeof(usb_buffer)) {
+ while (remain) {
+ if (remain > sizeof(usb_buffer)) {
length = sizeof(usb_buffer);
} else {
length = remain;
USB_TIMEOUT_MS
);
- if(usb_ret < sizeof(usb_buffer)) {
+ if (usb_ret < sizeof(usb_buffer)) {
break;
}
USB_TIMEOUT_MS
);
- if(usb_ret < length) {
+ if (usb_ret < length) {
break;
}
remain = length;
count = 0;
- while(remain) {
- if(remain > (sizeof(usb_buffer) - 4)) {
+ while (remain) {
+ if (remain > (sizeof(usb_buffer) - 4)) {
length = (sizeof(usb_buffer) - 4);
} else {
length = remain;
USB_TIMEOUT_MS
);
- if((size_t)usb_ret < sizeof(usb_buffer)) {
+ if ((size_t)usb_ret < sizeof(usb_buffer)) {
break;
}
va_list ap;
size_t remain;
- if(length > sizeof(buffer)) {
+ if (length > sizeof(buffer)) {
length = sizeof(buffer);
}
buffer_p = buffer;
va_start(ap, length);
- while(remain > 0) {
+ while (remain > 0) {
*buffer_p++ = va_arg(ap, int);
remain--;
}
int
dtc_load_from_buffer(
usb_dev_handle *pHDev,
- const u8 *buffer,
+ const uint8_t *buffer,
size_t length
) {
struct header_s {
- u8 type;
- u8 length;
+ uint8_t type;
+ uint8_t length;
};
int usb_err;
struct header_s *header;
- u8 lut_start = 0xc0;
+ uint8_t lut_start = 0xc0;
dtc_entry_download = 0;
pHDev, 1,
EP1_CMD_DTC_STOP
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
- while(length) {
- if(length < sizeof(*header)) {
+ while (length) {
+ if (length < sizeof(*header)) {
LOG_ERROR("Malformed DTC image\n");
exit(1);
}
buffer += sizeof(*header);
length -= sizeof(*header);
- if(length < (size_t)header->length + 1) {
+ if (length < (size_t)header->length + 1) {
LOG_ERROR("Malformed DTC image\n");
exit(1);
}
- switch(header->type) {
+ switch (header->type) {
case DTCLOAD_COMMENT:
break;
case DTCLOAD_ENTRY:
/* store entry addresses somewhere */
- if(!strncmp("download", (char *)buffer + 1, 8)) {
+ if (!strncmp("download", (char *)buffer + 1, 8)) {
dtc_entry_download = buffer[0];
}
break;
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(
(DTC_LOAD_BUFFER >> 8),
DTC_LOAD_BUFFER
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
break;
buffer[0],
EP1_CMD_DTC_WAIT
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
break;
ST7_USB_BUF_EP0OUT + lut_start,
header->length + 1, buffer
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
break;
default:
int
dtc_start_download(void) {
int usb_err;
- u8 ep2txr;
+ uint8_t ep2txr;
/* set up for download mode and make sure EP2 is set up to transmit */
usb_err = ep1_generic_commandl(
ST7_EP2TXR,
1
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
/* read back ep2txr */
usb_err = usb_bulk_read(
(char *)&ep2txr, 1,
USB_TIMEOUT_MS
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
usb_err = ep1_generic_commandl(
pHDev, 13,
dtc_entry_download,
EP1_CMD_DTC_GET_CACHED_STATUS
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
/* wait for completion */
usb_err = usb_bulk_read(
int
dtc_run_download(
usb_dev_handle *pHDev,
- u8 *command_buffer,
+ uint8_t *command_buffer,
int command_buffer_size,
- u8 *reply_buffer,
+ uint8_t *reply_buffer,
int reply_buffer_size
) {
- u8 ep2_buffer[USB_EP2IN_SIZE];
+ uint8_t ep2_buffer[USB_EP2IN_SIZE];
int usb_err;
int i;
(char *)command_buffer, USB_EP2BANK_SIZE,
USB_TIMEOUT_MS
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
/* Wait for DTC to finish running command buffer */
- for(i = 5;;) {
+ for (i = 10;;) {
usb_err = ep1_generic_commandl(
pHDev, 4,
DTC_STATUS_POLL_BYTE,
1
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
usb_err = usb_bulk_read(
pHDev,
(char *)ep2_buffer, 1,
USB_TIMEOUT_MS
);
- if(usb_err < 0) return(usb_err);
+ if (usb_err < 0) return(usb_err);
- if(ep2_buffer[0] & 0x01) break;
+ if (ep2_buffer[0] & 0x01) break;
- if(!--i) {
+ if (!--i) {
LOG_ERROR("%s, %d: too many retries waiting for DTC status\n",
__FILE__, __LINE__
);
}
- if(!reply_buffer) reply_buffer_size = 0;
- if(reply_buffer_size) {
+ if (!reply_buffer) reply_buffer_size = 0;
+ if (reply_buffer_size) {
usb_err = usb_bulk_read(
pHDev,
USB_EP2IN_ADDR,
USB_TIMEOUT_MS
);
- if(usb_err < (int)sizeof(ep2_buffer)) {
+ if (usb_err < (int)sizeof(ep2_buffer)) {
LOG_ERROR("%s, %d: Read of endpoint 2 returned %d\n",
__FILE__, __LINE__, usb_err
);
jtag_command_t *cmd; /* the command that resulted in this entry */
struct {
- u8 *buffer; /* the scan buffer */
+ uint8_t *buffer; /* the scan buffer */
int size; /* size of the scan buffer in bits */
int offset; /* how many bits were already done before this? */
int length; /* how many bits are processed in this operation? */
struct {
dtc_reply_queue_entry_t *rq_head;
dtc_reply_queue_entry_t *rq_tail;
- u32 cmd_index;
- u32 reply_index;
- u8 cmd_buffer[USB_EP2BANK_SIZE];
+ uint32_t cmd_index;
+ uint32_t reply_index;
+ uint8_t cmd_buffer[USB_EP2BANK_SIZE];
} dtc_queue;
static
struct {
- u32 length;
- u32 buffer;
+ uint32_t length;
+ uint32_t buffer;
} tap_state_queue;
dtc_reply_queue_entry_t *
dtc_queue_enqueue_reply(
enum scan_type type,
- u8 *buffer,
+ uint8_t *buffer,
int size,
int offset,
int length,
dtc_reply_queue_entry_t *rq_entry;
rq_entry = malloc(sizeof(dtc_reply_queue_entry_t));
- if(rq_entry != NULL) {
+ if (rq_entry != NULL) {
rq_entry->scan.type = type;
rq_entry->scan.buffer = buffer;
rq_entry->scan.size = size;
rq_entry->cmd = cmd;
rq_entry->next = NULL;
- if(dtc_queue.rq_head == NULL)
+ if (dtc_queue.rq_head == NULL)
dtc_queue.rq_head = rq_entry;
else
dtc_queue.rq_tail->next = rq_entry;
int usb_err;
int bit_cnt;
int x;
- u8 *dtc_p, *tdo_p;
- u8 dtc_mask, tdo_mask;
- u8 reply_buffer[USB_EP2IN_SIZE];
+ uint8_t *dtc_p, *tdo_p;
+ uint8_t dtc_mask, tdo_mask;
+ uint8_t reply_buffer[USB_EP2IN_SIZE];
retval = ERROR_OK;
- if(dtc_queue.cmd_index < 1) return(retval);
+ if (dtc_queue.cmd_index < 1) return(retval);
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
/* run the cmd */
- if(dtc_queue.rq_head == NULL) {
+ if (dtc_queue.rq_head == NULL) {
usb_err = dtc_run_download(pHDev,
dtc_queue.cmd_buffer, dtc_queue.cmd_index,
NULL, 0
);
- if(usb_err < 0) {
+ if (usb_err < 0) {
LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
exit(1);
}
dtc_queue.cmd_buffer, dtc_queue.cmd_index,
reply_buffer, dtc_queue.reply_index
);
- if(usb_err < 0) {
+ if (usb_err < 0) {
LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
exit(1);
} else {
/* 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
bit_cnt = rq_p->scan.length;
- if(bit_cnt >= 8) {
+ if (bit_cnt >= 8) {
/* bytes */
dtc_mask = 1 << (8 - 1);
- for(
+ for (
;
bit_cnt;
bit_cnt--
) {
- if(*dtc_p & dtc_mask) {
+ if (*dtc_p & dtc_mask) {
*tdo_p |= tdo_mask;
} else {
*tdo_p &=~ tdo_mask;
}
dtc_mask >>= 1;
- if(dtc_mask == 0) {
+ if (dtc_mask == 0) {
dtc_p++;
dtc_mask = 1 << (8 - 1);
}
tdo_mask <<= 1;
- if(tdo_mask == 0) {
+ if (tdo_mask == 0) {
tdo_p++;
tdo_mask = 1;
}
/* extra bits or last bit */
x = *dtc_p++;
- if((
+ if ((
rq_p->scan.type == SCAN_IN
) && (
rq_p->scan.offset != rq_p->scan.size - 1
dtc_mask = 1 << (bit_cnt - 1);
}
- for(
+ for (
;
bit_cnt;
bit_cnt--
) {
- if(x & dtc_mask) {
+ if (x & dtc_mask) {
*tdo_p |= tdo_mask;
} else {
*tdo_p &=~ tdo_mask;
dtc_mask >>= 1;
tdo_mask <<= 1;
- if(tdo_mask == 0) {
+ if (tdo_mask == 0) {
tdo_p++;
tdo_mask = 1;
}
}
}
- if((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
+ 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) {
+ 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);
tap_state_queue_run(void) {
int i;
int bits;
- u8 byte;
+ uint8_t byte;
int retval;
retval = 0;
- if(!tap_state_queue.length) return(retval);
+ if (!tap_state_queue.length) return(retval);
bits = 1;
byte = 0;
- for(i = tap_state_queue.length; i--;) {
+ for (i = tap_state_queue.length; i--;) {
byte <<= 1;
- if(tap_state_queue.buffer & 1) {
+ if (tap_state_queue.buffer & 1) {
byte |= 1;
}
- if((bits >= 8) || !i) {
+ if ((bits >= 8) || !i) {
byte <<= (8 - bits);
/* 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))) {
+ 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_queue_run();
}
#ifdef USE_HARDWARE_SHIFTER_FOR_TMS
- if(bits == 8) {
+ if (bits == 8) {
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
DTC_CMD_SHIFT_TMS_BYTES(1);
} else {
static
int
tap_state_queue_append(
- u8 tms
+ uint8_t tms
) {
int retval;
- if(tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
+ if (tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
retval = tap_state_queue_run();
- if(retval != 0) return(retval);
+ if (retval != 0) return(retval);
}
- if(tms) {
+ if (tms) {
tap_state_queue.buffer |= (1 << tap_state_queue.length);
}
tap_state_queue.length++;
void rlink_state_move(void) {
int i=0, tms=0;
- u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+ uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+ int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
- for (i = 0; i < 7; i++)
+ for (i = 0; i < tms_count; i++)
{
tms = (tms_scan >> i) & 1;
tap_state_queue_append(tms);
static
void rlink_reset(int trst, int srst)
{
- u8 bitmap;
+ uint8_t bitmap;
int usb_err;
/* Read port A for bit op */
ST7_PADR,
1
);
- if(usb_err < 0) {
+ if (usb_err < 0) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
(char *)&bitmap, 1,
USB_TIMEOUT_MS
);
- if(usb_err < 1) {
+ if (usb_err < 1) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
- if(trst) {
+ if (trst) {
bitmap &= ~ST7_PA_NTRST;
} else {
bitmap |= ST7_PA_NTRST;
ST7_PBDDR,
1
);
- if(usb_err < 0) {
+ if (usb_err < 0) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
(char *)&bitmap, 1,
USB_TIMEOUT_MS
);
- if(usb_err < 1) {
+ if (usb_err < 1) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
- if(srst) {
+ if (srst) {
bitmap |= ST7_PB_NSRST;
} else {
bitmap &= ~ST7_PB_NSRST;
bitmap,
EP1_CMD_DTC_GET_CACHED_STATUS
);
- if(usb_err < 0) {
+ if (usb_err < 0) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
(char *)&bitmap, 1,
USB_TIMEOUT_MS
);
- if(usb_err < 1) {
+ if (usb_err < 1) {
LOG_ERROR("%s", usb_strerror());
exit(1);
}
rlink_scan(
jtag_command_t *cmd,
enum scan_type type,
- u8 *buffer,
+ uint8_t *buffer,
int scan_size
) {
- int ir_scan;
+ bool ir_scan;
tap_state_t saved_end_state;
int byte_bits;
int extra_bits;
int x;
int tdi_bit_offset;
- u8 tdi_mask, *tdi_p;
- u8 dtc_mask;
+ uint8_t tdi_mask, *tdi_p;
+ uint8_t dtc_mask;
- if(scan_size < 1) {
+ if (scan_size < 1) {
LOG_ERROR("scan_size cannot be less than 1 bit\n");
exit(1);
}
buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
printf("before scan:");
- for(i = 0; i < (scan_size + 7) / 8; i++) {
+ for (i = 0; i < (scan_size + 7) / 8; i++) {
printf(" %02x", buffer[i]);
}
printf("\n");
tdi_p = buffer;
tdi_mask = 1;
- if(extra_bits && (type == SCAN_OUT)) {
+ if (extra_bits && (type == SCAN_OUT)) {
/* Schedule any extra bits into the DTC command buffer, padding as needed */
/* 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(
+ if (
(dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
) {
dtc_queue_run();
x = 0;
dtc_mask = 1 << (extra_bits - 1);
- while(extra_bits--) {
- if(*tdi_p & tdi_mask) {
+ while (extra_bits--) {
+ if (*tdi_p & tdi_mask) {
x |= dtc_mask;
}
dtc_mask >>= 1;
tdi_mask <<= 1;
- if(tdi_mask == 0) {
+ if (tdi_mask == 0) {
tdi_p++;
tdi_mask = 1;
}
}
/* Loop scheduling full bytes into the DTC command buffer */
- while(byte_bits) {
- if(type == SCAN_IN) {
+ while (byte_bits) {
+ if (type == SCAN_IN) {
/* make sure there's room for stop and byte op */
x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1));
} else {
x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1));
}
- if(type != SCAN_OUT) {
+ if (type != SCAN_OUT) {
/* make sure there's room for at least one reply byte */
x |= (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1));
}
- if(x) {
+ if (x) {
dtc_queue_run();
}
chunk_bits = byte_bits;
/* we can only use up to 16 bytes at a time */
- if(chunk_bits > (16 * 8)) chunk_bits = (16 * 8);
+ if (chunk_bits > (16 * 8)) chunk_bits = (16 * 8);
- if(type != SCAN_IN) {
+ if (type != SCAN_IN) {
/* how much is there room for, considering stop and byte op? */
x = (sizeof(dtc_queue.cmd_buffer) - (dtc_queue.cmd_index + 1 + 1)) * 8;
- if(chunk_bits > x) chunk_bits = x;
+ if (chunk_bits > x) chunk_bits = x;
}
- if(type != SCAN_OUT) {
+ if (type != SCAN_OUT) {
/* how much is there room for in the reply buffer? */
x = (USB_EP2IN_SIZE - dtc_queue.reply_index) * 8;
- if(chunk_bits > x) chunk_bits = x;
+ if (chunk_bits > x) chunk_bits = x;
}
/* so the loop will end */
byte_bits -= chunk_bits;
- if(type != SCAN_OUT) {
- if(dtc_queue_enqueue_reply(
+ if (type != SCAN_OUT) {
+ if (dtc_queue_enqueue_reply(
type, buffer, scan_size, tdi_bit_offset,
chunk_bits,
cmd
/* chunk_bits is a multiple of 8, so there are no rounding issues. */
chunk_bytes = chunk_bits / 8;
- switch(type) {
+ switch (type) {
case SCAN_IN:
x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
break;
}
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
- if(type != SCAN_IN) {
+ if (type != SCAN_IN) {
x = 0;
dtc_mask = 1 << (8 - 1);
- while(chunk_bits--) {
- if(*tdi_p & tdi_mask) {
+ while (chunk_bits--) {
+ if (*tdi_p & tdi_mask) {
x |= dtc_mask;
}
dtc_mask >>= 1;
- if(dtc_mask == 0) {
+ if (dtc_mask == 0) {
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
dtc_queue.reply_index++;
x = 0;
}
tdi_mask <<= 1;
- if(tdi_mask == 0) {
+ if (tdi_mask == 0) {
tdi_p++;
tdi_mask = 1;
}
}
}
- if(extra_bits && (type != SCAN_OUT)) {
+ if (extra_bits && (type != SCAN_OUT)) {
/* Schedule any extra bits into the DTC command buffer */
/* make sure there's room for stop, byte op, and one byte */
- if(
+ if (
(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(
+ if (dtc_queue_enqueue_reply(
type, buffer, scan_size, tdi_bit_offset,
extra_bits,
cmd
tdi_bit_offset += extra_bits;
- if(type == SCAN_IN) {
+ if (type == SCAN_IN) {
dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
DTC_CMD_SHIFT_TDO_BYTES(1);
x = 0;
dtc_mask = 1 << (8 - 1);
- while(extra_bits--) {
- if(*tdi_p & tdi_mask) {
+ while (extra_bits--) {
+ if (*tdi_p & tdi_mask) {
x |= dtc_mask;
}
dtc_mask >>= 1;
tdi_mask <<= 1;
- if(tdi_mask == 0) {
+ if (tdi_mask == 0) {
tdi_p++;
tdi_mask = 1;
}
/* Schedule the last bit into the DTC command buffer */
{
/* make sure there's room for stop, and bit pair command */
- if(
+ if (
(dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1))
||
(dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
dtc_queue_run();
}
- if(type == SCAN_OUT) {
+ 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(
+ if (dtc_queue_enqueue_reply(
type, buffer, scan_size, tdi_bit_offset,
1,
cmd
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
int scan_size;
enum scan_type type;
- u8 *buffer;
+ uint8_t *buffer;
int retval, tmp_retval;
/* return ERROR_OK, unless something goes wrong */
{
switch (cmd->type)
{
- case JTAG_END_STATE:
case JTAG_RUNTEST:
case JTAG_STATEMOVE:
case JTAG_PATHMOVE:
switch (cmd->type)
{
- case JTAG_END_STATE:
-#ifdef _DEBUG_JTAG_IO_
- LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
-#endif
- if (cmd->cmd.end_state->end_state != -1)
- rlink_end_state(cmd->cmd.end_state->end_state);
- break;
case JTAG_RESET:
#ifdef _DEBUG_JTAG_IO_
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_reset_config & RESET_SRST_PULLS_TRST)))
+ if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
{
tap_set_state(TAP_RESET);
}
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) {
+ if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) {
retval = ERROR_FAIL;
}
break;
/* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
tap_state_queue_run();
tmp_retval = dtc_queue_run();
- if(tmp_retval != ERROR_OK) {
+ if (tmp_retval != ERROR_OK) {
retval = tmp_retval;
}
{
int i;
- if(speed == 0) {
+ if (speed == 0) {
/* fastest speed */
speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
}
- 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) {
+ 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);
exit(1);
}
- if(dtc_start_download() < 0) {
+ if (dtc_start_download() < 0) {
LOG_ERROR("%s, %d: starting DTC: %s",
__FILE__, __LINE__,
usb_strerror()
) {
int i;
- for(i = rlink_speed_table_size; i--; ) {
- if(rlink_speed_table[i].prescaler == speed) {
+ for (i = rlink_speed_table_size; i--; ) {
+ if (rlink_speed_table[i].prescaler == speed) {
*khz = rlink_speed_table[i].khz;
return(ERROR_OK);
}
) {
int i;
- if(khz == 0) {
+ if (khz == 0) {
LOG_ERROR("RCLK not supported");
return ERROR_FAIL;
}
- for(i = rlink_speed_table_size; i--; ) {
- if(rlink_speed_table[i].khz <= khz) {
+ for (i = rlink_speed_table_size; i--; ) {
+ if (rlink_speed_table[i].khz <= khz) {
*speed = rlink_speed_table[i].prescaler;
return(ERROR_OK);
}
char **args,
int argc
) {
- if(argc != 1) {
+ if (argc != 1) {
LOG_ERROR("expected exactly one argument to rlink_dtc_directory <directory-path>");
return(ERROR_INVALID_ARGUMENTS);
}
int i, j, retries;
int found=0;
int success=0;
- u8 reply_buffer[USB_EP1IN_SIZE];
+ uint8_t reply_buffer[USB_EP1IN_SIZE];
usb_init();
usb_find_busses();
busses = usb_get_busses();
- for(bus = busses; bus; bus = bus->next)
+ for (bus = busses; bus; bus = bus->next)
{
struct usb_device *dev;
- for(dev = bus->devices; dev; dev = dev->next)
+ for (dev = bus->devices; dev; dev = dev->next)
{
- if( (dev->descriptor.idVendor == USB_IDVENDOR) && (dev->descriptor.idProduct == USB_IDPRODUCT) )
+ if ( (dev->descriptor.idVendor == USB_IDVENDOR) && (dev->descriptor.idProduct == USB_IDPRODUCT) )
{
found = 1;
LOG_DEBUG("Found device on bus.\n");
do
{
- if( dev->descriptor.bNumConfigurations > 1 )
+ if ( dev->descriptor.bNumConfigurations > 1 )
{
LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...\n");
break;
}
- if( dev->config->bNumInterfaces > 1 )
+ if ( dev->config->bNumInterfaces > 1 )
{
LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...\n");
break;
}
pHDev=usb_open(dev);
- if( !pHDev )
+ if ( !pHDev )
LOG_ERROR ("Failed to open device.\n");
else
{
do
{
i = usb_claim_interface(pHDev,0);
- if(i)
+ if (i)
{
LOG_ERROR("usb_claim_interface: %s", usb_strerror());
#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
j = usb_detach_kernel_driver_np(pHDev, 0);
- if(j)
+ if (j)
LOG_ERROR("detach kernel driver: %s", usb_strerror());
#endif
}
LOG_DEBUG("interface claimed!\n");
break;
}
- } while(--retries);
+ } while (--retries);
- if(!i)
+ if (!i)
{
- if( usb_set_altinterface(pHDev,0) )
+ if ( usb_set_altinterface(pHDev,0) )
{
LOG_ERROR("Failed to set interface.\n");
break;
success=1;
}
}
- } while(0);
+ } while (0);
}
}
}
- if( !found )
+ if ( !found )
{
LOG_ERROR("No device found on bus.\n");
exit(1);
}
- if( !success )
+ if ( !success )
{
LOG_ERROR("Initialisation failed.");
exit(1);
/* The device starts out in an unknown state on open. As such, result reads time out, and it's not even known whether the command was accepted. So, for this first command, we issue it repeatedly until its response doesn't time out. Also, if sending a command is going to time out, we'll find that out here. */
/* It must be possible to open the device in such a way that this special magic isn't needed, but, so far, it escapes us. */
- for(i = 0; i < 5; i++) {
+ for (i = 0; i < 5; i++) {
j = ep1_generic_commandl(
pHDev, 1,
EP1_CMD_GET_FWREV
);
- if(j < USB_EP1OUT_SIZE) {
+ if (j < USB_EP1OUT_SIZE) {
LOG_ERROR("USB write error: %s", usb_strerror());
return(ERROR_FAIL);
}
(char *)reply_buffer, sizeof(reply_buffer),
200
);
- if(j != -ETIMEDOUT) break;
+ if (j != -ETIMEDOUT) break;
}
- if(j < (int)sizeof(reply_buffer)) {
+ if (j < (int)sizeof(reply_buffer)) {
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]);
- if((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) {
+ 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");
}
USB_TIMEOUT_MS
);
- if((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
+ if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
LOG_WARNING("target detection problem\n");
}
);
- if((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
+ if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
LOG_WARNING("target not plugged in\n");
}
tap_state_queue_init();
dtc_queue_init();
- rlink_speed(jtag_speed);
+ rlink_speed(jtag_get_speed());
rlink_reset(0, 0);
return ERROR_OK;
Code Review / openocd.git / blobdiff