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--;
}
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:
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(
(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 = 10;;) {
+ 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
);
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;
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);
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 {
) {
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++;
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);
}
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
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);
}
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");
}
Code Review / openocd.git / blobdiff