explode tcl_target_func into many handlers
Eliminate the monolithic tcl_target_func by registering each of its commands using the new chained command registration mechanism. Also chains the target's commands under the CPU command, though these may not work properly without some further modification.
This commit is contained in:
Zachary T Welch
parent
cb8d567b75
commit
070259cadb
|
|
@ -3366,7 +3366,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc,
|
|||
* argv[4] = count to write
|
||||
*/
|
||||
if (argc != 4) {
|
||||
Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems");
|
||||
Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems");
|
||||
return JIM_ERR;
|
||||
}
|
||||
varname = Jim_GetString(argv[0], &len);
|
||||
|
|
@ -3849,169 +3849,109 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
|
|||
return JIM_OK;
|
||||
}
|
||||
|
||||
/** this is the 'tcl' handler for the target specific command */
|
||||
static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
static int jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
Jim_GetOptInfo goi;
|
||||
jim_wide a,b,c;
|
||||
int x,y,z;
|
||||
uint8_t target_buf[32];
|
||||
Jim_Nvp *n;
|
||||
struct target *target;
|
||||
struct command_context *cmd_ctx;
|
||||
int e;
|
||||
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
|
||||
goi.isconfigure = strcmp(Jim_GetString(argv[0], NULL), "configure") == 0;
|
||||
int need_args = 1 + goi.isconfigure;
|
||||
if (goi.argc < need_args)
|
||||
{
|
||||
Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
|
||||
goi.isconfigure
|
||||
? "missing: -option VALUE ..."
|
||||
: "missing: -option ...");
|
||||
return JIM_ERR;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(goi.interp);
|
||||
return target_configure(&goi, target);
|
||||
}
|
||||
|
||||
enum {
|
||||
TS_CMD_CONFIGURE,
|
||||
TS_CMD_CGET,
|
||||
static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
const char *cmd_name = Jim_GetString(argv[0], NULL);
|
||||
|
||||
TS_CMD_MWW, TS_CMD_MWH, TS_CMD_MWB,
|
||||
TS_CMD_MDW, TS_CMD_MDH, TS_CMD_MDB,
|
||||
TS_CMD_MRW, TS_CMD_MRH, TS_CMD_MRB,
|
||||
TS_CMD_MEM2ARRAY, TS_CMD_ARRAY2MEM,
|
||||
TS_CMD_EXAMINE,
|
||||
TS_CMD_POLL,
|
||||
TS_CMD_RESET,
|
||||
TS_CMD_HALT,
|
||||
TS_CMD_WAITSTATE,
|
||||
TS_CMD_EVENTLIST,
|
||||
TS_CMD_CURSTATE,
|
||||
TS_CMD_INVOKE_EVENT,
|
||||
};
|
||||
|
||||
static const Jim_Nvp target_options[] = {
|
||||
{ .name = "configure", .value = TS_CMD_CONFIGURE },
|
||||
{ .name = "cget", .value = TS_CMD_CGET },
|
||||
{ .name = "mww", .value = TS_CMD_MWW },
|
||||
{ .name = "mwh", .value = TS_CMD_MWH },
|
||||
{ .name = "mwb", .value = TS_CMD_MWB },
|
||||
{ .name = "mdw", .value = TS_CMD_MDW },
|
||||
{ .name = "mdh", .value = TS_CMD_MDH },
|
||||
{ .name = "mdb", .value = TS_CMD_MDB },
|
||||
{ .name = "mem2array", .value = TS_CMD_MEM2ARRAY },
|
||||
{ .name = "array2mem", .value = TS_CMD_ARRAY2MEM },
|
||||
{ .name = "eventlist", .value = TS_CMD_EVENTLIST },
|
||||
{ .name = "curstate", .value = TS_CMD_CURSTATE },
|
||||
|
||||
{ .name = "arp_examine", .value = TS_CMD_EXAMINE },
|
||||
{ .name = "arp_poll", .value = TS_CMD_POLL },
|
||||
{ .name = "arp_reset", .value = TS_CMD_RESET },
|
||||
{ .name = "arp_halt", .value = TS_CMD_HALT },
|
||||
{ .name = "arp_waitstate", .value = TS_CMD_WAITSTATE },
|
||||
{ .name = "invoke-event", .value = TS_CMD_INVOKE_EVENT },
|
||||
|
||||
{ .name = NULL, .value = -1 },
|
||||
};
|
||||
|
||||
/* go past the "command" */
|
||||
Jim_GetOptInfo goi;
|
||||
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
|
||||
|
||||
target = Jim_CmdPrivData(goi.interp);
|
||||
cmd_ctx = Jim_GetAssocData(goi.interp, "context");
|
||||
if (goi.argc != 2 && goi.argc != 3)
|
||||
{
|
||||
Jim_SetResult_sprintf(goi.interp,
|
||||
"usage: %s <address> <data> [<count>]", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
|
||||
/* commands here are in an NVP table */
|
||||
e = Jim_GetOpt_Nvp(&goi, target_options, &n);
|
||||
if (e != JIM_OK) {
|
||||
Jim_GetOpt_NvpUnknown(&goi, target_options, 0);
|
||||
jim_wide a;
|
||||
int e = Jim_GetOpt_Wide(&goi, &a);
|
||||
if (e != JIM_OK)
|
||||
return e;
|
||||
|
||||
jim_wide b;
|
||||
e = Jim_GetOpt_Wide(&goi, &b);
|
||||
if (e != JIM_OK)
|
||||
return e;
|
||||
|
||||
jim_wide c = 1;
|
||||
if (goi.argc == 3)
|
||||
{
|
||||
e = Jim_GetOpt_Wide(&goi, &c);
|
||||
if (e != JIM_OK)
|
||||
return e;
|
||||
}
|
||||
/* Assume blank result */
|
||||
Jim_SetEmptyResult(goi.interp);
|
||||
|
||||
switch (n->value) {
|
||||
case TS_CMD_CONFIGURE:
|
||||
if (goi.argc < 2) {
|
||||
Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "missing: -option VALUE ...");
|
||||
return JIM_ERR;
|
||||
}
|
||||
goi.isconfigure = 1;
|
||||
return target_configure(&goi, target);
|
||||
case TS_CMD_CGET:
|
||||
// some things take params
|
||||
if (goi.argc < 1) {
|
||||
Jim_WrongNumArgs(goi.interp, 0, goi.argv, "missing: ?-option?");
|
||||
return JIM_ERR;
|
||||
}
|
||||
goi.isconfigure = 0;
|
||||
return target_configure(&goi, target);
|
||||
break;
|
||||
case TS_CMD_MWW:
|
||||
case TS_CMD_MWH:
|
||||
case TS_CMD_MWB:
|
||||
/* argv[0] = cmd
|
||||
* argv[1] = address
|
||||
* argv[2] = data
|
||||
* argv[3] = optional count.
|
||||
*/
|
||||
|
||||
if ((goi.argc == 2) || (goi.argc == 3)) {
|
||||
/* all is well */
|
||||
} else {
|
||||
mwx_error:
|
||||
Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR DATA [COUNT]", n->name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
|
||||
e = Jim_GetOpt_Wide(&goi, &a);
|
||||
if (e != JIM_OK) {
|
||||
goto mwx_error;
|
||||
}
|
||||
|
||||
e = Jim_GetOpt_Wide(&goi, &b);
|
||||
if (e != JIM_OK) {
|
||||
goto mwx_error;
|
||||
}
|
||||
if (goi.argc == 3) {
|
||||
e = Jim_GetOpt_Wide(&goi, &c);
|
||||
if (e != JIM_OK) {
|
||||
goto mwx_error;
|
||||
}
|
||||
} else {
|
||||
c = 1;
|
||||
}
|
||||
|
||||
switch (n->value) {
|
||||
case TS_CMD_MWW:
|
||||
struct target *target = Jim_CmdPrivData(goi.interp);
|
||||
uint8_t target_buf[32];
|
||||
if (strcasecmp(cmd_name, "mww") == 0) {
|
||||
target_buffer_set_u32(target, target_buf, b);
|
||||
b = 4;
|
||||
break;
|
||||
case TS_CMD_MWH:
|
||||
}
|
||||
else if (strcasecmp(cmd_name, "mwh") == 0) {
|
||||
target_buffer_set_u16(target, target_buf, b);
|
||||
b = 2;
|
||||
break;
|
||||
case TS_CMD_MWB:
|
||||
}
|
||||
else if (strcasecmp(cmd_name, "mwb") == 0) {
|
||||
target_buffer_set_u8(target, target_buf, b);
|
||||
b = 1;
|
||||
break;
|
||||
} else {
|
||||
LOG_ERROR("command '%s' unknown: ", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
for (x = 0 ; x < c ; x++) {
|
||||
|
||||
for (jim_wide x = 0; x < c; x++)
|
||||
{
|
||||
e = target_write_memory(target, a, b, 1, target_buf);
|
||||
if (e != ERROR_OK) {
|
||||
Jim_SetResult_sprintf(interp, "Error writing @ 0x%08x: %d\n", (int)(a), e);
|
||||
if (e != ERROR_OK)
|
||||
{
|
||||
Jim_SetResult_sprintf(interp,
|
||||
"Error writing @ 0x%08x: %d\n", (int)(a), e);
|
||||
return JIM_ERR;
|
||||
}
|
||||
/* b = width */
|
||||
a = a + b;
|
||||
}
|
||||
return JIM_OK;
|
||||
break;
|
||||
}
|
||||
|
||||
/* display */
|
||||
case TS_CMD_MDW:
|
||||
case TS_CMD_MDH:
|
||||
case TS_CMD_MDB:
|
||||
/* argv[0] = command
|
||||
* argv[1] = address
|
||||
* argv[2] = optional count
|
||||
*/
|
||||
if ((goi.argc == 2) || (goi.argc == 3)) {
|
||||
Jim_SetResult_sprintf(goi.interp, "expected: %s ADDR [COUNT]", n->name);
|
||||
static int jim_target_md(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 == 2) || (goi.argc == 3))
|
||||
{
|
||||
Jim_SetResult_sprintf(goi.interp,
|
||||
"usage: %s <address> [<count>]", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
e = Jim_GetOpt_Wide(&goi, &a);
|
||||
|
||||
jim_wide a;
|
||||
int e = Jim_GetOpt_Wide(&goi, &a);
|
||||
if (e != JIM_OK) {
|
||||
return JIM_ERR;
|
||||
}
|
||||
jim_wide c;
|
||||
if (goi.argc) {
|
||||
e = Jim_GetOpt_Wide(&goi, &c);
|
||||
if (e != JIM_OK) {
|
||||
|
|
@ -4020,22 +3960,24 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
|||
} else {
|
||||
c = 1;
|
||||
}
|
||||
b = 1; /* shut up gcc */
|
||||
switch (n->value) {
|
||||
case TS_CMD_MDW:
|
||||
jim_wide b = 1; /* shut up gcc */
|
||||
if (strcasecmp(cmd_name, "mdw") == 0)
|
||||
b = 4;
|
||||
break;
|
||||
case TS_CMD_MDH:
|
||||
else if (strcasecmp(cmd_name, "mdh") == 0)
|
||||
b = 2;
|
||||
break;
|
||||
case TS_CMD_MDB:
|
||||
else if (strcasecmp(cmd_name, "mdb") == 0)
|
||||
b = 1;
|
||||
break;
|
||||
else {
|
||||
LOG_ERROR("command '%s' unknown: ", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
|
||||
/* convert to "bytes" */
|
||||
/* convert count to "bytes" */
|
||||
c = c * b;
|
||||
/* count is now in 'BYTES' */
|
||||
|
||||
struct target *target = Jim_CmdPrivData(goi.interp);
|
||||
uint8_t target_buf[32];
|
||||
jim_wide x, y, z;
|
||||
while (c > 0) {
|
||||
y = c;
|
||||
if (y > 16) {
|
||||
|
|
@ -4050,7 +3992,8 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
|||
Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a));
|
||||
switch (b) {
|
||||
case 4:
|
||||
for (x = 0 ; (x < 16) && (x < y) ; x += 4) {
|
||||
for (x = 0; x < 16 && x < y; x += 4)
|
||||
{
|
||||
z = target_buffer_get_u32(target, &(target_buf[ x * 4 ]));
|
||||
Jim_fprintf(interp, interp->cookie_stdout, "%08x ", (int)(z));
|
||||
}
|
||||
|
|
@ -4059,7 +4002,8 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
|||
}
|
||||
break;
|
||||
case 2:
|
||||
for (x = 0 ; (x < 16) && (x < y) ; x += 2) {
|
||||
for (x = 0; x < 16 && x < y; x += 2)
|
||||
{
|
||||
z = target_buffer_get_u16(target, &(target_buf[ x * 2 ]));
|
||||
Jim_fprintf(interp, interp->cookie_stdout, "%04x ", (int)(z));
|
||||
}
|
||||
|
|
@ -4102,64 +4046,101 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
|||
a += 16;
|
||||
}
|
||||
return JIM_OK;
|
||||
case TS_CMD_MEM2ARRAY:
|
||||
return target_mem2array(goi.interp, target, goi.argc, goi.argv);
|
||||
break;
|
||||
case TS_CMD_ARRAY2MEM:
|
||||
return target_array2mem(goi.interp, target, goi.argc, goi.argv);
|
||||
break;
|
||||
case TS_CMD_EXAMINE:
|
||||
if (goi.argc) {
|
||||
Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
|
||||
}
|
||||
|
||||
static int jim_target_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
return target_mem2array(interp, target, argc - 1, argv + 1);
|
||||
}
|
||||
|
||||
static int jim_target_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
return target_array2mem(interp, target, argc - 1, argv + 1);
|
||||
}
|
||||
|
||||
static int jim_target_tap_disabled(Jim_Interp *interp)
|
||||
{
|
||||
Jim_SetResult_sprintf(interp, "[TAP is disabled]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
|
||||
static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
if (argc != 1)
|
||||
{
|
||||
Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
if (!target->tap->enabled)
|
||||
goto err_tap_disabled;
|
||||
e = target->type->examine(target);
|
||||
if (e != ERROR_OK) {
|
||||
return jim_target_tap_disabled(interp);
|
||||
|
||||
int e = target->type->examine(target);
|
||||
if (e != ERROR_OK)
|
||||
{
|
||||
Jim_SetResult_sprintf(interp, "examine-fails: %d", e);
|
||||
return JIM_ERR;
|
||||
}
|
||||
return JIM_OK;
|
||||
case TS_CMD_POLL:
|
||||
if (goi.argc) {
|
||||
Jim_WrongNumArgs(goi.interp, 2, argv, "[no parameters]");
|
||||
}
|
||||
|
||||
static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
if (argc != 1)
|
||||
{
|
||||
Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
if (!target->tap->enabled)
|
||||
goto err_tap_disabled;
|
||||
return jim_target_tap_disabled(interp);
|
||||
|
||||
int e;
|
||||
if (!(target_was_examined(target))) {
|
||||
e = ERROR_TARGET_NOT_EXAMINED;
|
||||
} else {
|
||||
e = target->type->poll(target);
|
||||
}
|
||||
if (e != ERROR_OK) {
|
||||
if (e != ERROR_OK)
|
||||
{
|
||||
Jim_SetResult_sprintf(interp, "poll-fails: %d", e);
|
||||
return JIM_ERR;
|
||||
} else {
|
||||
}
|
||||
return JIM_OK;
|
||||
}
|
||||
break;
|
||||
case TS_CMD_RESET:
|
||||
if (goi.argc != 2) {
|
||||
Jim_WrongNumArgs(interp, 2, argv,
|
||||
|
||||
static int jim_target_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 != 2)
|
||||
{
|
||||
Jim_WrongNumArgs(interp, 0, argv,
|
||||
"([tT]|[fF]|assert|deassert) BOOL");
|
||||
return JIM_ERR;
|
||||
}
|
||||
e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
|
||||
if (e != JIM_OK) {
|
||||
|
||||
Jim_Nvp *n;
|
||||
int e = Jim_GetOpt_Nvp(&goi, nvp_assert, &n);
|
||||
if (e != JIM_OK)
|
||||
{
|
||||
Jim_GetOpt_NvpUnknown(&goi, nvp_assert, 1);
|
||||
return e;
|
||||
}
|
||||
/* the halt or not param */
|
||||
jim_wide a;
|
||||
e = Jim_GetOpt_Wide(&goi, &a);
|
||||
if (e != JIM_OK) {
|
||||
if (e != JIM_OK)
|
||||
return e;
|
||||
}
|
||||
|
||||
struct target *target = Jim_CmdPrivData(goi.interp);
|
||||
if (!target->tap->enabled)
|
||||
goto err_tap_disabled;
|
||||
if (!target->type->assert_reset
|
||||
|| !target->type->deassert_reset) {
|
||||
return jim_target_tap_disabled(interp);
|
||||
if (!target->type->assert_reset || !target->type->deassert_reset)
|
||||
{
|
||||
Jim_SetResult_sprintf(interp,
|
||||
"No target-specific reset for %s",
|
||||
target_name(target));
|
||||
|
|
@ -4177,93 +4158,227 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
|||
e = target->type->deassert_reset(target);
|
||||
}
|
||||
return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
|
||||
case TS_CMD_HALT:
|
||||
if (goi.argc) {
|
||||
Jim_WrongNumArgs(goi.interp, 0, argv, "halt [no parameters]");
|
||||
}
|
||||
|
||||
static int jim_target_halt(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
if (argc != 1) {
|
||||
Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
if (!target->tap->enabled)
|
||||
goto err_tap_disabled;
|
||||
e = target->type->halt(target);
|
||||
return jim_target_tap_disabled(interp);
|
||||
int e = target->type->halt(target);
|
||||
return (e == ERROR_OK) ? JIM_OK : JIM_ERR;
|
||||
case TS_CMD_WAITSTATE:
|
||||
}
|
||||
|
||||
static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
Jim_GetOptInfo goi;
|
||||
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
|
||||
|
||||
/* params: <name> statename timeoutmsecs */
|
||||
if (goi.argc != 2) {
|
||||
Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name);
|
||||
if (goi.argc != 2)
|
||||
{
|
||||
const char *cmd_name = Jim_GetString(argv[0], NULL);
|
||||
Jim_SetResult_sprintf(goi.interp,
|
||||
"%s <state_name> <timeout_in_msec>", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
|
||||
|
||||
Jim_Nvp *n;
|
||||
int e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n);
|
||||
if (e != JIM_OK) {
|
||||
Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1);
|
||||
return e;
|
||||
}
|
||||
jim_wide a;
|
||||
e = Jim_GetOpt_Wide(&goi, &a);
|
||||
if (e != JIM_OK) {
|
||||
return e;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
if (!target->tap->enabled)
|
||||
goto err_tap_disabled;
|
||||
return jim_target_tap_disabled(interp);
|
||||
|
||||
e = target_wait_state(target, n->value, a);
|
||||
if (e != ERROR_OK) {
|
||||
if (e != ERROR_OK)
|
||||
{
|
||||
Jim_SetResult_sprintf(goi.interp,
|
||||
"target: %s wait %s fails (%d) %s",
|
||||
target_name(target), n->name,
|
||||
e, target_strerror_safe(e));
|
||||
return JIM_ERR;
|
||||
} else {
|
||||
}
|
||||
return JIM_OK;
|
||||
}
|
||||
case TS_CMD_EVENTLIST:
|
||||
/* List for human, Events defined for this target.
|
||||
* scripts/programs should use 'name cget -event NAME'
|
||||
*/
|
||||
static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
struct target_event_action *teap;
|
||||
teap = target->event_action;
|
||||
command_print(cmd_ctx,
|
||||
"Event actions for target (%d) %s\n",
|
||||
struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
struct target_event_action *teap = target->event_action;
|
||||
command_print(cmd_ctx, "Event actions for target (%d) %s\n",
|
||||
target->target_number,
|
||||
target_name(target));
|
||||
command_print(cmd_ctx, "%-25s | Body", "Event");
|
||||
command_print(cmd_ctx, "------------------------- | ----------------------------------------");
|
||||
while (teap) {
|
||||
command_print(cmd_ctx,
|
||||
"%-25s | %s",
|
||||
Jim_Nvp_value2name_simple(nvp_target_event, teap->event)->name,
|
||||
Jim_GetString(teap->body, NULL));
|
||||
command_print(cmd_ctx, "------------------------- | "
|
||||
"----------------------------------------");
|
||||
while (teap)
|
||||
{
|
||||
Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
|
||||
command_print(cmd_ctx, "%-25s | %s",
|
||||
opt->name, Jim_GetString(teap->body, NULL));
|
||||
teap = teap->next;
|
||||
}
|
||||
command_print(cmd_ctx, "***END***");
|
||||
return JIM_OK;
|
||||
}
|
||||
case TS_CMD_CURSTATE:
|
||||
if (goi.argc != 0) {
|
||||
Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]");
|
||||
static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
if (argc != 1)
|
||||
{
|
||||
Jim_WrongNumArgs(interp, 1, argv, "[no parameters]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
Jim_SetResultString(goi.interp,
|
||||
target_state_name( target ),
|
||||
-1);
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
Jim_SetResultString(interp, target_state_name(target), -1);
|
||||
return JIM_OK;
|
||||
case TS_CMD_INVOKE_EVENT:
|
||||
if (goi.argc != 1) {
|
||||
Jim_SetResult_sprintf(goi.interp, "%s ?EVENTNAME?",n->name);
|
||||
}
|
||||
static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
{
|
||||
Jim_GetOptInfo goi;
|
||||
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
|
||||
if (goi.argc != 1)
|
||||
{
|
||||
const char *cmd_name = Jim_GetString(argv[0], NULL);
|
||||
Jim_SetResult_sprintf(goi.interp, "%s <eventname>", cmd_name);
|
||||
return JIM_ERR;
|
||||
}
|
||||
e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
|
||||
if (e != JIM_OK) {
|
||||
Jim_Nvp *n;
|
||||
int e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n);
|
||||
if (e != JIM_OK)
|
||||
{
|
||||
Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1);
|
||||
return e;
|
||||
}
|
||||
struct target *target = Jim_CmdPrivData(interp);
|
||||
target_handle_event(target, n->value);
|
||||
return JIM_OK;
|
||||
}
|
||||
return JIM_ERR;
|
||||
|
||||
err_tap_disabled:
|
||||
Jim_SetResult_sprintf(interp, "[TAP is disabled]");
|
||||
return JIM_ERR;
|
||||
}
|
||||
static const struct command_registration target_instance_command_handlers[] = {
|
||||
{
|
||||
.name = "configure",
|
||||
.mode = COMMAND_CONFIG,
|
||||
.jim_handler = &jim_target_configure,
|
||||
.usage = "[<target_options> ...]",
|
||||
.help = "configure a new target for use",
|
||||
},
|
||||
{
|
||||
.name = "cget",
|
||||
.mode = COMMAND_ANY,
|
||||
.jim_handler = &jim_target_configure,
|
||||
.usage = "<target_type> [<target_options> ...]",
|
||||
.help = "configure a new target for use",
|
||||
},
|
||||
{
|
||||
.name = "mww",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_mw,
|
||||
.usage = "<address> <data> [<count>]",
|
||||
.help = "Write 32-bit word(s) to target memory",
|
||||
},
|
||||
{
|
||||
.name = "mwh",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_mw,
|
||||
.usage = "<address> <data> [<count>]",
|
||||
.help = "Write 16-bit half-word(s) to target memory",
|
||||
},
|
||||
{
|
||||
.name = "mwb",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_mw,
|
||||
.usage = "<address> <data> [<count>]",
|
||||
.help = "Write byte(s) to target memory",
|
||||
},
|
||||
{
|
||||
.name = "mdw",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_md,
|
||||
.usage = "<address> [<count>]",
|
||||
.help = "Display target memory as 32-bit words",
|
||||
},
|
||||
{
|
||||
.name = "mdh",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_md,
|
||||
.usage = "<address> [<count>]",
|
||||
.help = "Display target memory as 16-bit half-words",
|
||||
},
|
||||
{
|
||||
.name = "mdb",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_md,
|
||||
.usage = "<address> [<count>]",
|
||||
.help = "Display target memory as 8-bit bytes",
|
||||
},
|
||||
{
|
||||
.name = "array2mem",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_array2mem,
|
||||
},
|
||||
{
|
||||
.name = "mem2array",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_mem2array,
|
||||
},
|
||||
{
|
||||
.name = "eventlist",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_event_list,
|
||||
},
|
||||
{
|
||||
.name = "curstate",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_current_state,
|
||||
},
|
||||
{
|
||||
.name = "arp_examine",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_examine,
|
||||
},
|
||||
{
|
||||
.name = "arp_poll",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_poll,
|
||||
},
|
||||
{
|
||||
.name = "arp_reset",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_reset,
|
||||
},
|
||||
{
|
||||
.name = "arp_halt",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_halt,
|
||||
},
|
||||
{
|
||||
.name = "arp_waitstate",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_wait_state,
|
||||
},
|
||||
{
|
||||
.name = "invoke-event",
|
||||
.mode = COMMAND_EXEC,
|
||||
.jim_handler = &jim_target_invoke_event,
|
||||
},
|
||||
COMMAND_REGISTRATION_DONE
|
||||
};
|
||||
|
||||
static int target_create(Jim_GetOptInfo *goi)
|
||||
{
|
||||
|
|
@ -4414,14 +4529,33 @@ static int target_create(Jim_GetOptInfo *goi)
|
|||
}
|
||||
|
||||
/* now - create the new target name command */
|
||||
const struct command_registration target_command = {
|
||||
.name = cp,
|
||||
.jim_handler = &tcl_target_func,
|
||||
.jim_handler_data = target,
|
||||
.help = "target command group",
|
||||
const const struct command_registration target_subcommands[] = {
|
||||
{
|
||||
.chain = target_instance_command_handlers,
|
||||
},
|
||||
{
|
||||
.chain = target->type->commands,
|
||||
},
|
||||
COMMAND_REGISTRATION_DONE
|
||||
};
|
||||
struct command *c = register_command(cmd_ctx, NULL, &target_command);
|
||||
return (NULL != c) ? ERROR_OK : ERROR_FAIL;
|
||||
const const struct command_registration target_commands[] = {
|
||||
{
|
||||
.name = cp,
|
||||
.mode = COMMAND_ANY,
|
||||
.help = "target command group",
|
||||
.chain = target_subcommands,
|
||||
},
|
||||
COMMAND_REGISTRATION_DONE
|
||||
};
|
||||
e = register_commands(cmd_ctx, NULL, target_commands);
|
||||
if (ERROR_OK != e)
|
||||
return JIM_ERR;
|
||||
|
||||
struct command *c = command_find_in_context(cmd_ctx, cp);
|
||||
assert(c);
|
||||
command_set_handler_data(c, target);
|
||||
|
||||
return (ERROR_OK == e) ? JIM_OK : JIM_ERR;
|
||||
}
|
||||
|
||||
static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
|
||||
|
|
|
|||
Loading…
Reference in New Issue