static uint8_t vsllink_usb_interface;
static int VSLLINK_USB_TIMEOUT = 1000;
-static int vsllink_tms_offset = 0;
+static int vsllink_tms_offset;
/* Global USB buffers */
-static uint8_t* vsllink_usb_in_buffer = NULL;
-static uint8_t* vsllink_usb_out_buffer = NULL;
+static uint8_t *vsllink_usb_in_buffer;
+static uint8_t *vsllink_usb_out_buffer;
static int vsllink_buffer_size = 128;
/* Constants for Versaloon command */
#define MAX_PENDING_SCAN_RESULTS 256
static int pending_scan_results_length;
-static struct pending_scan_result \
- pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
+static struct pending_scan_result
+ pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
/* Queue command functions */
static void vsllink_end_state(tap_state_t state);
static void vsllink_path_move(int num_states, tap_state_t *path);
static void vsllink_runtest(int num_cycles);
static void vsllink_stableclocks(int num_cycles, int tms);
-static void vsllink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, \
- int scan_size, struct scan_command *command);
+static void vsllink_scan(bool ir_scan, enum scan_type type,
+ uint8_t *buffer, int scan_size, struct scan_command *command);
static void vsllink_reset(int trst, int srst);
static void vsllink_simple_command(uint8_t command);
static void vsllink_tap_init(void);
static int vsllink_tap_execute(void);
static void vsllink_tap_ensure_pending(int scans);
-static void vsllink_tap_append_scan(int length, uint8_t *buffer, \
- struct scan_command *command);
+static void vsllink_tap_append_scan(int length, uint8_t *buffer,
+ struct scan_command *command);
/* VSLLink lowlevel functions */
struct vsllink {
- struct usb_dev_handle* usb_handle;
+ struct usb_dev_handle *usb_handle;
};
static struct vsllink *vsllink_usb_open(void);
static void vsllink_usb_close(struct vsllink *vsllink);
-static int vsllink_usb_message(struct vsllink *vsllink, int out_length, \
+static int vsllink_usb_message(struct vsllink *vsllink, int out_length,
int in_length);
static int vsllink_usb_write(struct vsllink *vsllink, int out_length);
static int vsllink_usb_read(struct vsllink *vsllink);
static void vsllink_debug_buffer(uint8_t *buffer, int length);
#endif
-static int tap_length = 0;
-static int tap_buffer_size = 0;
-static uint8_t *tms_buffer = NULL;
-static uint8_t *tdi_buffer = NULL;
-static uint8_t *tdo_buffer = NULL;
+static int tap_length;
+static int tap_buffer_size;
+static uint8_t *tms_buffer;
+static uint8_t *tdi_buffer;
+static uint8_t *tdo_buffer;
-static struct vsllink* vsllink_handle = NULL;
+static struct vsllink *vsllink_handle;
static void reset_command_pointer(void)
{
enum scan_type type;
uint8_t *buffer;
- DEBUG_JTAG_IO( "-------------------------------------"
- " vsllink "
- "-------------------------------------");
+ DEBUG_JTAG_IO("-------------------------------------"
+ " vsllink "
+ "-------------------------------------");
reset_command_pointer();
- while (cmd != NULL)
- {
- switch (cmd->type)
- {
+ while (cmd != NULL) {
+ switch (cmd->type) {
case JTAG_RUNTEST:
- DEBUG_JTAG_IO("runtest %i cycles, end in %s", \
- cmd->cmd.runtest->num_cycles, \
- tap_state_name(cmd->cmd.runtest->end_state));
+ DEBUG_JTAG_IO("runtest %i cycles, end in %s",
+ cmd->cmd.runtest->num_cycles,
+ tap_state_name(cmd->cmd.runtest
+ ->end_state));
vsllink_end_state(cmd->cmd.runtest->end_state);
vsllink_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_STATEMOVE:
- DEBUG_JTAG_IO("statemove end in %s", \
- tap_state_name(cmd->cmd.statemove->end_state));
+ DEBUG_JTAG_IO("statemove end in %s",
+ tap_state_name(cmd->cmd.statemove
+ ->end_state));
- vsllink_end_state(cmd->cmd.statemove->end_state);
+ vsllink_end_state(cmd->cmd.statemove
+ ->end_state);
vsllink_state_move();
break;
case JTAG_PATHMOVE:
- DEBUG_JTAG_IO("pathmove: %i states, end in %s", \
- cmd->cmd.pathmove->num_states, \
- tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
-
- vsllink_path_move(cmd->cmd.pathmove->num_states, \
- cmd->cmd.pathmove->path);
+ DEBUG_JTAG_IO("pathmove: %i states, end in %s",
+ cmd->cmd.pathmove->num_states,
+ tap_state_name(cmd->cmd.pathmove
+ ->path[cmd->cmd.pathmove
+ ->num_states - 1]));
+
+ vsllink_path_move(
+ cmd->cmd.pathmove->num_states,
+ cmd->cmd.pathmove->path);
break;
case JTAG_SCAN:
vsllink_end_state(cmd->cmd.scan->end_state);
- scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+ scan_size = jtag_build_buffer(
+ cmd->cmd.scan, &buffer);
+
if (cmd->cmd.scan->ir_scan)
- {
- DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %s:", \
- scan_size, \
- tap_state_name(cmd->cmd.scan->end_state));
- }
+ DEBUG_JTAG_IO(
+ "JTAG Scan write IR(%d bits), "
+ "end in %s:",
+ scan_size,
+ tap_state_name(cmd->cmd.scan
+ ->end_state));
+
else
- {
- DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %s:", \
- scan_size, \
- tap_state_name(cmd->cmd.scan->end_state));
- }
+ DEBUG_JTAG_IO(
+ "JTAG Scan write DR(%d bits), "
+ "end in %s:",
+ scan_size,
+ tap_state_name(cmd->cmd.scan
+ ->end_state));
#ifdef _DEBUG_JTAG_IO_
- vsllink_debug_buffer(buffer, DIV_ROUND_UP(scan_size, 8));
+ vsllink_debug_buffer(buffer,
+ DIV_ROUND_UP(scan_size, 8));
#endif
type = jtag_scan_type(cmd->cmd.scan);
- vsllink_scan(cmd->cmd.scan->ir_scan, type, buffer, \
- scan_size, cmd->cmd.scan);
+ vsllink_scan(cmd->cmd.scan->ir_scan,
+ type, buffer, scan_size,
+ cmd->cmd.scan);
break;
case JTAG_RESET:
- DEBUG_JTAG_IO("reset trst: %i srst %i", \
- cmd->cmd.reset->trst, \
- cmd->cmd.reset->srst);
+ DEBUG_JTAG_IO("reset trst: %i srst %i",
+ cmd->cmd.reset->trst,
+ cmd->cmd.reset->srst);
vsllink_tap_execute();
if (cmd->cmd.reset->trst == 1)
- {
tap_set_state(TAP_RESET);
- }
- vsllink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+
+ vsllink_reset(cmd->cmd.reset->trst,
+ cmd->cmd.reset->srst);
break;
case JTAG_SLEEP:
break;
case JTAG_STABLECLOCKS:
- DEBUG_JTAG_IO("add %d clocks", \
- cmd->cmd.stableclocks->num_cycles);
- switch (tap_get_state())
- {
+ DEBUG_JTAG_IO("add %d clocks",
+ cmd->cmd.stableclocks->num_cycles);
+ switch (tap_get_state()) {
case TAP_RESET:
- // tms should be '1' to stay in TAP_RESET mode
+ /* tms must be '1' to stay
+ * n TAP_RESET mode
+ */
scan_size = 1;
break;
case TAP_DRSHIFT:
case TAP_DRPAUSE:
case TAP_IRSHIFT:
case TAP_IRPAUSE:
- // in other mode, tms should be '0'
+ /* else, tms should be '0' */
scan_size = 0;
- break; /* above stable states are OK */
+ break;
+ /* above stable states are OK */
default:
- LOG_ERROR("jtag_add_clocks() in non-stable state \"%s\"",
- tap_state_name(tap_get_state()));
- exit(-1);
+ LOG_ERROR("jtag_add_clocks() "
+ "in non-stable state \"%s\"",
+ tap_state_name(tap_get_state())
+ );
+ exit(-1);
}
- vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, \
- scan_size);
+ vsllink_stableclocks(cmd->cmd.stableclocks
+ ->num_cycles, scan_size);
break;
default:
- LOG_ERROR("BUG: unknown JTAG command type encountered: %d", \
- cmd->type);
+ LOG_ERROR("BUG: unknown JTAG command type "
+ "encountered: %d", cmd->type);
exit(-1);
}
cmd = cmd->next;
result = vsllink_usb_write(vsllink_handle, 3);
if (result == 3)
- {
return ERROR_OK;
- }
- else
- {
+ else {
LOG_ERROR("VSLLink setting speed failed (%d)", result);
return ERROR_JTAG_DEVICE_ERROR;
}
vsllink_usb_in_buffer = malloc(vsllink_buffer_size);
vsllink_usb_out_buffer = malloc(vsllink_buffer_size);
- if ((vsllink_usb_in_buffer == NULL) || (vsllink_usb_out_buffer == NULL))
- {
+ if ((vsllink_usb_in_buffer == NULL)
+ || (vsllink_usb_out_buffer == NULL)) {
LOG_ERROR("Not enough memory");
exit(-1);
}
vsllink_handle = vsllink_usb_open();
- if (vsllink_handle == 0)
- {
+ if (vsllink_handle == 0) {
LOG_ERROR("Can't find USB JTAG Interface!"\
- "Please check connection and permissions.");
+ "Please check connection and permissions.");
return ERROR_JTAG_INIT_FAILED;
}
- LOG_DEBUG("vsllink found on %04X:%04X", vsllink_usb_vid, vsllink_usb_pid);
+ LOG_DEBUG("vsllink found on %04X:%04X",
+ vsllink_usb_vid, vsllink_usb_pid);
to_tmp = VSLLINK_USB_TIMEOUT;
VSLLINK_USB_TIMEOUT = 100;
check_cnt = 0;
- while (check_cnt < 5)
- {
+ while (check_cnt < 5) {
vsllink_simple_command(VERSALOON_GET_INFO);
result = vsllink_usb_read(vsllink_handle);
- if (result > 2)
- {
+ if (result > 2) {
vsllink_usb_in_buffer[result] = 0;
- vsllink_buffer_size = vsllink_usb_in_buffer[0] + \
- (vsllink_usb_in_buffer[1] << 8);
- strncpy(version_str, (char *)vsllink_usb_in_buffer + 2, \
+ vsllink_buffer_size = vsllink_usb_in_buffer[0]
+ + (vsllink_usb_in_buffer[1] << 8);
+ strncpy(version_str, (char *)vsllink_usb_in_buffer + 2,
sizeof(version_str));
LOG_INFO("%s", version_str);
- // free the pre-alloc memroy
+ /* free the pre-allocated memory */
free(vsllink_usb_in_buffer);
free(vsllink_usb_out_buffer);
vsllink_usb_in_buffer = NULL;
vsllink_usb_out_buffer = NULL;
- // alloc new memory
+ /* alloc new memory */
vsllink_usb_in_buffer = malloc(vsllink_buffer_size);
vsllink_usb_out_buffer = malloc(vsllink_buffer_size);
- if ((vsllink_usb_in_buffer == NULL) || \
- (vsllink_usb_out_buffer == NULL))
- {
+ if ((vsllink_usb_in_buffer == NULL) ||
+ (vsllink_usb_out_buffer == NULL)) {
LOG_ERROR("Not enough memory");
exit(-1);
- }
- else
- {
- LOG_INFO("buffer size for USB is %d bytes", \
+ } else
+ LOG_INFO("buffer size for USB is %d bytes",
vsllink_buffer_size);
- }
- // alloc tms/tdi/tdo buffer
+
+ /* alloc tms/tdi/tdo buffer */
tap_buffer_size = (vsllink_buffer_size - 3) / 2;
- tms_buffer = (uint8_t*)malloc(tap_buffer_size);
- tdi_buffer = (uint8_t*)malloc(tap_buffer_size);
- tdo_buffer = (uint8_t*)malloc(tap_buffer_size);
- if ((tms_buffer == NULL) || (tdi_buffer == NULL) || \
- (tdo_buffer == NULL))
- {
+ tms_buffer = (uint8_t *)malloc(tap_buffer_size);
+ tdi_buffer = (uint8_t *)malloc(tap_buffer_size);
+ tdo_buffer = (uint8_t *)malloc(tap_buffer_size);
+ if ((tms_buffer == NULL) || (tdi_buffer == NULL) ||
+ (tdo_buffer == NULL)) {
LOG_ERROR("Not enough memory");
exit(-1);
}
vsllink_simple_command(VSLLINK_CMD_DISCONN);
check_cnt++;
}
- if (check_cnt == 3)
- {
- // Fail to access Versaloon
+ if (check_cnt == 3) {
+ /* Fail to access Versaloon */
LOG_ERROR("VSLLink initial failed");
exit(-1);
}
vsllink_simple_command(VERSALOON_GET_TVCC);
result = vsllink_usb_read(vsllink_handle);
if (result != 2)
- {
LOG_WARNING("Fail to get target voltage");
- }
else
- {
- LOG_INFO("Target runs at %d mV", vsllink_usb_in_buffer[0] + \
+ LOG_INFO("Target runs at %d mV", vsllink_usb_in_buffer[0] +
(vsllink_usb_in_buffer[1] << 8));
- }
- // connect to vsllink
+ /* connect to vsllink */
vsllink_usb_out_buffer[0] = VSLLINK_CMD_CONN;
vsllink_usb_out_buffer[1] = 1;
vsllink_usb_message(vsllink_handle, 2, 0);
- if (vsllink_usb_read(vsllink_handle) > 2)
- {
- strncpy(version_str, (char *)vsllink_usb_in_buffer + 2, \
+ if (vsllink_usb_read(vsllink_handle) > 2) {
+ strncpy(version_str, (char *)vsllink_usb_in_buffer + 2,
sizeof(version_str));
LOG_INFO("%s", version_str);
}
- // Set SRST and TRST to output, Set USR1 and USR2 to input
+ /* Set SRST and TRST to output, Set USR1 and USR2 to input */
vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
- vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | \
- JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
+ vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST
+ | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
vsllink_usb_out_buffer[2] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
- if (vsllink_usb_write(vsllink_handle, 3) != 3)
- {
+ if (vsllink_usb_write(vsllink_handle, 3) != 3) {
LOG_ERROR("VSLLink USB send data error");
exit(-1);
}
static int vsllink_quit(void)
{
- if ((vsllink_usb_in_buffer != NULL) && (vsllink_usb_out_buffer != NULL))
- {
+ if ((vsllink_usb_in_buffer != NULL)
+ && (vsllink_usb_out_buffer != NULL)) {
// Set all pins to input
vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
- vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | \
- JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
+ vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST
+ | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2;
vsllink_usb_out_buffer[2] = 0;
- if (vsllink_usb_write(vsllink_handle, 3) != 3)
- {
+ if (vsllink_usb_write(vsllink_handle, 3) != 3) {
LOG_ERROR("VSLLink USB send data error");
exit(-1);
}
vsllink_handle = NULL;
}
- if (vsllink_usb_in_buffer != NULL)
- {
+ if (vsllink_usb_in_buffer != NULL) {
free(vsllink_usb_in_buffer);
vsllink_usb_in_buffer = NULL;
}
- if (vsllink_usb_out_buffer != NULL)
- {
+ if (vsllink_usb_out_buffer != NULL) {
free(vsllink_usb_out_buffer);
vsllink_usb_out_buffer = NULL;
}
static void vsllink_end_state(tap_state_t state)
{
if (tap_is_state_stable(state))
- {
tap_set_end_state(state);
- }
- else
- {
+ else {
LOG_ERROR("BUG: %i is not a valid end state", state);
exit(-1);
}
static void vsllink_state_move(void)
{
int i;
- uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
- uint8_t tms_scan_bits = \
- tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
+ uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
+ tap_get_end_state());
+ uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(),
+ tap_get_end_state());
for (i = 0; i < tms_scan_bits; i++)
- {
vsllink_tap_append_step((tms_scan >> i) & 1, 0);
- }
tap_set_state(tap_get_end_state());
}
static void vsllink_path_move(int num_states, tap_state_t *path)
{
- for (int i = 0; i < num_states; i++)
- {
+ for (int i = 0; i < num_states; i++) {
if (path[i] == tap_state_transition(tap_get_state(), false))
- {
vsllink_tap_append_step(0, 0);
- }
else if (path[i] == tap_state_transition(tap_get_state(), true))
- {
vsllink_tap_append_step(1, 0);
- }
- else
- {
- LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", \
- tap_state_name(tap_get_state()), \
+ else {
+ LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
+ tap_state_name(tap_get_state()),
tap_state_name(path[i]));
exit(-1);
}
static void vsllink_stableclocks(int num_cycles, int tms)
{
- while (num_cycles > 0)
- {
+ while (num_cycles > 0) {
vsllink_tap_append_step(tms, 0);
num_cycles--;
}
{
tap_state_t saved_end_state = tap_get_end_state();
- if (tap_get_state() != TAP_IDLE)
- {
- // enter into IDLE state
+ if (tap_get_state() != TAP_IDLE) {
+ /* enter IDLE state */
vsllink_end_state(TAP_IDLE);
vsllink_state_move();
}
// set end_state
vsllink_end_state(saved_end_state);
if (tap_get_end_state() != tap_get_end_state())
- {
vsllink_state_move();
- }
}
-static void vsllink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, \
- int scan_size, struct scan_command *command)
+static void vsllink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer,
+ int scan_size, struct scan_command *command)
{
tap_state_t saved_end_state;
vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
if (tap_get_state() != tap_get_end_state())
- {
vsllink_state_move();
- }
vsllink_end_state(saved_end_state);
/* Scan */
tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
if (tap_get_state() != tap_get_end_state())
- {
vsllink_state_move();
- }
}
static void vsllink_reset(int trst, int srst)
vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST;
vsllink_usb_out_buffer[2] = 0;
if (srst == 0)
- {
vsllink_usb_out_buffer[2] |= JTAG_PINMSK_SRST;
- }
if (trst == 0)
- {
vsllink_usb_out_buffer[2] |= JTAG_PINMSK_TRST;
- }
result = vsllink_usb_write(vsllink_handle, 3);
if (result != 3)
- {
- LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)", result);
- }
+ LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)",
+ result);
}
static void vsllink_simple_command(uint8_t command)
result = vsllink_usb_write(vsllink_handle, 1);
if (result != 1)
- {
- LOG_ERROR("VSLLink command 0x%02x failed (%d)", command, result);
- }
+ LOG_ERROR("VSLLink command 0x%02x failed (%d)",
+ command, result);
}
COMMAND_HANDLER(vsllink_handle_mode_command)
COMMAND_HANDLER(vsllink_handle_usb_vid_command)
{
- if (CMD_ARGC != 1)
- {
+ if (CMD_ARGC != 1) {
LOG_ERROR("parameter error, "
"should be one parameter for VID");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_pid_command)
{
- if (CMD_ARGC != 1)
- {
+ if (CMD_ARGC != 1) {
LOG_ERROR("parameter error, "
"should be one parameter for PID");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_bulkin_command)
{
- if (CMD_ARGC != 1)
- {
+ if (CMD_ARGC != 1) {
LOG_ERROR("parameter error, "
- "should be one parameter for BULKIN endpoint");
+ "should be one parameter for BULKIN endpoint");
return ERROR_OK;
}
COMMAND_HANDLER(vsllink_handle_usb_bulkout_command)
{
- if (CMD_ARGC != 1)
- {
+ if (CMD_ARGC != 1) {
LOG_ERROR("parameter error, "
- "should be one parameter for BULKOUT endpoint");
+ "should be one parameter for BULKOUT endpoint");
return ERROR_OK;
}
COMMAND_HANDLER(vsllink_handle_usb_interface_command)
{
- if (CMD_ARGC != 1)
- {
+ if (CMD_ARGC != 1) {
LOG_ERROR("parameter error, "
- "should be one parameter for interface number");
+ "should be one parameter for interface number");
return ERROR_OK;
}
static void vsllink_tap_ensure_pending(int scans)
{
- int available_scans = \
+ int available_scans =
MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
if (scans > available_scans)
- {
vsllink_tap_execute();
- }
}
static void vsllink_tap_append_step(int tms, int tdi)
uint8_t bit = 1 << bit_index;
if (tms)
- {
tms_buffer[index] |= bit;
- }
else
- {
tms_buffer[index] &= ~bit;
- }
if (tdi)
- {
tdi_buffer[index] |= bit;
- }
else
- {
tdi_buffer[index] &= ~bit;
- }
tap_length++;
+
if (tap_buffer_size * 8 <= tap_length)
- {
vsllink_tap_execute();
- }
}
-static void vsllink_tap_append_scan(int length, uint8_t *buffer, \
- struct scan_command *command)
+static void vsllink_tap_append_scan(int length, uint8_t *buffer,
+ struct scan_command *command)
{
struct pending_scan_result *pending_scan_result;
int len_tmp, len_all, i;
len_all = 0;
- while (len_all < length)
- {
+ while (len_all < length) {
vsllink_tap_ensure_pending(1);
- pending_scan_result = \
- &pending_scan_results_buffer[pending_scan_results_length];
+ pending_scan_result =
+ &pending_scan_results_buffer[
+ pending_scan_results_length];
- if ((length - len_all) > (tap_buffer_size * 8 - tap_length))
- {
- /* Use all memory available
+ if ((length - len_all) > (tap_buffer_size * 8 - tap_length)) {
+ /* Use all memory available
vsllink_tap_append_step will commit automatically */
len_tmp = tap_buffer_size * 8 - tap_length;
pending_scan_result->last = false;
- }
- else
- {
+ } else {
len_tmp = length - len_all;
pending_scan_result->last = true;
}
pending_scan_result->buffer = buffer;
pending_scan_results_length++;
- for (i = 0; i < len_tmp; i++)
- {
- vsllink_tap_append_step(((len_all + i) < length-1 ? 0 : 1), \
- (buffer[(len_all + i)/8] >> ((len_all + i)%8)) & 1);
+ for (i = 0; i < len_tmp; i++) {
+ vsllink_tap_append_step(((len_all + i) < length-1
+ ? 0 : 1),
+ (buffer[(len_all + i)/8]
+ >> ((len_all + i)%8)) & 1);
}
len_all += len_tmp;
int result;
if (tap_length <= 0)
- {
return ERROR_OK;
- }
/* Pad data so that tap_length is divisible by 8 */
- if ((tap_length % 8) != 0)
- {
- if (vsllink_tms_offset > 0)
- {
- /* append tms:0 at vsllink_tms_offset, which is in Pause */
+ if ((tap_length % 8) != 0) {
+ if (vsllink_tms_offset > 0) {
+ /* append tms:0 at vsllink_tms_offset,
+ * which is in Pause
+ */
int start_pos = DIV_ROUND_UP(tap_length, 8) - 1;
int end_pos = DIV_ROUND_UP(vsllink_tms_offset, 8) - 1;
int shift_cnt = (start_pos + 1) * 8 - tap_length;
- uint8_t last_mask = ~((1 << (vsllink_tms_offset % 8)) - 1);
-
- while (1)
- {
- if (start_pos == end_pos)
- {
- tms_buffer[start_pos] = \
- (tms_buffer[start_pos] & ~last_mask) | \
- ((tms_buffer[start_pos] & last_mask) << shift_cnt);
- tdi_buffer[start_pos] = \
- (tdi_buffer[start_pos] & ~last_mask) | \
- ((tdi_buffer[start_pos] & last_mask) << shift_cnt);
+ uint8_t last_mask = ~(
+ (1 << (vsllink_tms_offset % 8)) - 1);
+
+ while (1) {
+ if (start_pos == end_pos) {
+ tms_buffer[start_pos] =
+ (tms_buffer[start_pos]
+ & ~last_mask)
+ | ((tms_buffer[start_pos]
+ & last_mask)
+ << shift_cnt);
+ tdi_buffer[start_pos] =
+ (tdi_buffer[start_pos]
+ & ~last_mask)
+ |
+ ((tdi_buffer[start_pos]
+ & last_mask)
+ << shift_cnt);
break;
- }
- else if (start_pos == (end_pos + 1))
- {
- tms_buffer[start_pos] = \
- (tms_buffer[start_pos] << shift_cnt) | \
- ((tms_buffer[start_pos - 1] & last_mask) >> (8 - shift_cnt));
- tdi_buffer[start_pos] = \
- (tdi_buffer[start_pos] << shift_cnt) | \
- ((tdi_buffer[start_pos - 1] & last_mask) >> (8 - shift_cnt));
- }
- else
- {
- tms_buffer[start_pos] = \
- (tms_buffer[start_pos] << shift_cnt) | \
- (tms_buffer[start_pos - 1] >> (8 - shift_cnt));
- tdi_buffer[start_pos] = \
- (tdi_buffer[start_pos] << shift_cnt) | \
- (tdi_buffer[start_pos - 1] >> (8 - shift_cnt));
+ } else if (start_pos == (end_pos + 1)) {
+ tms_buffer[start_pos] =
+ (tms_buffer[start_pos]
+ << shift_cnt) |
+ ((tms_buffer[start_pos - 1]
+ & last_mask)
+ >> (8 - shift_cnt));
+ tdi_buffer[start_pos] =
+ (tdi_buffer[start_pos]
+ << shift_cnt) |
+ ((tdi_buffer[start_pos - 1]
+ & last_mask)
+ >> (8 - shift_cnt));
+ } else {
+ tms_buffer[start_pos] =
+ (tms_buffer[start_pos]
+ << shift_cnt) |
+ (tms_buffer[start_pos - 1]
+ >> (8 - shift_cnt));
+ tdi_buffer[start_pos] =
+ (tdi_buffer[start_pos]
+ << shift_cnt) |
+ (tdi_buffer[start_pos - 1]
+ >> (8 - shift_cnt));
}
start_pos--;
}
tap_length = DIV_ROUND_UP(tap_length, 8) * 8;
- }
- else
- {
+ } else {
/* append data at last */
- while ((tap_length % 8) != 0)
- {
- vsllink_tap_append_step((tap_get_state() == TAP_RESET)?1:0, 0);
+ while ((tap_length % 8) != 0) {
+ vsllink_tap_append_step(
+ (tap_get_state() == TAP_RESET)
+ ? 1 : 0, 0);
}
}
}
vsllink_usb_out_buffer[2] = ((byte_length * 2 + 3) >> 8) & 0xff;
memcpy(&vsllink_usb_out_buffer[3], tdi_buffer, byte_length);
- memcpy(&vsllink_usb_out_buffer[3 + byte_length], tms_buffer, byte_length);
+ memcpy(&vsllink_usb_out_buffer[3 + byte_length], tms_buffer,
+ byte_length);
- result = vsllink_usb_message(vsllink_handle, 3 + 2 * byte_length, \
- byte_length);
+ result = vsllink_usb_message(vsllink_handle, 3 + 2 * byte_length,
+ byte_length);
- if (result == byte_length)
- {
- for (i = 0; i < pending_scan_results_length; i++)
- {
- struct pending_scan_result *pending_scan_result = \
- &pending_scan_results_buffer[i];
+ if (result == byte_length) {
+ for (i = 0; i < pending_scan_results_length; i++) {
+ struct pending_scan_result *pending_scan_result =
+ &pending_scan_results_buffer[i];
uint8_t *buffer = pending_scan_result->buffer;
int length = pending_scan_result->length;
int src_first = pending_scan_result->src_offset;
int dest_first = pending_scan_result->dest_offset;
bool last = pending_scan_result->last;
- struct scan_command *command = pending_scan_result->command;
- buf_set_buf(vsllink_usb_in_buffer, src_first, buffer, \
+ struct scan_command *command;
+
+ command = pending_scan_result->command;
+ buf_set_buf(vsllink_usb_in_buffer, src_first, buffer,
dest_first, length);
- DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):", \
- length, dest_first);
+ DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):",
+ length, dest_first);
#ifdef _DEBUG_JTAG_IO_
- vsllink_debug_buffer(buffer + dest_first / 8, DIV_ROUND_UP(length, 7));
+ vsllink_debug_buffer(buffer + dest_first / 8,
+ DIV_ROUND_UP(length, 7));
#endif
- if (last)
- {
- if (jtag_read_buffer(buffer, command) != ERROR_OK)
- {
+ if (last) {
+ if (jtag_read_buffer(buffer, command)
+ != ERROR_OK) {
vsllink_tap_init();
return ERROR_JTAG_QUEUE_FAILED;
}
if (pending_scan_result->buffer != NULL)
- {
free(pending_scan_result->buffer);
- }
}
}
- }
- else
- {
- LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", \
+ } else {
+ LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d",
result, byte_length);
return ERROR_JTAG_QUEUE_FAILED;
}
/*****************************************************************************/
/* VSLLink USB low-level functions */
-static struct vsllink* vsllink_usb_open(void)
+static struct vsllink *vsllink_usb_open(void)
{
usb_init();
/* usb_set_configuration required under win32 */
struct usb_device *udev = usb_device(dev);
- int ret = usb_set_configuration(dev, udev->config[0].bConfigurationValue);
- if (ret != 0)
- {
+ int ret = usb_set_configuration(dev,
+ udev->config[0].bConfigurationValue);
+ if (ret != 0) {
LOG_ERROR("fail to set configuration to %d (error %d)."
"Not enough permissions for the device?",
udev->config[0].bConfigurationValue, ret);
return NULL;
}
ret = usb_claim_interface(dev, vsllink_usb_interface);
- if (ret != 0)
- {
+ if (ret != 0) {
LOG_ERROR("fail to claim interface %d, %d returned",
vsllink_usb_interface, ret);
return NULL;
{
int ret;
- ret = usb_release_interface(vsllink->usb_handle, vsllink_usb_interface);
- if (ret != 0)
- {
- LOG_ERROR("fail to release interface %d, %d returned", \
+ ret = usb_release_interface(vsllink->usb_handle,
+ vsllink_usb_interface);
+ if (ret != 0) {
+ LOG_ERROR("fail to release interface %d, %d returned",
vsllink_usb_interface, ret);
exit(-1);
}
ret = usb_close(vsllink->usb_handle);
- if (ret != 0)
- {
+ if (ret != 0) {
LOG_ERROR("fail to close usb, %d returned", ret);
exit(-1);
}
}
/* Send a message and receive the reply. */
-static int vsllink_usb_message(struct vsllink *vsllink, int out_length, \
+static int vsllink_usb_message(struct vsllink *vsllink, int out_length,
int in_length)
{
int result;
result = vsllink_usb_write(vsllink, out_length);
- if (result == out_length)
- {
- if (in_length > 0)
- {
+ if (result == out_length) {
+ if (in_length > 0) {
result = vsllink_usb_read(vsllink);
if (result == in_length)
- {
return result;
- }
- else
- {
- LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", \
+ else {
+ LOG_ERROR("usb_bulk_read failed "
+ "(requested=%d, result=%d)",
in_length, result);
return -1;
}
}
return 0;
- }
- else
- {
- LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", \
+ } else {
+ LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)",
out_length, result);
return -1;
}
{
int result;
- if (out_length > vsllink_buffer_size)
- {
- LOG_ERROR("vsllink_write illegal out_length=%d (max=%d)", \
+ if (out_length > vsllink_buffer_size) {
+ LOG_ERROR("vsllink_write illegal out_length=%d (max=%d)",
out_length, vsllink_buffer_size);
return -1;
}
- result = usb_bulk_write(vsllink->usb_handle, vsllink_usb_bulkout, \
- (char *)vsllink_usb_out_buffer, out_length, VSLLINK_USB_TIMEOUT);
+ result = usb_bulk_write(vsllink->usb_handle, vsllink_usb_bulkout,
+ (char *)vsllink_usb_out_buffer, out_length,
+ VSLLINK_USB_TIMEOUT);
- DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d", \
+ DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d",
out_length, result);
#ifdef _DEBUG_USB_COMMS_
/* Read data from USB into in_buffer. */
static int vsllink_usb_read(struct vsllink *vsllink)
{
- int result = usb_bulk_read(vsllink->usb_handle, vsllink_usb_bulkin, \
- (char *)vsllink_usb_in_buffer, vsllink_buffer_size, \
+ int result = usb_bulk_read(vsllink->usb_handle, vsllink_usb_bulkin,
+ (char *)vsllink_usb_in_buffer, vsllink_buffer_size,
VSLLINK_USB_TIMEOUT);
DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result);
int i;
int j;
- for (i = 0; i < length; i += BYTES_PER_LINE)
- {
+ for (i = 0; i < length; i += BYTES_PER_LINE) {
snprintf(line, 5, "%04x", i);
- for (j = i; j < i + BYTES_PER_LINE && j < length; j++)
- {
+ for (j = i; j < i + BYTES_PER_LINE && j < length; j++) {
snprintf(s, 4, " %02x", buffer[j]);
strcat(line, s);
}
LOG_DEBUG("%s", line);
}
}
-#endif // _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_
+#endif /* _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_ */
static const struct command_registration vsllink_command_handlers[] = {
{
Code Review / openocd.git / commitdiff