extern struct target_type arm11_target;
extern struct target_type mips_m4k_target;
extern struct target_type avr_target;
+extern struct target_type testee_target;
struct target_type *target_types[] =
{
&arm11_target,
&mips_m4k_target,
&avr_target,
+ &testee_target,
NULL,
};
{ .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
{ .value = TARGET_EVENT_RESET_ASSERT_PRE, .name = "reset-assert-pre" },
+ { .value = TARGET_EVENT_RESET_ASSERT, .name = "reset-assert" },
{ .value = TARGET_EVENT_RESET_ASSERT_POST, .name = "reset-assert-post" },
{ .value = TARGET_EVENT_RESET_DEASSERT_PRE, .name = "reset-deassert-pre" },
{ .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
{ .value = TARGET_EVENT_RESET_HALT_POST, .name = "reset-halt-post" },
{ .value = TARGET_EVENT_RESET_WAIT_PRE, .name = "reset-wait-pre" },
{ .value = TARGET_EVENT_RESET_WAIT_POST, .name = "reset-wait-post" },
- { .value = TARGET_EVENT_RESET_INIT , .name = "reset-init" },
- { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
+ { .value = TARGET_EVENT_RESET_INIT, .name = "reset-init" },
+ { .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
{ .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
{ .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
}
return retval;
}
-const char *target_get_name(struct target *target)
+const char *target_type_name(struct target *target)
{
return target->type->name;
}
}
if (!target->type->soft_reset_halt_imp) {
LOG_ERROR("Target %s does not support soft_reset_halt",
- target->cmd_name);
+ target_name(target));
return ERROR_FAIL;
}
return target->type->soft_reset_halt_imp(target);
int target_add_breakpoint(struct target *target,
struct breakpoint *breakpoint)
{
+ if (target->state != TARGET_HALTED) {
+ LOG_WARNING("target %s is not halted", target->cmd_name);
+ return ERROR_TARGET_NOT_HALTED;
+ }
return target->type->add_breakpoint(target, breakpoint);
}
int target_remove_breakpoint(struct target *target,
int target_add_watchpoint(struct target *target,
struct watchpoint *watchpoint)
{
+ if (target->state != TARGET_HALTED) {
+ LOG_WARNING("target %s is not halted", target->cmd_name);
+ return ERROR_TARGET_NOT_HALTED;
+ }
return target->type->add_watchpoint(target, watchpoint);
}
int target_remove_watchpoint(struct target *target,
if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
{
- LOG_ERROR("target '%s' init failed", target_get_name(target));
+ LOG_ERROR("target '%s' init failed", target_name(target));
return retval;
}
target->type->mcr = default_mcr;
} else
{
- /* FIX! multiple targets will generally register global commands
- * multiple times. Only register this one if *one* of the
- * targets need the command. Hmm... make it a command on the
- * Jim Tcl target object?
- */
- register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
+ const struct command_registration mcr_cmd = {
+ .name = "mcr",
+ .mode = COMMAND_EXEC,
+ .jim_handler = &jim_mcrmrc,
+ .help = "write coprocessor",
+ .usage = "<cpnum> <op1> <op2> <CRn> <CRm> <value>",
+ };
+ register_command(cmd_ctx, NULL, &mcr_cmd);
}
if (target->type->mrc == NULL)
target->type->mrc = default_mrc;
} else
{
- register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
+ const struct command_registration mrc_cmd = {
+ .name = "mrc",
+ .jim_handler = &jim_mcrmrc,
+ .help = "read coprocessor",
+ .usage = "<cpnum> <op1> <op2> <CRn> <CRm>",
+ };
+ register_command(cmd_ctx, NULL, &mrc_cmd);
}
command_print(CMD_CTX, "%2d%c %-18s %-10s %-6s %-18s %s",
target->target_number,
marker,
- target->cmd_name,
- target_get_name(target),
+ target_name(target),
+ target_type_name(target),
Jim_Nvp_value2name_simple(nvp_target_endian,
target->endianness)->name,
target->tap->dotted_name,
if (teap->event == e) {
LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
target->target_number,
- target->cmd_name,
- target_get_name(target),
+ target_name(target),
+ target_type_name(target),
e,
Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
Jim_GetString(teap->body, NULL));
}
}
+/**
+ * Returns true only if the target has a handler for the specified event.
+ */
+bool target_has_event_action(struct target *target, enum target_event event)
+{
+ struct target_event_action *teap;
+
+ for (teap = target->event_action; teap != NULL; teap = teap->next) {
+ if (teap->event == event)
+ return true;
+ }
+ return false;
+}
+
enum target_cfg_param {
TCFG_TYPE,
TCFG_EVENT,
case TCFG_TYPE:
/* not setable */
if (goi->isconfigure) {
- Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
+ Jim_SetResult_sprintf(goi->interp,
+ "not settable: %s", n->name);
return JIM_ERR;
} else {
no_params:
if (goi->argc != 0) {
- Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
+ Jim_WrongNumArgs(goi->interp,
+ goi->argc, goi->argv,
+ "NO PARAMS");
return JIM_ERR;
}
}
- Jim_SetResultString(goi->interp, target_get_name(target), -1);
+ Jim_SetResultString(goi->interp,
+ target_type_name(target), -1);
/* loop for more */
break;
case TCFG_EVENT:
|| !target->type->deassert_reset) {
Jim_SetResult_sprintf(interp,
"No target-specific reset for %s",
- target->cmd_name);
+ target_name(target));
return JIM_ERR;
}
/* determine if we should halt or not. */
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->cmd_name,
- n->name,
- e, target_strerror_safe(e));
+ "target: %s wait %s fails (%d) %s",
+ target_name(target), n->name,
+ e, target_strerror_safe(e));
return JIM_ERR;
} else {
return JIM_OK;
{
struct target_event_action *teap;
teap = target->event_action;
- command_print(cmd_ctx, "Event actions for target (%d) %s\n",
- target->target_number,
- target->cmd_name);
+ 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) {
if (!target->variant)
target->variant = strdup("");
+ cp = Jim_GetString(new_cmd, NULL);
+ target->cmd_name = strdup(cp);
+
/* create the target specific commands */
- if (target->type->register_commands) {
- (*(target->type->register_commands))(cmd_ctx);
+ if (target->type->commands) {
+ e = register_commands(cmd_ctx, NULL, target->type->commands);
+ if (ERROR_OK != e)
+ LOG_ERROR("unable to register '%s' commands", cp);
}
if (target->type->target_create) {
(*(target->type->target_create))(target, goi->interp);
*tpp = target;
}
- cp = Jim_GetString(new_cmd, NULL);
- target->cmd_name = strdup(cp);
-
/* now - create the new target name command */
- e = Jim_CreateCommand(goi->interp,
- /* name */
- cp,
- tcl_target_func, /* C function */
- target, /* private data */
- NULL); /* no del proc */
-
- return e;
+ const struct command_registration target_command = {
+ .name = cp,
+ .jim_handler = &tcl_target_func,
+ .jim_handler_data = target,
+ .help = "target command group",
+ };
+ struct command *c = register_command(cmd_ctx, NULL, &target_command);
+ return (NULL != c) ? ERROR_OK : ERROR_FAIL;
}
static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
return JIM_ERR;
}
- Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
+ Jim_SetResultString(goi.interp,
+ target_name(get_current_target(cmd_ctx)),
+ -1);
return JIM_OK;
case TG_CMD_TYPES:
if (goi.argc != 0) {
target = all_targets;
while (target) {
Jim_ListAppendElement(goi.interp,
- Jim_GetResult(goi.interp),
- Jim_NewStringObj(goi.interp, target->cmd_name, -1));
+ Jim_GetResult(goi.interp),
+ Jim_NewStringObj(goi.interp,
+ target_name(target), -1));
target = target->next;
}
return JIM_OK;
"Target: number %d does not exist", (int)(w));
return JIM_ERR;
}
- Jim_SetResultString(goi.interp, target->cmd_name, -1);
+ Jim_SetResultString(goi.interp, target_name(target), -1);
return JIM_OK;
case TG_CMD_COUNT:
if (goi.argc != 0) {
return JIM_OK;
}
+static const struct command_registration target_command_handlers[] = {
+ {
+ .name = "targets",
+ .handler = &handle_targets_command,
+ .mode = COMMAND_ANY,
+ .help = "change current command line target (one parameter) "
+ "or list targets (no parameters)",
+ .usage = "[<new_current_target>]",
+ },
+ {
+ .name = "target",
+ .mode = COMMAND_CONFIG,
+ .jim_handler = &jim_target,
+ .help = "configure target",
+ },
+ COMMAND_REGISTRATION_DONE
+};
+
int target_register_commands(struct command_context *cmd_ctx)
{
-
- COMMAND_REGISTER(cmd_ctx, NULL, "targets",
- handle_targets_command, COMMAND_EXEC,
- "change current command line target (one parameter) "
- "or list targets (no parameters)");
-
- register_jim(cmd_ctx, "target", jim_target, "configure target");
-
- return ERROR_OK;
+ return register_commands(cmd_ctx, NULL, target_command_handlers);
}
+static const struct command_registration target_exec_command_handlers[] = {
+ {
+ .name = "fast_load_image",
+ .handler = &handle_fast_load_image_command,
+ .mode = COMMAND_ANY,
+ .help = "Load image into memory, mainly for profiling purposes",
+ .usage = "<file> <address> ['bin'|'ihex'|'elf'|'s19'] "
+ "[min_address] [max_length]",
+ },
+ {
+ .name = "fast_load",
+ .handler = &handle_fast_load_command,
+ .mode = COMMAND_ANY,
+ .help = "loads active fast load image to current target "
+ "- mainly for profiling purposes",
+ },
+ {
+ .name = "profile",
+ .handler = &handle_profile_command,
+ .mode = COMMAND_EXEC,
+ .help = "profiling samples the CPU PC",
+ },
+ /** @todo don't register virt2phys() unless target supports it */
+ {
+ .name = "virt2phys",
+ .handler = &handle_virt2phys_command,
+ .mode = COMMAND_ANY,
+ .help = "translate a virtual address into a physical address",
+ },
+
+ {
+ .name = "reg",
+ .handler = &handle_reg_command,
+ .mode = COMMAND_EXEC,
+ .help = "display or set a register",
+ },
+
+ {
+ .name = "poll",
+ .handler = &handle_poll_command,
+ .mode = COMMAND_EXEC,
+ .help = "poll target state",
+ },
+ {
+ .name = "wait_halt",
+ .handler = &handle_wait_halt_command,
+ .mode = COMMAND_EXEC,
+ .help = "wait for target halt",
+ .usage = "[time (s)]",
+ },
+ {
+ .name = "halt",
+ .handler = &handle_halt_command,
+ .mode = COMMAND_EXEC,
+ .help = "halt target",
+ },
+ {
+ .name = "resume",
+ .handler = &handle_resume_command,
+ .mode = COMMAND_EXEC,
+ .help = "resume target",
+ .usage = "[<address>]",
+ },
+ {
+ .name = "reset",
+ .handler = &handle_reset_command,
+ .mode = COMMAND_EXEC,
+ .usage = "[run|halt|init]",
+ .help = "Reset all targets into the specified mode."
+ "Default reset mode is run, if not given.",
+ },
+ {
+ .name = "soft_reset_halt",
+ .handler = &handle_soft_reset_halt_command,
+ .mode = COMMAND_EXEC,
+ .help = "halt the target and do a soft reset",
+ },
+ {
+
+ .name = "step",
+ .handler = &handle_step_command,
+ .mode = COMMAND_EXEC,
+ .help = "step one instruction from current PC or [addr]",
+ .usage = "[<address>]",
+ },
+ {
+
+ .name = "mdw",
+ .handler = &handle_md_command,
+ .mode = COMMAND_EXEC,
+ .help = "display memory words",
+ .usage = "[phys] <addr> [count]",
+ },
+ {
+ .name = "mdh",
+ .handler = &handle_md_command,
+ .mode = COMMAND_EXEC,
+ .help = "display memory half-words",
+ .usage = "[phys] <addr> [count]",
+ },
+ {
+ .name = "mdb",
+ .handler = &handle_md_command,
+ .mode = COMMAND_EXEC,
+ .help = "display memory bytes",
+ .usage = "[phys] <addr> [count]",
+ },
+ {
+
+ .name = "mww",
+ .handler = &handle_mw_command,
+ .mode = COMMAND_EXEC,
+ .help = "write memory word",
+ .usage = "[phys] <addr> <value> [count]",
+ },
+ {
+ .name = "mwh",
+ .handler = &handle_mw_command,
+ .mode = COMMAND_EXEC,
+ .help = "write memory half-word",
+ .usage = "[phys] <addr> <value> [count]",
+ },
+ {
+ .name = "mwb",
+ .handler = &handle_mw_command,
+ .mode = COMMAND_EXEC,
+ .help = "write memory byte",
+ .usage = "[phys] <addr> <value> [count]",
+ },
+ {
+
+ .name = "bp",
+ .handler = &handle_bp_command,
+ .mode = COMMAND_EXEC,
+ .help = "list or set breakpoint",
+ .usage = "[<address> <length> [hw]]",
+ },
+ {
+ .name = "rbp",
+ .handler = &handle_rbp_command,
+ .mode = COMMAND_EXEC,
+ .help = "remove breakpoint",
+ .usage = "<address>",
+ },
+ {
+
+ .name = "wp",
+ .handler = &handle_wp_command,
+ .mode = COMMAND_EXEC,
+ .help = "list or set watchpoint",
+ .usage = "[<address> <length> <r/w/a> [value] [mask]]",
+ },
+ {
+ .name = "rwp",
+ .handler = &handle_rwp_command,
+ .mode = COMMAND_EXEC,
+ .help = "remove watchpoint",
+ .usage = "<address>",
+
+ },
+ {
+ .name = "load_image",
+ .handler = &handle_load_image_command,
+ .mode = COMMAND_EXEC,
+ .usage = "<file> <address> ['bin'|'ihex'|'elf'|'s19'] "
+ "[min_address] [max_length]",
+ },
+ {
+ .name = "dump_image",
+ .handler = &handle_dump_image_command,
+ .mode = COMMAND_EXEC,
+ .usage = "<file> <address> <size>",
+ },
+ {
+ .name = "verify_image",
+ .handler = &handle_verify_image_command,
+ .mode = COMMAND_EXEC,
+ .usage = "<file> [offset] [type]",
+ },
+ {
+ .name = "test_image",
+ .handler = &handle_test_image_command,
+ .mode = COMMAND_EXEC,
+ .usage = "<file> [offset] [type]",
+ },
+ {
+ .name = "ocd_mem2array",
+ .mode = COMMAND_EXEC,
+ .jim_handler = &jim_mem2array,
+ .help = "read memory and return as a TCL array "
+ "for script processing",
+ .usage = "<arrayname> <width=32|16|8> <address> <count>",
+ },
+ {
+ .name = "ocd_array2mem",
+ .mode = COMMAND_EXEC,
+ .jim_handler = &jim_array2mem,
+ .help = "convert a TCL array to memory locations "
+ "and write the values",
+ .usage = "<arrayname> <width=32|16|8> <address> <count>",
+ },
+ COMMAND_REGISTRATION_DONE
+};
int target_register_user_commands(struct command_context *cmd_ctx)
{
int retval = ERROR_OK;
if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
return retval;
- COMMAND_REGISTER(cmd_ctx, NULL, "profile",
- handle_profile_command, COMMAND_EXEC,
- "profiling samples the CPU PC");
-
- register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array,
- "read memory and return as a TCL array for script processing "
- "<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
-
- register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem,
- "convert a TCL array to memory locations and write the values "
- "<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "fast_load_image",
- handle_fast_load_image_command, COMMAND_ANY,
- "same CMD_ARGV as load_image, image stored in memory "
- "- mainly for profiling purposes");
- COMMAND_REGISTER(cmd_ctx, NULL, "fast_load",
- handle_fast_load_command, COMMAND_ANY,
- "loads active fast load image to current target "
- "- mainly for profiling purposes");
-
- /** @todo don't register virt2phys() unless target supports it */
- COMMAND_REGISTER(cmd_ctx, NULL, "virt2phys",
- handle_virt2phys_command, COMMAND_ANY,
- "translate a virtual address into a physical address");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "reg",
- handle_reg_command, COMMAND_EXEC,
- "display or set a register");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "poll",
- handle_poll_command, COMMAND_EXEC,
- "poll target state");
- COMMAND_REGISTER(cmd_ctx, NULL, "wait_halt",
- handle_wait_halt_command, COMMAND_EXEC,
- "wait for target halt [time (s)]");
- COMMAND_REGISTER(cmd_ctx, NULL, "halt",
- handle_halt_command, COMMAND_EXEC,
- "halt target");
- COMMAND_REGISTER(cmd_ctx, NULL, "resume",
- handle_resume_command, COMMAND_EXEC,
- "resume target [addr]");
- COMMAND_REGISTER(cmd_ctx, NULL, "reset",
- handle_reset_command, COMMAND_EXEC,
- "reset target [run | halt | init] - default is run");
- COMMAND_REGISTER(cmd_ctx, NULL, "soft_reset_halt",
- handle_soft_reset_halt_command, COMMAND_EXEC,
- "halt the target and do a soft reset");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "step",
- handle_step_command, COMMAND_EXEC,
- "step one instruction from current PC or [addr]");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "mdw",
- handle_md_command, COMMAND_EXEC,
- "display memory words [phys] <addr> [count]");
- COMMAND_REGISTER(cmd_ctx, NULL, "mdh",
- handle_md_command, COMMAND_EXEC,
- "display memory half-words [phys] <addr> [count]");
- COMMAND_REGISTER(cmd_ctx, NULL, "mdb",
- handle_md_command, COMMAND_EXEC,
- "display memory bytes [phys] <addr> [count]");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "mww",
- handle_mw_command, COMMAND_EXEC,
- "write memory word [phys] <addr> <value> [count]");
- COMMAND_REGISTER(cmd_ctx, NULL, "mwh",
- handle_mw_command, COMMAND_EXEC,
- "write memory half-word [phys] <addr> <value> [count]");
- COMMAND_REGISTER(cmd_ctx, NULL, "mwb",
- handle_mw_command, COMMAND_EXEC,
- "write memory byte [phys] <addr> <value> [count]");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "bp",
- handle_bp_command, COMMAND_EXEC,
- "list or set breakpoint [<address> <length> [hw]]");
- COMMAND_REGISTER(cmd_ctx, NULL, "rbp",
- handle_rbp_command, COMMAND_EXEC,
- "remove breakpoint <address>");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "wp",
- handle_wp_command, COMMAND_EXEC,
- "list or set watchpoint "
- "[<address> <length> <r/w/a> [value] [mask]]");
- COMMAND_REGISTER(cmd_ctx, NULL, "rwp",
- handle_rwp_command, COMMAND_EXEC,
- "remove watchpoint <address>");
-
- COMMAND_REGISTER(cmd_ctx, NULL, "load_image",
- handle_load_image_command, COMMAND_EXEC,
- "load_image <file> <address> "
- "['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
- COMMAND_REGISTER(cmd_ctx, NULL, "dump_image",
- handle_dump_image_command, COMMAND_EXEC,
- "dump_image <file> <address> <size>");
- COMMAND_REGISTER(cmd_ctx, NULL, "verify_image",
- handle_verify_image_command, COMMAND_EXEC,
- "verify_image <file> [offset] [type]");
- COMMAND_REGISTER(cmd_ctx, NULL, "test_image",
- handle_test_image_command, COMMAND_EXEC,
- "test_image <file> [offset] [type]");
-
- return ERROR_OK;
+ return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
}
Code Review / openocd.git / blobdiff