|
|
@@ -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,422 +3849,537 @@ 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, |
|
|
|
|
|
|
|
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 int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
|
|
|
{ |
|
|
|
const char *cmd_name = Jim_GetString(argv[0], NULL); |
|
|
|
|
|
|
|
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 }, |
|
|
|
}; |
|
|
|
Jim_GetOptInfo goi; |
|
|
|
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1); |
|
|
|
|
|
|
|
/* go past the "command" */ |
|
|
|
Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1); |
|
|
|
if (goi.argc != 2 && goi.argc != 3) |
|
|
|
{ |
|
|
|
Jim_SetResult_sprintf(goi.interp, |
|
|
|
"usage: %s <address> <data> [<count>]", cmd_name); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
target = Jim_CmdPrivData(goi.interp); |
|
|
|
cmd_ctx = Jim_GetAssocData(goi.interp, "context"); |
|
|
|
jim_wide a; |
|
|
|
int e = Jim_GetOpt_Wide(&goi, &a); |
|
|
|
if (e != JIM_OK) |
|
|
|
return e; |
|
|
|
|
|
|
|
/* 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 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. |
|
|
|
*/ |
|
|
|
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; |
|
|
|
} |
|
|
|
else if (strcasecmp(cmd_name, "mwh") == 0) { |
|
|
|
target_buffer_set_u16(target, target_buf, b); |
|
|
|
b = 2; |
|
|
|
} |
|
|
|
else if (strcasecmp(cmd_name, "mwb") == 0) { |
|
|
|
target_buffer_set_u8(target, target_buf, b); |
|
|
|
b = 1; |
|
|
|
} else { |
|
|
|
LOG_ERROR("command '%s' unknown: ", cmd_name); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
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); |
|
|
|
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); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
/* b = width */ |
|
|
|
a = a + b; |
|
|
|
} |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
|
|
|
|
e = Jim_GetOpt_Wide(&goi, &a); |
|
|
|
if (e != JIM_OK) { |
|
|
|
goto mwx_error; |
|
|
|
} |
|
|
|
static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
|
|
|
{ |
|
|
|
const char *cmd_name = Jim_GetString(argv[0], NULL); |
|
|
|
|
|
|
|
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; |
|
|
|
} |
|
|
|
Jim_GetOptInfo goi; |
|
|
|
Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1); |
|
|
|
|
|
|
|
switch (n->value) { |
|
|
|
case TS_CMD_MWW: |
|
|
|
target_buffer_set_u32(target, target_buf, b); |
|
|
|
b = 4; |
|
|
|
break; |
|
|
|
case TS_CMD_MWH: |
|
|
|
target_buffer_set_u16(target, target_buf, b); |
|
|
|
b = 2; |
|
|
|
break; |
|
|
|
case TS_CMD_MWB: |
|
|
|
target_buffer_set_u8(target, target_buf, b); |
|
|
|
b = 1; |
|
|
|
break; |
|
|
|
} |
|
|
|
for (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); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
/* b = width */ |
|
|
|
a = a + b; |
|
|
|
} |
|
|
|
return JIM_OK; |
|
|
|
break; |
|
|
|
if ((goi.argc == 2) || (goi.argc == 3)) |
|
|
|
{ |
|
|
|
Jim_SetResult_sprintf(goi.interp, |
|
|
|
"usage: %s <address> [<count>]", cmd_name); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
/* 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); |
|
|
|
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) { |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
if (goi.argc) { |
|
|
|
e = Jim_GetOpt_Wide(&goi, &c); |
|
|
|
if (e != JIM_OK) { |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
} else { |
|
|
|
c = 1; |
|
|
|
} else { |
|
|
|
c = 1; |
|
|
|
} |
|
|
|
jim_wide b = 1; /* shut up gcc */ |
|
|
|
if (strcasecmp(cmd_name, "mdw") == 0) |
|
|
|
b = 4; |
|
|
|
else if (strcasecmp(cmd_name, "mdh") == 0) |
|
|
|
b = 2; |
|
|
|
else if (strcasecmp(cmd_name, "mdb") == 0) |
|
|
|
b = 1; |
|
|
|
else { |
|
|
|
LOG_ERROR("command '%s' unknown: ", cmd_name); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
/* convert count to "bytes" */ |
|
|
|
c = c * b; |
|
|
|
|
|
|
|
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) { |
|
|
|
y = 16; |
|
|
|
} |
|
|
|
b = 1; /* shut up gcc */ |
|
|
|
switch (n->value) { |
|
|
|
case TS_CMD_MDW: |
|
|
|
b = 4; |
|
|
|
break; |
|
|
|
case TS_CMD_MDH: |
|
|
|
b = 2; |
|
|
|
break; |
|
|
|
case TS_CMD_MDB: |
|
|
|
b = 1; |
|
|
|
break; |
|
|
|
e = target_read_memory(target, a, b, y / b, target_buf); |
|
|
|
if (e != ERROR_OK) { |
|
|
|
Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a)); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
/* convert to "bytes" */ |
|
|
|
c = c * b; |
|
|
|
/* count is now in 'BYTES' */ |
|
|
|
while (c > 0) { |
|
|
|
y = c; |
|
|
|
if (y > 16) { |
|
|
|
y = 16; |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a)); |
|
|
|
switch (b) { |
|
|
|
case 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)); |
|
|
|
} |
|
|
|
e = target_read_memory(target, a, b, y / b, target_buf); |
|
|
|
if (e != ERROR_OK) { |
|
|
|
Jim_SetResult_sprintf(interp, "error reading target @ 0x%08lx", (int)(a)); |
|
|
|
return JIM_ERR; |
|
|
|
for (; (x < 16) ; x += 4) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
|
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "0x%08x ", (int)(a)); |
|
|
|
switch (b) { |
|
|
|
case 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)); |
|
|
|
} |
|
|
|
for (; (x < 16) ; x += 4) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 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)); |
|
|
|
} |
|
|
|
for (; (x < 16) ; x += 2) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
break; |
|
|
|
case 1: |
|
|
|
default: |
|
|
|
for (x = 0 ; (x < 16) && (x < y) ; x += 1) { |
|
|
|
z = target_buffer_get_u8(target, &(target_buf[ x * 4 ])); |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z)); |
|
|
|
} |
|
|
|
for (; (x < 16) ; x += 1) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
break; |
|
|
|
break; |
|
|
|
case 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)); |
|
|
|
} |
|
|
|
/* ascii-ify the bytes */ |
|
|
|
for (x = 0 ; x < y ; x++) { |
|
|
|
if ((target_buf[x] >= 0x20) && |
|
|
|
(target_buf[x] <= 0x7e)) { |
|
|
|
/* good */ |
|
|
|
} else { |
|
|
|
/* smack it */ |
|
|
|
target_buf[x] = '.'; |
|
|
|
} |
|
|
|
for (; (x < 16) ; x += 2) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
/* space pad */ |
|
|
|
while (x < 16) { |
|
|
|
target_buf[x] = ' '; |
|
|
|
x++; |
|
|
|
break; |
|
|
|
case 1: |
|
|
|
default: |
|
|
|
for (x = 0 ; (x < 16) && (x < y) ; x += 1) { |
|
|
|
z = target_buffer_get_u8(target, &(target_buf[ x * 4 ])); |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "%02x ", (int)(z)); |
|
|
|
} |
|
|
|
/* terminate */ |
|
|
|
target_buf[16] = 0; |
|
|
|
/* print - with a newline */ |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf); |
|
|
|
/* NEXT... */ |
|
|
|
c -= 16; |
|
|
|
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]"); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
if (!target->tap->enabled) |
|
|
|
goto err_tap_disabled; |
|
|
|
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]"); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
if (!target->tap->enabled) |
|
|
|
goto err_tap_disabled; |
|
|
|
if (!(target_was_examined(target))) { |
|
|
|
e = ERROR_TARGET_NOT_EXAMINED; |
|
|
|
} else { |
|
|
|
e = target->type->poll(target); |
|
|
|
} |
|
|
|
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, |
|
|
|
"([tT]|[fF]|assert|deassert) BOOL"); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
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 */ |
|
|
|
e = Jim_GetOpt_Wide(&goi, &a); |
|
|
|
if (e != JIM_OK) { |
|
|
|
return e; |
|
|
|
} |
|
|
|
if (!target->tap->enabled) |
|
|
|
goto err_tap_disabled; |
|
|
|
if (!target->type->assert_reset |
|
|
|
|| !target->type->deassert_reset) { |
|
|
|
Jim_SetResult_sprintf(interp, |
|
|
|
"No target-specific reset for %s", |
|
|
|
target_name(target)); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
/* determine if we should halt or not. */ |
|
|
|
target->reset_halt = !!a; |
|
|
|
/* When this happens - all workareas are invalid. */ |
|
|
|
target_free_all_working_areas_restore(target, 0); |
|
|
|
|
|
|
|
/* do the assert */ |
|
|
|
if (n->value == NVP_ASSERT) { |
|
|
|
e = target->type->assert_reset(target); |
|
|
|
} else { |
|
|
|
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]"); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
if (!target->tap->enabled) |
|
|
|
goto err_tap_disabled; |
|
|
|
e = target->type->halt(target); |
|
|
|
return (e == ERROR_OK) ? JIM_OK : JIM_ERR; |
|
|
|
case TS_CMD_WAITSTATE: |
|
|
|
/* params: <name> statename timeoutmsecs */ |
|
|
|
if (goi.argc != 2) { |
|
|
|
Jim_SetResult_sprintf(goi.interp, "%s STATENAME TIMEOUTMSECS", n->name); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
e = Jim_GetOpt_Nvp(&goi, nvp_target_state, &n); |
|
|
|
if (e != JIM_OK) { |
|
|
|
Jim_GetOpt_NvpUnknown(&goi, nvp_target_state,1); |
|
|
|
return e; |
|
|
|
} |
|
|
|
e = Jim_GetOpt_Wide(&goi, &a); |
|
|
|
if (e != JIM_OK) { |
|
|
|
return e; |
|
|
|
} |
|
|
|
if (!target->tap->enabled) |
|
|
|
goto err_tap_disabled; |
|
|
|
e = target_wait_state(target, n->value, a); |
|
|
|
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' |
|
|
|
*/ |
|
|
|
{ |
|
|
|
struct target_event_action *teap; |
|
|
|
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)); |
|
|
|
teap = teap->next; |
|
|
|
for (; (x < 16) ; x += 1) { |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, " "); |
|
|
|
} |
|
|
|
command_print(cmd_ctx, "***END***"); |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
case TS_CMD_CURSTATE: |
|
|
|
if (goi.argc != 0) { |
|
|
|
Jim_WrongNumArgs(goi.interp, 0, argv, "[no parameters]"); |
|
|
|
return JIM_ERR; |
|
|
|
break; |
|
|
|
} |
|
|
|
Jim_SetResultString(goi.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); |
|
|
|
return JIM_ERR; |
|
|
|
/* ascii-ify the bytes */ |
|
|
|
for (x = 0 ; x < y ; x++) { |
|
|
|
if ((target_buf[x] >= 0x20) && |
|
|
|
(target_buf[x] <= 0x7e)) { |
|
|
|
/* good */ |
|
|
|
} else { |
|
|
|
/* smack it */ |
|
|
|
target_buf[x] = '.'; |
|
|
|
} |
|
|
|
} |
|
|
|
e = Jim_GetOpt_Nvp(&goi, nvp_target_event, &n); |
|
|
|
if (e != JIM_OK) { |
|
|
|
Jim_GetOpt_NvpUnknown(&goi, nvp_target_event, 1); |
|
|
|
return e; |
|
|
|
/* space pad */ |
|
|
|
while (x < 16) { |
|
|
|
target_buf[x] = ' '; |
|
|
|
x++; |
|
|
|
} |
|
|
|
target_handle_event(target, n->value); |
|
|
|
return JIM_OK; |
|
|
|
/* terminate */ |
|
|
|
target_buf[16] = 0; |
|
|
|
/* print - with a newline */ |
|
|
|
Jim_fprintf(interp, interp->cookie_stdout, "%s\n", target_buf); |
|
|
|
/* NEXT... */ |
|
|
|
c -= 16; |
|
|
|
a += 16; |
|
|
|
} |
|
|
|
return JIM_ERR; |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
|
|
|
|
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); |
|
|
|
} |
|
|
|
|
|
|
|
err_tap_disabled: |
|
|
|
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) |
|
|
|
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; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
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) |
|
|
|
{ |
|
|
|
Jim_SetResult_sprintf(interp, "poll-fails: %d", e); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
|
|
|
|
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; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
return e; |
|
|
|
|
|
|
|
struct target *target = Jim_CmdPrivData(goi.interp); |
|
|
|
if (!target->tap->enabled) |
|
|
|
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)); |
|
|
|
return JIM_ERR; |
|
|
|
} |
|
|
|
/* determine if we should halt or not. */ |
|
|
|
target->reset_halt = !!a; |
|
|
|
/* When this happens - all workareas are invalid. */ |
|
|
|
target_free_all_working_areas_restore(target, 0); |
|
|
|
|
|
|
|
/* do the assert */ |
|
|
|
if (n->value == NVP_ASSERT) { |
|
|
|
e = target->type->assert_reset(target); |
|
|
|
} else { |
|
|
|
e = target->type->deassert_reset(target); |
|
|
|
} |
|
|
|
return (e == ERROR_OK) ? JIM_OK : JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
return jim_target_tap_disabled(interp); |
|
|
|
int e = target->type->halt(target); |
|
|
|
return (e == ERROR_OK) ? JIM_OK : JIM_ERR; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
{ |
|
|
|
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; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
return jim_target_tap_disabled(interp); |
|
|
|
|
|
|
|
e = target_wait_state(target, n->value, a); |
|
|
|
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; |
|
|
|
} |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
/* 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 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) |
|
|
|
{ |
|
|
|
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; |
|
|
|
} |
|
|
|
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; |
|
|
|
} |
|
|
|
struct target *target = Jim_CmdPrivData(interp); |
|
|
|
Jim_SetResultString(interp, target_state_name(target), -1); |
|
|
|
return JIM_OK; |
|
|
|
} |
|
|
|
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; |
|
|
|
} |
|
|
|
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; |
|
|
|
} |
|
|
|
|
|
|
|
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) |
|
|
|
{ |
|
|
|
Jim_Obj *new_cmd; |
|
|
@@ -4412,16 +4527,35 @@ static int target_create(Jim_GetOptInfo *goi) |
|
|
|
} |
|
|
|
*tpp = target; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* 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) |
|
|
|