static void ftdi_execute_sleep(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
mpsse_flush(mpsse_ctx);
jtag_sleep(cmd->cmd.sleep->us);
DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
cmd->cmd.sleep->us,
tap_state_name(tap_get_state()));
}
static int ftdi_execute_sleep(struct jtag_command *cmd)
{
int retval = ERROR_OK;
DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
retval = mpsse_flush(mpsse_ctx);
jtag_sleep(cmd->cmd.sleep->us);
DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
cmd->cmd.sleep->us,
tap_state_name(tap_get_state()));
return retval;
}
static int jtag_vpi_execute_queue(void)
{
struct jtag_command *cmd;
int ret = ERROR_OK;
for (cmd = jtag_command_queue; ret == ERROR_OK && cmd != NULL;
cmd = cmd->next) {
switch (cmd->type) {
case JTAG_RESET:
LOG_DEBUG("--> JTAG_RESET");
jtag_vpi_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
break;
case JTAG_RUNTEST:
LOG_DEBUG("--> JTAG_RUNTEST");
jtag_vpi_runtest(cmd->cmd.runtest->num_cycles,
cmd->cmd.runtest->end_state);
break;
case JTAG_STABLECLOCKS:
LOG_DEBUG("--> JTAG_STABLECLOCKS");
jtag_vpi_stableclocks(cmd->cmd.stableclocks->num_cycles);
break;
case JTAG_TLR_RESET:
LOG_DEBUG("--> JTAG_TLR_RESET");
jtag_vpi_state_move(cmd->cmd.statemove->end_state);
break;
case JTAG_PATHMOVE:
LOG_DEBUG("--> JTAG_PATHMOVE");
jtag_vpi_path_move(cmd->cmd.pathmove);
break;
case JTAG_TMS:
LOG_DEBUG("--> JTAG_TMS");
jtag_vpi_tms(cmd->cmd.tms);
break;
case JTAG_SLEEP:
LOG_DEBUG("--> JTAG_SLEEP");
jtag_sleep(cmd->cmd.sleep->us);
break;
case JTAG_SCAN:
LOG_DEBUG("--> JTAG_SCAN");
ret = jtag_vpi_scan(cmd->cmd.scan);
break;
}
}
return ret;
}
static int presto_bitq_sleep(unsigned long us)
{
long waits;
presto_tdi_flush();
presto_tck_idle();
if (us > 100000) {
presto_bitq_flush();
jtag_sleep(us);
return 0;
}
waits = us / 170 + 2;
while (waits--)
presto_sendbyte(0x80);
return 0;
}
static int usbp5_execute_queue(void)
{
struct jtag_command *cmd;
int retval = ERROR_OK;
for (cmd = jtag_command_queue; retval == ERROR_OK && cmd != NULL;
cmd = cmd->next) {
switch (cmd->type) {
case JTAG_RESET:
retval = usbp5_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
break;
case JTAG_RUNTEST:
retval = usbp5_runtest(cmd->cmd.runtest->num_cycles,
cmd->cmd.runtest->end_state);
break;
case JTAG_STABLECLOCKS:
retval = usbp5_stableclocks(cmd->cmd.stableclocks->num_cycles);
break;
case JTAG_TLR_RESET:
retval = usbp5_state_move(cmd->cmd.statemove->end_state);
break;
case JTAG_PATHMOVE:
retval = usbp5_path_move(cmd->cmd.pathmove);
break;
case JTAG_TMS:
retval = usbp5_tms(cmd->cmd.tms);
break;
case JTAG_SLEEP:
jtag_sleep(cmd->cmd.sleep->us);
break;
case JTAG_SCAN:
retval = usbp5_scan(cmd->cmd.scan);
break;
default:
fprintf(stderr,"[usbprog5] unhandled command: %d\n",cmd->type);
exit(23);
}
}
return retval;
}
static int jlink_init(void)
{
int ret;
struct jaylink_device **devs;
unsigned int i;
bool found_device;
uint32_t tmp;
char *firmware_version;
struct jaylink_hardware_version hwver;
struct jaylink_hardware_status hwstatus;
ret = jaylink_init(&jayctx);
if (ret != JAYLINK_OK) {
LOG_ERROR("jaylink_init() failed: %s.",
jaylink_strerror_name(ret));
return ERROR_JTAG_INIT_FAILED;
}
ret = jaylink_get_device_list(jayctx, &devs);
if (ret < 0) {
LOG_ERROR("jaylink_get_device_list() failed: %s.",
jaylink_strerror_name(ret));
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
found_device = false;
if (!use_serial_number && !use_usb_address)
LOG_INFO("No device selected, using first device.");
for (i = 0; devs[i]; i++) {
jaylink_device_get_serial_number(devs[i], &tmp);
ret = jaylink_device_get_usb_address(devs[i]);
if (use_usb_address && usb_address != ret)
continue;
if (use_serial_number && tmp != serial_number)
continue;
ret = jaylink_open(devs[i], &devh);
if (ret != JAYLINK_OK) {
LOG_ERROR("Failed to open device: %s.", jaylink_strerror_name(ret));
continue;
}
found_device = true;
break;
}
jaylink_free_device_list(devs, 1);
if (!found_device) {
LOG_ERROR("No J-Link device found.");
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
/*
* Be careful with changing the following initialization sequence because
* some devices are known to be sensitive regarding the order.
*/
ret = jaylink_get_firmware_version(devh, &firmware_version);
if (ret > 0) {
LOG_INFO("%s", firmware_version);
free(firmware_version);
} else if (!ret) {
LOG_WARNING("Device responds empty firmware version string.");
} else {
LOG_ERROR("jaylink_get_firmware_version() failed: %s.",
jaylink_strerror_name(ret));
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
memset(caps, 0, JAYLINK_DEV_EXT_CAPS_SIZE);
ret = jaylink_get_caps(devh, caps);
if (ret != JAYLINK_OK) {
LOG_ERROR("jaylink_get_caps() failed: %s.", jaylink_strerror_name(ret));
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_EXT_CAPS)) {
ret = jaylink_get_extended_caps(devh, caps);
if (ret != JAYLINK_OK) {
LOG_ERROR("jaylink_get_extended_caps() failed: %s.",
jaylink_strerror_name(ret));
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
}
jtag_command_version = JAYLINK_JTAG_V2;
if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_HW_VERSION)) {
ret = jaylink_get_hardware_version(devh, &hwver);
if (ret != JAYLINK_OK) {
LOG_ERROR("Failed to retrieve hardware version: %s.",
jaylink_strerror_name(ret));
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
LOG_INFO("Hardware version: %u.%02u", hwver.major, hwver.minor);
if (hwver.major >= 5)
jtag_command_version = JAYLINK_JTAG_V3;
}
if (iface == JAYLINK_TIF_SWD) {
/*
* Adjust the SWD transaction buffer size in case there is already
* allocated memory on the device. This happens for example if the
* memory for SWO capturing is still allocated because the software
* which used the device before has not been shut down properly.
*/
if (!adjust_swd_buffer_size()) {
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
}
if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
if (!read_device_config(&config)) {
LOG_ERROR("Failed to read device configuration data.");
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
memcpy(&tmp_config, &config, sizeof(struct device_config));
}
ret = jaylink_get_hardware_status(devh, &hwstatus);
if (ret != JAYLINK_OK) {
LOG_ERROR("jaylink_get_hardware_status() failed: %s.",
jaylink_strerror_name(ret));
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
LOG_INFO("VTarget = %u.%03u V", hwstatus.target_voltage / 1000,
hwstatus.target_voltage % 1000);
conn.handle = 0;
conn.pid = 0;
conn.hid = 0;
conn.iid = 0;
conn.cid = 0;
ret = jlink_register();
if (ret != ERROR_OK) {
jaylink_close(devh);
jaylink_exit(jayctx);
return ERROR_JTAG_INIT_FAILED;
}
ret = select_interface();
if (ret != ERROR_OK) {
jaylink_close(devh);
jaylink_exit(jayctx);
return ret;
}
jlink_reset(0, 0);
jtag_sleep(3000);
jlink_tap_init();
jlink_speed(jtag_get_speed_khz());
if (iface == JAYLINK_TIF_JTAG) {
/*
* J-Link devices with firmware version v5 and v6 seems to have an issue
* if the first tap move is not divisible by 8, so we send a TLR on
* first power up.
*/
uint8_t tms = 0xff;
jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 8);
jlink_flush();
}
return ERROR_OK;
}
static void jlink_execute_sleep(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
jlink_flush();
jtag_sleep(cmd->cmd.sleep->us);
}
static int vsllink_execute_queue(void)
{
struct jtag_command *cmd = jtag_command_queue;
int scan_size;
enum scan_type type;
uint8_t *buffer;
DEBUG_JTAG_IO("-------------------------------------"
" vsllink "
"-------------------------------------");
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));
vsllink_end_state(cmd->cmd.runtest->end_state);
vsllink_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_TLR_RESET:
DEBUG_JTAG_IO("statemove end in %s",
tap_state_name(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);
break;
case JTAG_SCAN:
DEBUG_JTAG_IO("JTAG Scan...");
vsllink_end_state(cmd->cmd.scan->end_state);
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));
else
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));
#endif
type = jtag_scan_type(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);
vsllink_tap_execute();
if (cmd->cmd.reset->trst == 1)
tap_set_state(TAP_RESET);
vsllink_reset(cmd->cmd.reset->trst,
cmd->cmd.reset->srst);
break;
case JTAG_SLEEP:
DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
vsllink_tap_execute();
jtag_sleep(cmd->cmd.sleep->us);
break;
case JTAG_STABLECLOCKS:
DEBUG_JTAG_IO("add %d clocks",
cmd->cmd.stableclocks->num_cycles);
switch (tap_get_state()) {
case TAP_RESET:
/* tms must be '1' to stay
* n TAP_RESET mode
*/
scan_size = 1;
break;
case TAP_DRSHIFT:
case TAP_IDLE:
case TAP_DRPAUSE:
case TAP_IRSHIFT:
case TAP_IRPAUSE:
/* else, tms should be '0' */
scan_size = 0;
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);
}
vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size);
break;
case JTAG_TMS:
DEBUG_JTAG_IO("add %d jtag tms",
cmd->cmd.tms->num_bits);
vsllink_tms(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
break;
default:
LOG_ERROR("BUG: unknown JTAG command type "
"encountered: %d", cmd->type);
exit(-1);
}
cmd = cmd->next;
}
return vsllink_tap_execute();
}
int interface_jtag_add_sleep(uint32_t us)
{
jtag_sleep(us);
return ERROR_OK;
}
