imi415/openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ec297e4bf1
openocd/src/jtag/tcl.c
David Brownell 2c3e413d49 JTAG: shrink "scan_chain" output 
Tweak the "scan_chain" output by removing column separators.  Also
remove the "current instruction" state ... which changes constantly.

Now its style resembles the "targets" output, and can even fit on
one line in standard terminals and in the PDF docs.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
2009-12-16 14:19:44 -08:00

1705 lines
41 KiB
C
Raw Blame History

/***************************************************************************
* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* Copyright (C) 2007,2008 Øyvind Harboe *
* oyvind.harboe@zylin.com *
* *
* Copyright (C) 2009 SoftPLC Corporation *
* http://softplc.com *
* dick@softplc.com *
* *
* Copyright (C) 2009 Zachary T Welch *
* zw@superlucidity.net *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "jtag.h"
#include "minidriver.h"
#include "interface.h"
#include "interfaces.h"
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
static const Jim_Nvp nvp_jtag_tap_event[] = {
{ .value = JTAG_TRST_ASSERTED, .name = "post-reset" },
{ .value = JTAG_TAP_EVENT_SETUP, .name = "setup" },
{ .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
{ .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
{ .name = NULL, .value = -1 }
};
extern struct jtag_interface *jtag_interface;
struct jtag_tap *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
{
const char *cp = Jim_GetString(o, NULL);
struct jtag_tap *t = cp ? jtag_tap_by_string(cp) : NULL;
if (NULL == cp)
cp = "(unknown)";
if (NULL == t)
Jim_SetResult_sprintf(interp, "Tap '%s' could not be found", cp);
return t;
}
static bool scan_is_safe(tap_state_t state)
{
switch (state)
{
case TAP_RESET:
case TAP_IDLE:
case TAP_DRPAUSE:
case TAP_IRPAUSE:
return true;
default:
return false;
}
}
static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
{
int retval;
struct scan_field *fields;
int num_fields;
int field_count = 0;
int i, e;
struct jtag_tap *tap;
tap_state_t endstate;
/* args[1] = device
* args[2] = num_bits
* args[3] = hex string
* ... repeat num bits and hex string ...
*
* .. optionally:
* args[N-2] = "-endstate"
* args[N-1] = statename
*/
if ((argc < 4) || ((argc % 2) != 0))
{
Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
return JIM_ERR;
}
endstate = TAP_IDLE;
script_debug(interp, "drscan", argc, args);
/* validate arguments as numbers */
e = JIM_OK;
for (i = 2; i < argc; i += 2)
{
long bits;
const char *cp;
e = Jim_GetLong(interp, args[i], &bits);
/* If valid - try next arg */
if (e == JIM_OK) {
continue;
}
/* Not valid.. are we at the end? */
if (((i + 2) != argc)) {
/* nope, then error */
return e;
}
/* it could be: "-endstate FOO"
* e.g. DRPAUSE so we can issue more instructions
* before entering RUN/IDLE and executing them.
*/
/* get arg as a string. */
cp = Jim_GetString(args[i], NULL);
/* is it the magic? */
if (0 == strcmp("-endstate", cp)) {
/* is the statename valid? */
cp = Jim_GetString(args[i + 1], NULL);
/* see if it is a valid state name */
endstate = tap_state_by_name(cp);
if (endstate < 0) {
/* update the error message */
Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
} else {
if (!scan_is_safe(endstate))
LOG_WARNING("drscan with unsafe "
"endstate \"%s\"", cp);
/* valid - so clear the error */
e = JIM_OK;
/* and remove the last 2 args */
argc -= 2;
}
}
/* Still an error? */
if (e != JIM_OK) {
return e; /* too bad */
}
} /* validate args */
tap = jtag_tap_by_jim_obj(interp, args[1]);
if (tap == NULL) {
return JIM_ERR;
}
num_fields = (argc-2)/2;
fields = malloc(sizeof(struct scan_field) * num_fields);
for (i = 2; i < argc; i += 2)
{
long bits;
int len;
const char *str;
Jim_GetLong(interp, args[i], &bits);
str = Jim_GetString(args[i + 1], &len);
fields[field_count].tap = tap;
fields[field_count].num_bits = bits;
fields[field_count].out_value = malloc(DIV_ROUND_UP(bits, 8));
str_to_buf(str, len, fields[field_count].out_value, bits, 0);
fields[field_count].in_value = fields[field_count].out_value;
field_count++;
}
jtag_add_dr_scan(num_fields, fields, endstate);
retval = jtag_execute_queue();
if (retval != ERROR_OK)
{
Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
return JIM_ERR;
}
field_count = 0;
Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
for (i = 2; i < argc; i += 2)
{
long bits;
char *str;
Jim_GetLong(interp, args[i], &bits);
str = buf_to_str(fields[field_count].in_value, bits, 16);
free(fields[field_count].out_value);
Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
free(str);
field_count++;
}
Jim_SetResult(interp, list);
free(fields);
return JIM_OK;
}
static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
{
tap_state_t states[8];
if ((argc < 2) || ((size_t)argc > (ARRAY_SIZE(states) + 1)))
{
Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
return JIM_ERR;
}
script_debug(interp, "pathmove", argc, args);
int i;
for (i = 0; i < argc-1; i++)
{
const char *cp;
cp = Jim_GetString(args[i + 1], NULL);
states[i] = tap_state_by_name(cp);
if (states[i] < 0)
{
/* update the error message */
Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
return JIM_ERR;
}
}
if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
{
Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
return JIM_ERR;
}
jtag_add_pathmove(argc-2, states + 1);
if (jtag_execute_queue()!= ERROR_OK)
{
Jim_SetResultString(interp, "pathmove: failed",-1);
return JIM_ERR;
}
return JIM_OK;
}
static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
{
script_debug(interp, "flush_count", argc, args);
Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
return JIM_OK;
}
static const struct command_registration jtag_command_handlers_to_move[] = {
{
.name = "drscan",
.mode = COMMAND_EXEC,
.jim_handler = &Jim_Command_drscan,
.help = "execute DR scan <device> "
"<num_bits> <value> <num_bits1> <value2> ...",
},
{
.name = "flush_count",
.mode = COMMAND_EXEC,
.jim_handler = &Jim_Command_flush_count,
.help = "returns number of times the JTAG queue has been flushed",
},
{
.name = "pathmove",
.mode = COMMAND_EXEC,
.jim_handler = &Jim_Command_pathmove,
.usage = "<state1>,<state2>,<state3>... ",
.help = "move JTAG to state1 then to state2, state3, etc.",
},
COMMAND_REGISTRATION_DONE
};
enum jtag_tap_cfg_param {
JCFG_EVENT
};
static Jim_Nvp nvp_config_opts[] = {
{ .name = "-event", .value = JCFG_EVENT },
{ .name = NULL, .value = -1 }
};
static int jtag_tap_configure_event(Jim_GetOptInfo *goi, struct jtag_tap * tap)
{
if (goi->argc == 0)
{
Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name> ...");
return JIM_ERR;
}
Jim_Nvp *n;
int e = Jim_GetOpt_Nvp(goi, nvp_jtag_tap_event, &n);
if (e != JIM_OK)
{
Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
return e;
}
if (goi->isconfigure) {
if (goi->argc != 1) {
Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name> <event-body>");
return JIM_ERR;
}
} else {
if (goi->argc != 0) {
Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name>");
return JIM_ERR;
}
}
struct jtag_tap_event_action *jteap = tap->event_action;
/* replace existing event body */
bool found = false;
while (jteap)
{
if (jteap->event == (enum jtag_event)n->value)
{
found = true;
break;
}
jteap = jteap->next;
}
Jim_SetEmptyResult(goi->interp);
if (goi->isconfigure)
{
if (!found)
jteap = calloc(1, sizeof(*jteap));
else if (NULL != jteap->body)
Jim_DecrRefCount(goi->interp, jteap->body);
jteap->interp = goi->interp;
jteap->event = n->value;
Jim_Obj *o;
Jim_GetOpt_Obj(goi, &o);
jteap->body = Jim_DuplicateObj(goi->interp, o);
Jim_IncrRefCount(jteap->body);
if (!found)
{
/* add to head of event list */
jteap->next = tap->event_action;
tap->event_action = jteap;
}
}
else if (found)
{
jteap->interp = goi->interp;
Jim_SetResult(goi->interp,
Jim_DuplicateObj(goi->interp, jteap->body));
}
return JIM_OK;
}
static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, struct jtag_tap * tap)
{
/* parse config or cget options */
while (goi->argc > 0)
{
Jim_SetEmptyResult (goi->interp);
Jim_Nvp *n;
int e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
if (e != JIM_OK)
{
Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
return e;
}
switch (n->value)
{
case JCFG_EVENT:
e = jtag_tap_configure_event(goi, tap);
if (e != JIM_OK)
return e;
break;
default:
Jim_SetResult_sprintf(goi->interp, "unknown event: %s", n->name);
return JIM_ERR;
}
}
return JIM_OK;
}
static int is_bad_irval(int ir_length, jim_wide w)
{
jim_wide v = 1;
v <<= ir_length;
v -= 1;
v = ~v;
return (w & v) != 0;
}
static int jim_newtap_expected_id(Jim_Nvp *n, Jim_GetOptInfo *goi,
struct jtag_tap *pTap)
{
jim_wide w;
int e = Jim_GetOpt_Wide(goi, &w);
if (e != JIM_OK) {
Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
return e;
}
unsigned expected_len = sizeof(uint32_t) * pTap->expected_ids_cnt;
uint32_t *new_expected_ids = malloc(expected_len + sizeof(uint32_t));
if (new_expected_ids == NULL)
{
Jim_SetResult_sprintf(goi->interp, "no memory");
return JIM_ERR;
}
memcpy(new_expected_ids, pTap->expected_ids, expected_len);
new_expected_ids[pTap->expected_ids_cnt] = w;
free(pTap->expected_ids);
pTap->expected_ids = new_expected_ids;
pTap->expected_ids_cnt++;
return JIM_OK;
}
#define NTAP_OPT_IRLEN 0
#define NTAP_OPT_IRMASK 1
#define NTAP_OPT_IRCAPTURE 2
#define NTAP_OPT_ENABLED 3
#define NTAP_OPT_DISABLED 4
#define NTAP_OPT_EXPECTED_ID 5
#define NTAP_OPT_VERSION 6
static int jim_newtap_ir_param(Jim_Nvp *n, Jim_GetOptInfo *goi,
struct jtag_tap *pTap)
{
jim_wide w;
int e = Jim_GetOpt_Wide(goi, &w);
if (e != JIM_OK)
{
Jim_SetResult_sprintf(goi->interp,
"option: %s bad parameter", n->name);
free((void *)pTap->dotted_name);
return e;
}
switch (n->value) {
case NTAP_OPT_IRLEN:
if (w > (jim_wide) (8 * sizeof(pTap->ir_capture_value)))
{
LOG_WARNING("%s: huge IR length %d",
pTap->dotted_name, (int) w);
}
pTap->ir_length = w;
break;
case NTAP_OPT_IRMASK:
if (is_bad_irval(pTap->ir_length, w))
{
LOG_ERROR("%s: IR mask %x too big",
pTap->dotted_name,
(int) w);
return JIM_ERR;
}
if ((w & 3) != 3)
LOG_WARNING("%s: nonstandard IR mask", pTap->dotted_name);
pTap->ir_capture_mask = w;
break;
case NTAP_OPT_IRCAPTURE:
if (is_bad_irval(pTap->ir_length, w))
{
LOG_ERROR("%s: IR capture %x too big",
pTap->dotted_name, (int) w);
return JIM_ERR;
}
if ((w & 3) != 1)
LOG_WARNING("%s: nonstandard IR value",
pTap->dotted_name);
pTap->ir_capture_value = w;
break;
default:
return JIM_ERR;
}
return JIM_OK;
}
static int jim_newtap_cmd(Jim_GetOptInfo *goi)
{
struct jtag_tap *pTap;
int x;
int e;
Jim_Nvp *n;
char *cp;
const Jim_Nvp opts[] = {
{ .name = "-irlen" , .value = NTAP_OPT_IRLEN },
{ .name = "-irmask" , .value = NTAP_OPT_IRMASK },
{ .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
{ .name = "-enable" , .value = NTAP_OPT_ENABLED },
{ .name = "-disable" , .value = NTAP_OPT_DISABLED },
{ .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
{ .name = "-ignore-version" , .value = NTAP_OPT_VERSION },
{ .name = NULL , .value = -1 },
};
pTap = calloc(1, sizeof(struct jtag_tap));
if (!pTap) {
Jim_SetResult_sprintf(goi->interp, "no memory");
return JIM_ERR;
}
/*
* we expect CHIP + TAP + OPTIONS
* */
if (goi->argc < 3) {
Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
free(pTap);
return JIM_ERR;
}
Jim_GetOpt_String(goi, &cp, NULL);
pTap->chip = strdup(cp);
Jim_GetOpt_String(goi, &cp, NULL);
pTap->tapname = strdup(cp);
/* name + dot + name + null */
x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
cp = malloc(x);
sprintf(cp, "%s.%s", pTap->chip, pTap->tapname);
pTap->dotted_name = cp;
LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
/* IEEE specifies that the two LSBs of an IR scan are 01, so make
* that the default. The "-irlen" and "-irmask" options are only
* needed to cope with nonstandard TAPs, or to specify more bits.
*/
pTap->ir_capture_mask = 0x03;
pTap->ir_capture_value = 0x01;
while (goi->argc) {
e = Jim_GetOpt_Nvp(goi, opts, &n);
if (e != JIM_OK) {
Jim_GetOpt_NvpUnknown(goi, opts, 0);
free((void *)pTap->dotted_name);
free(pTap);
return e;
}
LOG_DEBUG("Processing option: %s", n->name);
switch (n->value) {
case NTAP_OPT_ENABLED:
pTap->disabled_after_reset = false;
break;
case NTAP_OPT_DISABLED:
pTap->disabled_after_reset = true;
break;
case NTAP_OPT_EXPECTED_ID:
e = jim_newtap_expected_id(n, goi, pTap);
if (JIM_OK != e)
{
free((void *)pTap->dotted_name);
free(pTap);
return e;
}
break;
case NTAP_OPT_IRLEN:
case NTAP_OPT_IRMASK:
case NTAP_OPT_IRCAPTURE:
e = jim_newtap_ir_param(n, goi, pTap);
if (JIM_OK != e)
{
free((void *)pTap->dotted_name);
free(pTap);
return e;
}
break;
case NTAP_OPT_VERSION:
pTap->ignore_version = true;
break;
} /* switch (n->value) */
} /* while (goi->argc) */
/* default is enabled-after-reset */
pTap->enabled = !pTap->disabled_after_reset;
/* Did all the required option bits get cleared? */
if (pTap->ir_length != 0)
{
jtag_tap_init(pTap);
return ERROR_OK;
}
Jim_SetResult_sprintf(goi->interp,
"newtap: %s missing IR length",
pTap->dotted_name);
jtag_tap_free(pTap);
return JIM_ERR;
}
static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e)
{
struct jtag_tap_event_action * jteap;
for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next)
{
if (jteap->event != e)
continue;
Jim_Nvp *nvp = Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e);
LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
tap->dotted_name, e, nvp->name,
Jim_GetString(jteap->body, NULL));
if (Jim_EvalObj(jteap->interp, jteap->body) != JIM_OK)
{
Jim_PrintErrorMessage(jteap->interp);
continue;
}
switch (e)
{
case JTAG_TAP_EVENT_ENABLE:
case JTAG_TAP_EVENT_DISABLE:
/* NOTE: we currently assume the handlers
* can't fail. Right here is where we should
* really be verifying the scan chains ...
*/
tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
tap->enabled ? "enabled" : "disabled");
break;
default:
break;
}
}
}
static int jim_jtag_interface(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
/* return the name of the interface */
/* TCL code might need to know the exact type... */
/* FUTURE: we allow this as a means to "set" the interface. */
if (goi.argc != 0) {
Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
return JIM_ERR;
}
const char *name = jtag_interface ? jtag_interface->name : NULL;
Jim_SetResultString(goi.interp, name ? : "undefined", -1);
return JIM_OK;
}
static int jim_jtag_arp_init(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
if (goi.argc != 0) {
Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
return JIM_ERR;
}
struct command_context *context = Jim_GetAssocData(interp, "context");
int e = jtag_init_inner(context);
if (e != ERROR_OK) {
Jim_SetResult_sprintf(goi.interp, "error: %d", e);
return JIM_ERR;
}
return JIM_OK;
}
static int jim_jtag_arp_init_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
if (goi.argc != 0) {
Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
return JIM_ERR;
}
struct command_context *context = Jim_GetAssocData(interp, "context");
int e = jtag_init_reset(context);
if (e != ERROR_OK) {
Jim_SetResult_sprintf(goi.interp, "error: %d", e);
return JIM_ERR;
}
return JIM_OK;
}
static int jim_jtag_newtap(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
return jim_newtap_cmd(&goi);
}
static bool jtag_tap_enable(struct jtag_tap *t)
{
if (t->enabled)
return false;
jtag_tap_handle_event(t, JTAG_TAP_EVENT_ENABLE);
if (!t->enabled)
return false;
/* FIXME add JTAG sanity checks, w/o TLR
* - scan chain length grew by one (this)
* - IDs and IR lengths are as expected
*/
jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE);
return true;
}
static bool jtag_tap_disable(struct jtag_tap *t)
{
if (!t->enabled)
return false;
jtag_tap_handle_event(t, JTAG_TAP_EVENT_DISABLE);
if (t->enabled)
return false;
/* FIXME add JTAG sanity checks, w/o TLR
* - scan chain length shrank by one (this)
* - IDs and IR lengths are as expected
*/
jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE);
return true;
}
static int jim_jtag_tap_enabler(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
const char *cmd_name = Jim_GetString(argv[0], NULL);
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
if (goi.argc != 1) {
Jim_SetResult_sprintf(goi.interp, "usage: %s <name>", cmd_name);
return JIM_ERR;
}
struct jtag_tap *t;
t = jtag_tap_by_jim_obj(goi.interp, goi.argv[0]);
if (t == NULL)
return JIM_ERR;
if (strcasecmp(cmd_name, "tapisenabled") == 0) {
// do nothing, just return the value
} else if (strcasecmp(cmd_name, "tapenable") == 0) {
if (!jtag_tap_enable(t))
LOG_WARNING("failed to disable tap");
} else if (strcasecmp(cmd_name, "tapdisable") == 0) {
if (!jtag_tap_disable(t))
LOG_WARNING("failed to disable tap");
} else {
LOG_ERROR("command '%s' unknown", cmd_name);
return JIM_ERR;
}
bool e = t->enabled;
Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, e));
return JIM_OK;
}
static int jim_jtag_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
const char *cmd_name = Jim_GetString(argv[0], NULL);
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
goi.isconfigure = !strcmp(cmd_name, "configure");
if (goi.argc < 2 + goi.isconfigure) {
Jim_WrongNumArgs(goi.interp, 0, NULL,
"<tap_name> <attribute> ...");
return JIM_ERR;
}
struct jtag_tap *t;
Jim_Obj *o;
Jim_GetOpt_Obj(&goi, &o);
t = jtag_tap_by_jim_obj(goi.interp, o);
if (t == NULL) {
return JIM_ERR;
}
return jtag_tap_configure_cmd(&goi, t);
}
static int jim_jtag_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_GetOptInfo goi;
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
if (goi.argc != 0) {
Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
return JIM_ERR;
}
Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
struct jtag_tap *tap;
for (tap = jtag_all_taps(); tap; tap = tap->next_tap) {
Jim_ListAppendElement(goi.interp,
Jim_GetResult(goi.interp),
Jim_NewStringObj(goi.interp,
tap->dotted_name, -1));
}
return JIM_OK;
}
COMMAND_HANDLER(handle_jtag_init_command)
{
if (CMD_ARGC != 0)
return ERROR_COMMAND_SYNTAX_ERROR;
static bool jtag_initialized = false;
if (jtag_initialized)
{
LOG_INFO("'jtag init' has already been called");
return ERROR_OK;
}
jtag_initialized = true;
LOG_DEBUG("Initializing jtag devices...");
return jtag_init(CMD_CTX);
}
static const struct command_registration jtag_subcommand_handlers[] = {
{
.name = "init",
.mode = COMMAND_ANY,
.handler = &handle_jtag_init_command,
.help = "initialize jtag scan chain",
},
{
.name = "interface",
.mode = COMMAND_ANY,
.jim_handler = &jim_jtag_interface,
.help = "Returns the selected interface",
},
{
.name = "arp_init",
.mode = COMMAND_ANY,
.jim_handler = &jim_jtag_arp_init,
},
{
.name = "arp_init-reset",
.mode = COMMAND_ANY,
.jim_handler = &jim_jtag_arp_init_reset,
},
{
.name = "newtap",
.mode = COMMAND_CONFIG,
.jim_handler = &jim_jtag_newtap,
.help = "Create a new TAP instance",
.usage = "<name> <type> -irlen <count> [-ircapture <count>] "
"[-irmask <count>] [-enable|-disable]",
},
{
.name = "tapisenabled",
.mode = COMMAND_EXEC,
.jim_handler = &jim_jtag_tap_enabler,
.help = "Returns a integer indicating TAP state (0/1)",
.usage = "<name>",
},
{
.name = "tapenable",
.mode = COMMAND_EXEC,
.jim_handler = &jim_jtag_tap_enabler,
.help = "Enable the specified TAP",
.usage = "<name>",
},
{
.name = "tapdisable",
.mode = COMMAND_EXEC,
.jim_handler = &jim_jtag_tap_enabler,
.help = "Enable the specified TAP",
.usage = "<name>",
},
{
.name = "configure",
.mode = COMMAND_EXEC,
.jim_handler = &jim_jtag_configure,
.help = "Enable the specified TAP",
.usage = "<name> [<key> <value> ...]",
},
{
.name = "cget",
.mode = COMMAND_EXEC,
.jim_handler = &jim_jtag_configure,
.help = "Enable the specified TAP",
.usage = "<name> [<key> <value> ...]",
},
{
.name = "names",
.mode = COMMAND_ANY,
.jim_handler = &jim_jtag_names,
.help = "Returns list of all JTAG tap names",
},
{
.chain = jtag_command_handlers_to_move,
},
COMMAND_REGISTRATION_DONE
};
void jtag_notify_event(enum jtag_event event)
{
struct jtag_tap *tap;
for (tap = jtag_all_taps(); tap; tap = tap->next_tap)
jtag_tap_handle_event(tap, event);
}
static int default_khz(int khz, int *jtag_speed)
{
LOG_ERROR("Translation from khz to jtag_speed not implemented");
return ERROR_FAIL;
}
static int default_speed_div(int speed, int *khz)
{
LOG_ERROR("Translation from jtag_speed to khz not implemented");
return ERROR_FAIL;
}
static int default_power_dropout(int *dropout)
{
*dropout = 0; /* by default we can't detect power dropout */
return ERROR_OK;
}
static int default_srst_asserted(int *srst_asserted)
{
*srst_asserted = 0; /* by default we can't detect srst asserted */
return ERROR_OK;
}
COMMAND_HANDLER(handle_interface_list_command)
{
if (strcmp(CMD_NAME, "interface_list") == 0 && CMD_ARGC > 0)
return ERROR_COMMAND_SYNTAX_ERROR;
command_print(CMD_CTX, "The following JTAG interfaces are available:");
for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
{
const char *name = jtag_interfaces[i]->name;
command_print(CMD_CTX, "%u: %s", i + 1, name);
}
return ERROR_OK;
}
COMMAND_HANDLER(handle_interface_command)
{
/* check whether the interface is already configured */
if (jtag_interface)
{
LOG_WARNING("Interface already configured, ignoring");
return ERROR_OK;
}
/* interface name is a mandatory argument */
if (CMD_ARGC != 1 || CMD_ARGV[0][0] == '\0')
return ERROR_COMMAND_SYNTAX_ERROR;
for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
{
if (strcmp(CMD_ARGV[0], jtag_interfaces[i]->name) != 0)
continue;
if (NULL != jtag_interfaces[i]->commands)
{
int retval = register_commands(CMD_CTX, NULL,
jtag_interfaces[i]->commands);
if (ERROR_OK != retval)
return retval;
}
jtag_interface = jtag_interfaces[i];
if (jtag_interface->khz == NULL)
jtag_interface->khz = default_khz;
if (jtag_interface->speed_div == NULL)
jtag_interface->speed_div = default_speed_div;
if (jtag_interface->power_dropout == NULL)
jtag_interface->power_dropout = default_power_dropout;
if (jtag_interface->srst_asserted == NULL)
jtag_interface->srst_asserted = default_srst_asserted;
return ERROR_OK;
}
/* no valid interface was found (i.e. the configuration option,
* didn't match one of the compiled-in interfaces
*/
LOG_ERROR("The specified JTAG interface was not found (%s)", CMD_ARGV[0]);
CALL_COMMAND_HANDLER(handle_interface_list_command);
return ERROR_JTAG_INVALID_INTERFACE;
}
COMMAND_HANDLER(handle_scan_chain_command)
{
struct jtag_tap *tap;
char expected_id[12];
tap = jtag_all_taps();
command_print(CMD_CTX,
" TapName Enabled IdCode Expected IrLen IrCap IrMask");
command_print(CMD_CTX,
"-- ------------------- -------- ---------- ---------- ----- ----- ------");
while (tap) {
uint32_t expected, expected_mask, ii;
snprintf(expected_id, sizeof expected_id, "0x%08x",
(unsigned)((tap->expected_ids_cnt > 0)
? tap->expected_ids[0]
: 0));
if (tap->ignore_version)
expected_id[2] = '*';
expected = buf_get_u32(tap->expected, 0, tap->ir_length);
expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
command_print(CMD_CTX,
"%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
tap->abs_chain_position,
tap->dotted_name,
tap->enabled ? 'Y' : 'n',
(unsigned int)(tap->idcode),
expected_id,
(unsigned int)(tap->ir_length),
(unsigned int)(expected),
(unsigned int)(expected_mask));
for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
snprintf(expected_id, sizeof expected_id, "0x%08x",
(unsigned) tap->expected_ids[1]);
if (tap->ignore_version)
expected_id[2] = '*';
command_print(CMD_CTX,
" %s",
expected_id);
}
tap = tap->next_tap;
}
return ERROR_OK;
}
COMMAND_HANDLER(handle_reset_config_command)
{
int new_cfg = 0;
int mask = 0;
/* Original versions cared about the order of these tokens:
* reset_config signals [combination [trst_type [srst_type]]]
* They also clobbered the previous configuration even on error.
*
* Here we don't care about the order, and only change values
* which have been explicitly specified.
*/
for (; CMD_ARGC; CMD_ARGC--, CMD_ARGV++) {
int tmp = 0;
int m;
/* gating */
m = RESET_SRST_NO_GATING;
if (strcmp(*CMD_ARGV, "srst_gates_jtag") == 0)
/* default: don't use JTAG while SRST asserted */;
else if (strcmp(*CMD_ARGV, "srst_nogate") == 0)
tmp = RESET_SRST_NO_GATING;
else
m = 0;
if (mask & m) {
LOG_ERROR("extra reset_config %s spec (%s)",
"gating", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
}
if (m)
goto next;
/* signals */
m = RESET_HAS_TRST | RESET_HAS_SRST;
if (strcmp(*CMD_ARGV, "none") == 0)
tmp = RESET_NONE;
else if (strcmp(*CMD_ARGV, "trst_only") == 0)
tmp = RESET_HAS_TRST;
else if (strcmp(*CMD_ARGV, "srst_only") == 0)
tmp = RESET_HAS_SRST;
else if (strcmp(*CMD_ARGV, "trst_and_srst") == 0)
tmp = RESET_HAS_TRST | RESET_HAS_SRST;
else
m = 0;
if (mask & m) {
LOG_ERROR("extra reset_config %s spec (%s)",
"signal", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
}
if (m)
goto next;
/* combination (options for broken wiring) */
m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
if (strcmp(*CMD_ARGV, "separate") == 0)
/* separate reset lines - default */;
else if (strcmp(*CMD_ARGV, "srst_pulls_trst") == 0)
tmp |= RESET_SRST_PULLS_TRST;
else if (strcmp(*CMD_ARGV, "trst_pulls_srst") == 0)
tmp |= RESET_TRST_PULLS_SRST;
else if (strcmp(*CMD_ARGV, "combined") == 0)
tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
else
m = 0;
if (mask & m) {
LOG_ERROR("extra reset_config %s spec (%s)",
"combination", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
}
if (m)
goto next;
/* trst_type (NOP without HAS_TRST) */
m = RESET_TRST_OPEN_DRAIN;
if (strcmp(*CMD_ARGV, "trst_open_drain") == 0)
tmp |= RESET_TRST_OPEN_DRAIN;
else if (strcmp(*CMD_ARGV, "trst_push_pull") == 0)
/* push/pull from adapter - default */;
else
m = 0;
if (mask & m) {
LOG_ERROR("extra reset_config %s spec (%s)",
"trst_type", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
}
if (m)
goto next;
/* srst_type (NOP without HAS_SRST) */
m |= RESET_SRST_PUSH_PULL;
if (strcmp(*CMD_ARGV, "srst_push_pull") == 0)
tmp |= RESET_SRST_PUSH_PULL;
else if (strcmp(*CMD_ARGV, "srst_open_drain") == 0)
/* open drain from adapter - default */;
else
m = 0;
if (mask & m) {
LOG_ERROR("extra reset_config %s spec (%s)",
"srst_type", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
}
if (m)
goto next;
/* caller provided nonsense; fail */
LOG_ERROR("unknown reset_config flag (%s)", *CMD_ARGV);
return ERROR_INVALID_ARGUMENTS;
next:
/* Remember the bits which were specified (mask)
* and their new values (new_cfg).
*/
mask |= m;
new_cfg |= tmp;
}
/* clear previous values of those bits, save new values */
if (mask) {
int old_cfg = jtag_get_reset_config();
old_cfg &= ~mask;
new_cfg |= old_cfg;
jtag_set_reset_config(new_cfg);
} else
new_cfg = jtag_get_reset_config();
/*
* Display the (now-)current reset mode
*/
char *modes[5];
/* minimal JTAG has neither SRST nor TRST (so that's the default) */
switch (new_cfg & (RESET_HAS_TRST | RESET_HAS_SRST)) {
case RESET_HAS_SRST:
modes[0] = "srst_only";
break;
case RESET_HAS_TRST:
modes[0] = "trst_only";
break;
case RESET_TRST_AND_SRST:
modes[0] = "trst_and_srst";
break;
default:
modes[0] = "none";
break;
}
/* normally SRST and TRST are decoupled; but bugs happen ... */
switch (new_cfg & (RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST)) {
case RESET_SRST_PULLS_TRST:
modes[1] = "srst_pulls_trst";
break;
case RESET_TRST_PULLS_SRST:
modes[1] = "trst_pulls_srst";
break;
case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
modes[1] = "combined";
break;
default:
modes[1] = "separate";
break;
}
/* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
if (new_cfg & RESET_HAS_TRST) {
if (new_cfg & RESET_TRST_OPEN_DRAIN)
modes[3] = " trst_open_drain";
else
modes[3] = " trst_push_pull";
} else
modes[3] = "";
/* SRST-less connectors include TI-14, Xilinx, and minimal JTAG */
if (new_cfg & RESET_HAS_SRST) {
if (new_cfg & RESET_SRST_NO_GATING)
modes[2] = " srst_nogate";
else
modes[2] = " srst_gates_jtag";
if (new_cfg & RESET_SRST_PUSH_PULL)
modes[4] = " srst_push_pull";
else
modes[4] = " srst_open_drain";
} else {
modes[2] = "";
modes[4] = "";
}
command_print(CMD_CTX, "%s %s%s%s%s",
modes[0], modes[1],
modes[2], modes[3], modes[4]);
return ERROR_OK;
}
COMMAND_HANDLER(handle_jtag_nsrst_delay_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
jtag_set_nsrst_delay(delay);
}
command_print(CMD_CTX, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
return ERROR_OK;
}
COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
jtag_set_ntrst_delay(delay);
}
command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
return ERROR_OK;
}
COMMAND_HANDLER(handle_jtag_nsrst_assert_width_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
jtag_set_nsrst_assert_width(delay);
}
command_print(CMD_CTX, "jtag_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
return ERROR_OK;
}
COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
jtag_set_ntrst_assert_width(delay);
}
command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
return ERROR_OK;
}
COMMAND_HANDLER(handle_jtag_khz_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
if (CMD_ARGC == 1)
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
retval = jtag_config_khz(khz);
if (ERROR_OK != retval)
return retval;
}
int cur_speed = jtag_get_speed_khz();
retval = jtag_get_speed_readable(&cur_speed);
if (ERROR_OK != retval)
return retval;
if (cur_speed)
command_print(CMD_CTX, "%d kHz", cur_speed);
else
command_print(CMD_CTX, "RCLK - adaptive");
return retval;
}
COMMAND_HANDLER(handle_jtag_rclk_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
if (CMD_ARGC == 1)
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
retval = jtag_config_rclk(khz);
if (ERROR_OK != retval)
return retval;
}
int cur_khz = jtag_get_speed_khz();
retval = jtag_get_speed_readable(&cur_khz);
if (ERROR_OK != retval)
return retval;
if (cur_khz)
command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz);
else
command_print(CMD_CTX, "RCLK - adaptive");
return retval;
}
COMMAND_HANDLER(handle_jtag_reset_command)
{
if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
int trst = -1;
if (CMD_ARGV[0][0] == '1')
trst = 1;
else if (CMD_ARGV[0][0] == '0')
trst = 0;
else
return ERROR_COMMAND_SYNTAX_ERROR;
int srst = -1;
if (CMD_ARGV[1][0] == '1')
srst = 1;
else if (CMD_ARGV[1][0] == '0')
srst = 0;
else
return ERROR_COMMAND_SYNTAX_ERROR;
if (jtag_interface_init(CMD_CTX) != ERROR_OK)
return ERROR_JTAG_INIT_FAILED;
jtag_add_reset(trst, srst);
return jtag_execute_queue();
}
COMMAND_HANDLER(handle_runtest_command)
{
if (CMD_ARGC != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned num_clocks;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num_clocks);
jtag_add_runtest(num_clocks, TAP_IDLE);
return jtag_execute_queue();
}
/*
* For "irscan" or "drscan" commands, the "end" (really, "next") state
* should be stable ... and *NOT* a shift state, otherwise free-running
* jtag clocks could change the values latched by the update state.
* Not surprisingly, this is the same constraint as SVF; the "irscan"
* and "drscan" commands are a write-only subset of what SVF provides.
*/
COMMAND_HANDLER(handle_irscan_command)
{
int i;
struct scan_field *fields;
struct jtag_tap *tap;
tap_state_t endstate;
if ((CMD_ARGC < 2) || (CMD_ARGC % 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
/* optional "-endstate" "statename" at the end of the arguments,
* so that e.g. IRPAUSE can let us load the data register before
* entering RUN/IDLE to execute the instruction we load here.
*/
endstate = TAP_IDLE;
if (CMD_ARGC >= 4) {
/* have at least one pair of numbers. */
/* is last pair the magic text? */
if (strcmp("-endstate", CMD_ARGV[CMD_ARGC - 2]) == 0) {
endstate = tap_state_by_name(CMD_ARGV[CMD_ARGC - 1]);
if (endstate == TAP_INVALID)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!scan_is_safe(endstate))
LOG_WARNING("unstable irscan endstate \"%s\"",
CMD_ARGV[CMD_ARGC - 1]);
CMD_ARGC -= 2;
}
}
int num_fields = CMD_ARGC / 2;
size_t fields_len = sizeof(struct scan_field) * num_fields;
fields = malloc(fields_len);
memset(fields, 0, fields_len);
int retval;
for (i = 0; i < num_fields; i++)
{
tap = jtag_tap_by_string(CMD_ARGV[i*2]);
if (tap == NULL)
{
int j;
for (j = 0; j < i; j++)
free(fields[j].out_value);
free(fields);
command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]);
return ERROR_FAIL;
}
int field_size = tap->ir_length;
fields[i].tap = tap;
fields[i].num_bits = field_size;
fields[i].out_value = malloc(DIV_ROUND_UP(field_size, 8));
uint32_t value;
retval = parse_u32(CMD_ARGV[i * 2 + 1], &value);
if (ERROR_OK != retval)
goto error_return;
buf_set_u32(fields[i].out_value, 0, field_size, value);
fields[i].in_value = NULL;
}
/* did we have an endstate? */
jtag_add_ir_scan(num_fields, fields, endstate);
retval = jtag_execute_queue();
error_return:
for (i = 0; i < num_fields; i++)
{
if (NULL != fields[i].out_value)
free(fields[i].out_value);
}
free (fields);
return retval;
}
COMMAND_HANDLER(handle_verify_ircapture_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
bool enable;
COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
jtag_set_verify_capture_ir(enable);
}
const char *status = jtag_will_verify_capture_ir() ? "enabled": "disabled";
command_print(CMD_CTX, "verify Capture-IR is %s", status);
return ERROR_OK;
}
COMMAND_HANDLER(handle_verify_jtag_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
bool enable;
COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
jtag_set_verify(enable);
}
const char *status = jtag_will_verify() ? "enabled": "disabled";
command_print(CMD_CTX, "verify jtag capture is %s", status);
return ERROR_OK;
}
COMMAND_HANDLER(handle_tms_sequence_command)
{
if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (CMD_ARGC == 1)
{
bool use_new_table;
if (strcmp(CMD_ARGV[0], "short") == 0)
use_new_table = true;
else if (strcmp(CMD_ARGV[0], "long") == 0)
use_new_table = false;
else
return ERROR_COMMAND_SYNTAX_ERROR;
tap_use_new_tms_table(use_new_table);
}
command_print(CMD_CTX, "tms sequence is %s",
tap_uses_new_tms_table() ? "short": "long");
return ERROR_OK;
}
static const struct command_registration jtag_command_handlers[] = {
{
.name = "interface",
.handler = &handle_interface_command,
.mode = COMMAND_CONFIG,
.help = "select a JTAG interface",
.usage = "<driver_name>",
},
{
.name = "interface_list",
.handler = &handle_interface_list_command,
.mode = COMMAND_ANY,
.help = "list all built-in interfaces",
},
{
.name = "jtag_khz",
.handler = &handle_jtag_khz_command,
.mode = COMMAND_ANY,
.help = "set maximum jtag speed (if supported)",
.usage = "<khz:0=rtck>",
},
{
.name = "jtag_rclk",
.handler = &handle_jtag_rclk_command,
.mode = COMMAND_ANY,
.help = "set JTAG speed to RCLK or use fallback speed",
.usage = "<fallback_speed_khz>",
},
{
.name = "reset_config",
.handler = &handle_reset_config_command,
.mode = COMMAND_ANY,
.help = "configure JTAG reset behavior",
.usage = "[none|trst_only|srst_only|trst_and_srst] "
"[srst_pulls_trst|trst_pulls_srst|combined|separate] "
"[srst_gates_jtag|srst_nogate] "
"[trst_push_pull|trst_open_drain] "
"[srst_push_pull|srst_open_drain]",
},
{
.name = "jtag_nsrst_delay",
.handler = &handle_jtag_nsrst_delay_command,
.mode = COMMAND_ANY,
.help = "delay after deasserting srst in ms",
.usage = "<ms>",
},
{
.name = "jtag_ntrst_delay",
.handler = &handle_jtag_ntrst_delay_command,
.mode = COMMAND_ANY,
.help = "delay after deasserting trst in ms",
.usage = "<ms>"
},
{
.name = "jtag_nsrst_assert_width",
.handler = &handle_jtag_nsrst_assert_width_command,
.mode = COMMAND_ANY,
.help = "delay after asserting srst in ms",
.usage = "<ms>"
},
{
.name = "jtag_ntrst_assert_width",
.handler = &handle_jtag_ntrst_assert_width_command,
.mode = COMMAND_ANY,
.help = "delay after asserting trst in ms",
.usage = "<ms>"
},
{
.name = "scan_chain",
.handler = &handle_scan_chain_command,
.mode = COMMAND_EXEC,
.help = "print current scan chain configuration",
},
{
.name = "jtag_reset",
.handler = &handle_jtag_reset_command,
.mode = COMMAND_EXEC,
.help = "toggle reset lines",
.usage = "<trst> <srst>",
},
{
.name = "runtest",
.handler = &handle_runtest_command,
.mode = COMMAND_EXEC,
.help = "move to Run-Test/Idle, and execute <num_cycles>",
.usage = "<num_cycles>"
},
{
.name = "irscan",
.handler = &handle_irscan_command,
.mode = COMMAND_EXEC,
.help = "execute IR scan",
.usage = "<device> <instr> [dev2] [instr2] ...",
},
{
.name = "verify_ircapture",
.handler = &handle_verify_ircapture_command,
.mode = COMMAND_ANY,
.help = "verify value captured during Capture-IR",
.usage = "<enable | disable>",
},
{
.name = "verify_jtag",
.handler = &handle_verify_jtag_command,
.mode = COMMAND_ANY,
.help = "verify value capture",
.usage = "<enable | disable>",
},
{
.name = "tms_sequence",
.handler = &handle_tms_sequence_command,
.mode = COMMAND_ANY,
.help = "choose short(default) or long tms_sequence",
.usage = "<short | long>",
},
{
.name = "jtag",
.mode = COMMAND_ANY,
.help = "perform jtag tap actions",
.chain = jtag_subcommand_handlers,
},
{
.chain = jtag_command_handlers_to_move,
},
COMMAND_REGISTRATION_DONE
};
int jtag_register_commands(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL, jtag_command_handlers);
}
Reference in New Issue View Git Blame Copy Permalink