#include "config.h"
#endif
+#include <helper/time_support.h>
+#include <jtag/jtag.h>
+
#include "target.h"
#include "target_type.h"
#include "target_request.h"
#include "breakpoints.h"
-#include <helper/time_support.h>
#include "register.h"
#include "trace.h"
#include "image.h"
-#include "jtag.h"
-static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv);
-static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv);
+static int target_array2mem(Jim_Interp *interp, struct target *target,
+ int argc, Jim_Obj *const *argv);
+static int target_mem2array(Jim_Interp *interp, struct target *target,
+ int argc, Jim_Obj *const *argv);
/* targets */
extern struct target_type arm7tdmi_target;
extern struct target_type arm11_target;
extern struct target_type mips_m4k_target;
extern struct target_type avr_target;
+extern struct target_type dsp563xx_target;
extern struct target_type testee_target;
struct target_type *target_types[] =
&arm11_target,
&mips_m4k_target,
&avr_target,
+ &dsp563xx_target,
&testee_target,
NULL,
};
struct target_event_callback *target_event_callbacks = NULL;
struct target_timer_callback *target_timer_callbacks = NULL;
-const Jim_Nvp nvp_assert[] = {
+static const Jim_Nvp nvp_assert[] = {
{ .name = "assert", NVP_ASSERT },
{ .name = "deassert", NVP_DEASSERT },
{ .name = "T", NVP_ASSERT },
{ .name = NULL, .value = -1 }
};
-const Jim_Nvp nvp_error_target[] = {
+static const Jim_Nvp nvp_error_target[] = {
{ .value = ERROR_TARGET_INVALID, .name = "err-invalid" },
{ .value = ERROR_TARGET_INIT_FAILED, .name = "err-init-failed" },
{ .value = ERROR_TARGET_TIMEOUT, .name = "err-timeout" },
{ .name = NULL, .value = -1 }
};
-const Jim_Nvp nvp_target_state[] = {
+static const Jim_Nvp nvp_target_state[] = {
{ .name = "unknown", .value = TARGET_UNKNOWN },
{ .name = "running", .value = TARGET_RUNNING },
{ .name = "halted", .value = TARGET_HALTED },
{ .name = NULL, .value = -1 },
};
-const Jim_Nvp nvp_target_debug_reason [] = {
+static const Jim_Nvp nvp_target_debug_reason [] = {
{ .name = "debug-request" , .value = DBG_REASON_DBGRQ },
{ .name = "breakpoint" , .value = DBG_REASON_BREAKPOINT },
{ .name = "watchpoint" , .value = DBG_REASON_WATCHPOINT },
{ .name = NULL, .value = -1 },
};
-const Jim_Nvp nvp_target_endian[] = {
+static const Jim_Nvp nvp_target_endian[] = {
{ .name = "big", .value = TARGET_BIG_ENDIAN },
{ .name = "little", .value = TARGET_LITTLE_ENDIAN },
{ .name = "be", .value = TARGET_BIG_ENDIAN },
{ .name = NULL, .value = -1 },
};
-const Jim_Nvp nvp_reset_modes[] = {
+static const Jim_Nvp nvp_reset_modes[] = {
{ .name = "unknown", .value = RESET_UNKNOWN },
{ .name = "run" , .value = RESET_RUN },
{ .name = "halt" , .value = RESET_HALT },
{ .name = NULL , .value = -1 },
};
+const char *debug_reason_name(struct target *t)
+{
+ const char *cp;
+
+ cp = Jim_Nvp_value2name_simple(nvp_target_debug_reason,
+ t->debug_reason)->name;
+ if (!cp) {
+ LOG_ERROR("Invalid debug reason: %d", (int)(t->debug_reason));
+ cp = "(*BUG*unknown*BUG*)";
+ }
+ return cp;
+}
+
const char *
target_state_name( struct target *t )
{
/* We want any events to be processed before the prompt */
retval = target_call_timer_callbacks_now();
+ struct target *target;
+ for (target = all_targets; target; target = target->next) {
+ target->type->check_reset(target);
+ }
+
return retval;
}
return ERROR_OK;
}
+/* no check by default */
+static int default_check_reset(struct target *target)
+{
+ return ERROR_OK;
+}
+
int target_examine_one(struct target *target)
{
return target->type->examine(target);
if (type->examine == NULL)
type->examine = default_examine;
+ if (type->check_reset== NULL)
+ type->check_reset = default_check_reset;
+
int retval = type->init_target(cmd_ctx, target);
if (ERROR_OK != retval)
{
return ERROR_OK;
}
-static void target_call_event_callbacks_all(enum target_event e) {
- struct target *target;
- target = all_targets;
- while (target) {
- target_call_event_callbacks(target, e);
- target = target->next;
- }
-}
-
/* process target state changes */
static int handle_target(void *priv)
{
int did_something = 0;
if (runSrstAsserted)
{
- target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
+ LOG_INFO("srst asserted detected, running srst_asserted proc.");
Jim_Eval(interp, "srst_asserted");
did_something = 1;
}
}
if (runPowerDropout)
{
- target_call_event_callbacks_all(TARGET_EVENT_GDB_HALT);
+ LOG_INFO("Power dropout detected, running power_dropout proc.");
Jim_Eval(interp, "power_dropout");
did_something = 1;
}
/* polling may fail silently until the target has been examined */
if ((retval = target_poll(target)) != ERROR_OK)
{
+ /* FIX!!!!! If we add a LOG_INFO() here to output a line in GDB
+ * *why* we are aborting GDB, then we'll spam telnet when the
+ * poll is failing persistently.
+ *
+ * If we could implement an event that detected the
+ * target going from non-pollable to pollable, we could issue
+ * an error only upon the transition.
+ */
target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
return retval;
}
const char *value_fmt;
switch (size) {
case 4: value_fmt = "%8.8x "; break;
- case 2: value_fmt = "%4.2x "; break;
+ case 2: value_fmt = "%4.4x "; break;
case 1: value_fmt = "%2.2x "; break;
default:
+ /* "can't happen", caller checked */
LOG_ERROR("invalid memory read size: %u", size);
- exit(-1);
+ return;
}
for (unsigned i = 0; i < count; i++)
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
command_print(CMD_CTX,
- "dumped %zu bytes in %fs (%0.3f kb/s)", fileio.size,
+ "dumped %ld bytes in %fs (%0.3f kb/s)", (long)fileio.size,
duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
}
fclose(f);
}
-/* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
+/* profiling samples the CPU PC as quickly as OpenOCD is able,
+ * which will be used as a random sampling of PC */
COMMAND_HANDLER(handle_profile_command)
{
struct target *target = get_current_target(CMD_CTX);
timeval_add_time(&timeout, offset, 0);
+ /**
+ * @todo: Some cores let us sample the PC without the
+ * annoying halt/resume step; for example, ARMv7 PCSR.
+ * Provide a way to use that more efficient mechanism.
+ */
+
command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
static const int maxSample = 10000;
return target_array2mem(interp,target, argc-1, argv + 1);
}
-static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
+
+static int target_array2mem(Jim_Interp *interp, struct target *target,
+ int argc, Jim_Obj *const *argv)
{
long l;
uint32_t width;
return JIM_OK;
}
-static int jim_target_configure(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_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
- goi.isconfigure = strcmp(Jim_GetString(argv[0], NULL), "configure") == 0;
+ goi.isconfigure = !strcmp(Jim_GetString(argv[0], NULL), "configure");
int need_args = 1 + goi.isconfigure;
if (goi.argc < need_args)
{
return JIM_OK;
}
-static int jim_target_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+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)
+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);
return JIM_OK;
}
+static int jim_target_halt_gdb(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_call_event_callbacks(target, TARGET_EVENT_GDB_HALT) != ERROR_OK)
+ return JIM_ERR;
+
+ return JIM_OK;
+}
+
static int jim_target_poll(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
if (argc != 1)
struct target *target = Jim_CmdPrivData(goi.interp);
if (!target->tap->enabled)
return jim_target_tap_disabled(interp);
+ if (!(target_was_examined(target)))
+ {
+ LOG_ERROR("Target not examined yet");
+ return ERROR_TARGET_NOT_EXAMINED;
+ }
if (!target->type->assert_reset || !target->type->deassert_reset)
{
Jim_SetResult_sprintf(interp,
{
.name = "configure",
.mode = COMMAND_CONFIG,
- .jim_handler = &jim_target_configure,
- .usage = "[<target_options> ...]",
+ .jim_handler = jim_target_configure,
.help = "configure a new target for use",
+ .usage = "[target_attribute ...]",
},
{
.name = "cget",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_configure,
- .usage = "<target_type> [<target_options> ...]",
- .help = "configure a new target for use",
+ .jim_handler = jim_target_configure,
+ .help = "returns the specified target attribute",
+ .usage = "target_attribute",
},
{
.name = "mww",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_mw,
- .usage = "<address> <data> [<count>]",
+ .jim_handler = jim_target_mw,
.help = "Write 32-bit word(s) to target memory",
+ .usage = "address data [count]",
},
{
.name = "mwh",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_mw,
- .usage = "<address> <data> [<count>]",
+ .jim_handler = jim_target_mw,
.help = "Write 16-bit half-word(s) to target memory",
+ .usage = "address data [count]",
},
{
.name = "mwb",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_mw,
- .usage = "<address> <data> [<count>]",
+ .jim_handler = jim_target_mw,
.help = "Write byte(s) to target memory",
+ .usage = "address data [count]",
},
{
.name = "mdw",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_md,
- .usage = "<address> [<count>]",
+ .jim_handler = jim_target_md,
.help = "Display target memory as 32-bit words",
+ .usage = "address [count]",
},
{
.name = "mdh",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_md,
- .usage = "<address> [<count>]",
+ .jim_handler = jim_target_md,
.help = "Display target memory as 16-bit half-words",
+ .usage = "address [count]",
},
{
.name = "mdb",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_md,
- .usage = "<address> [<count>]",
+ .jim_handler = jim_target_md,
.help = "Display target memory as 8-bit bytes",
+ .usage = "address [count]",
},
{
.name = "array2mem",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_array2mem,
+ .jim_handler = jim_target_array2mem,
+ .help = "Writes Tcl array of 8/16/32 bit numbers "
+ "to target memory",
+ .usage = "arrayname bitwidth address count",
},
{
.name = "mem2array",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_mem2array,
+ .jim_handler = jim_target_mem2array,
+ .help = "Loads Tcl array of 8/16/32 bit numbers "
+ "from target memory",
+ .usage = "arrayname bitwidth address count",
},
{
.name = "eventlist",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_event_list,
+ .jim_handler = jim_target_event_list,
+ .help = "displays a table of events defined for this target",
},
{
.name = "curstate",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_current_state,
+ .jim_handler = jim_target_current_state,
+ .help = "displays the current state of this target",
},
{
.name = "arp_examine",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_examine,
+ .jim_handler = jim_target_examine,
+ .help = "used internally for reset processing",
+ },
+ {
+ .name = "arp_halt_gdb",
+ .mode = COMMAND_EXEC,
+ .jim_handler = jim_target_halt_gdb,
+ .help = "used internally for reset processing to halt GDB",
},
{
.name = "arp_poll",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_poll,
+ .jim_handler = jim_target_poll,
+ .help = "used internally for reset processing",
},
{
.name = "arp_reset",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_reset,
+ .jim_handler = jim_target_reset,
+ .help = "used internally for reset processing",
},
{
.name = "arp_halt",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_halt,
+ .jim_handler = jim_target_halt,
+ .help = "used internally for reset processing",
},
{
.name = "arp_waitstate",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_wait_state,
+ .jim_handler = jim_target_wait_state,
+ .help = "used internally for reset processing",
},
{
.name = "invoke-event",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_target_invoke_event,
+ .jim_handler = jim_target_invoke_event,
+ .help = "invoke handler for specified event",
+ .usage = "event_name",
},
COMMAND_REGISTRATION_DONE
};
}
*tpp = target;
}
-
+
/* now - create the new target name command */
const const struct command_registration target_subcommands[] = {
{
{
.name = "init",
.mode = COMMAND_CONFIG,
- .handler = &handle_target_init_command,
+ .handler = handle_target_init_command,
.help = "initialize targets",
},
{
.name = "create",
+ /* REVISIT this should be COMMAND_CONFIG ... */
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_create,
- .usage = "<name> <type> ...",
- .help = "Returns the currently selected target",
+ .jim_handler = jim_target_create,
+ .usage = "name type '-chain-position' name [options ...]",
+ .help = "Creates and selects a new target",
},
{
.name = "current",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_current,
+ .jim_handler = jim_target_current,
.help = "Returns the currently selected target",
},
{
.name = "types",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_types,
- .help = "Returns the available target types as a list of strings",
+ .jim_handler = jim_target_types,
+ .help = "Returns the available target types as "
+ "a list of strings",
},
{
.name = "names",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_names,
+ .jim_handler = jim_target_names,
.help = "Returns the names of all targets as a list of strings",
},
{
.name = "number",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_number,
- .usage = "<number>",
- .help = "Returns the name of target <n>",
+ .jim_handler = jim_target_number,
+ .usage = "number",
+ .help = "Returns the name of the numbered target "
+ "(DEPRECATED)",
},
{
.name = "count",
.mode = COMMAND_ANY,
- .jim_handler = &jim_target_count,
- .help = "Returns the number of targets as an integer",
+ .jim_handler = jim_target_count,
+ .help = "Returns the number of targets as an integer "
+ "(DEPRECATED)",
},
COMMAND_REGISTRATION_DONE
};
-
struct FastLoad
{
uint32_t address;
static const struct command_registration target_command_handlers[] = {
{
.name = "targets",
- .handler = &handle_targets_command,
+ .handler = handle_targets_command,
.mode = COMMAND_ANY,
- .help = "change current command line target (one parameter) "
- "or list targets (no parameters)",
- .usage = "[<new_current_target>]",
+ .help = "change current default target (one parameter) "
+ "or prints table of all targets (no parameters)",
+ .usage = "[target]",
},
{
.name = "target",
return register_commands(cmd_ctx, NULL, target_command_handlers);
}
+static bool target_reset_nag = true;
+
+bool get_target_reset_nag(void)
+{
+ return target_reset_nag;
+}
+
+COMMAND_HANDLER(handle_target_reset_nag)
+{
+ return CALL_COMMAND_HANDLER(handle_command_parse_bool,
+ &target_reset_nag, "Nag after each reset about options to improve "
+ "performance");
+}
+
static const struct command_registration target_exec_command_handlers[] = {
{
.name = "fast_load_image",
- .handler = &handle_fast_load_image_command,
+ .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]",
+ .help = "Load image into server memory for later use by "
+ "fast_load; primarily for profiling",
+ .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
+ "[min_address [max_length]]",
},
{
.name = "fast_load",
- .handler = &handle_fast_load_command,
- .mode = COMMAND_ANY,
+ .handler = handle_fast_load_command,
+ .mode = COMMAND_EXEC,
.help = "loads active fast load image to current target "
"- mainly for profiling purposes",
},
{
.name = "profile",
- .handler = &handle_profile_command,
+ .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,
+ .handler = handle_virt2phys_command,
.mode = COMMAND_ANY,
.help = "translate a virtual address into a physical address",
+ .usage = "virtual_address",
},
-
{
.name = "reg",
- .handler = &handle_reg_command,
+ .handler = handle_reg_command,
.mode = COMMAND_EXEC,
- .help = "display or set a register",
+ .help = "display or set a register; with no arguments, "
+ "displays all registers and their values",
+ .usage = "[(register_name|register_number) [value]]",
},
-
{
.name = "poll",
- .handler = &handle_poll_command,
+ .handler = handle_poll_command,
.mode = COMMAND_EXEC,
- .help = "poll target state",
+ .help = "poll target state; or reconfigure background polling",
+ .usage = "['on'|'off']",
},
{
.name = "wait_halt",
- .handler = &handle_wait_halt_command,
+ .handler = handle_wait_halt_command,
.mode = COMMAND_EXEC,
- .help = "wait for target halt",
- .usage = "[time (s)]",
+ .help = "wait up to the specified number of milliseconds "
+ "(default 5) for a previously requested halt",
+ .usage = "[milliseconds]",
},
{
.name = "halt",
- .handler = &handle_halt_command,
+ .handler = handle_halt_command,
.mode = COMMAND_EXEC,
- .help = "halt target",
+ .help = "request target to halt, then wait up to the specified"
+ "number of milliseconds (default 5) for it to complete",
+ .usage = "[milliseconds]",
},
{
.name = "resume",
- .handler = &handle_resume_command,
+ .handler = handle_resume_command,
.mode = COMMAND_EXEC,
- .help = "resume target",
- .usage = "[<address>]",
+ .help = "resume target execution from current PC or address",
+ .usage = "[address]",
},
{
.name = "reset",
- .handler = &handle_reset_command,
+ .handler = handle_reset_command,
.mode = COMMAND_EXEC,
.usage = "[run|halt|init]",
.help = "Reset all targets into the specified mode."
},
{
.name = "soft_reset_halt",
- .handler = &handle_soft_reset_halt_command,
+ .handler = handle_soft_reset_halt_command,
.mode = COMMAND_EXEC,
.help = "halt the target and do a soft reset",
},
{
-
.name = "step",
- .handler = &handle_step_command,
+ .handler = handle_step_command,
.mode = COMMAND_EXEC,
- .help = "step one instruction from current PC or [addr]",
- .usage = "[<address>]",
+ .help = "step one instruction from current PC or address",
+ .usage = "[address]",
},
{
-
.name = "mdw",
- .handler = &handle_md_command,
+ .handler = handle_md_command,
.mode = COMMAND_EXEC,
.help = "display memory words",
- .usage = "[phys] <addr> [count]",
+ .usage = "['phys'] address [count]",
},
{
.name = "mdh",
- .handler = &handle_md_command,
+ .handler = handle_md_command,
.mode = COMMAND_EXEC,
.help = "display memory half-words",
- .usage = "[phys] <addr> [count]",
+ .usage = "['phys'] address [count]",
},
{
.name = "mdb",
- .handler = &handle_md_command,
+ .handler = handle_md_command,
.mode = COMMAND_EXEC,
.help = "display memory bytes",
- .usage = "[phys] <addr> [count]",
+ .usage = "['phys'] address [count]",
},
{
-
.name = "mww",
- .handler = &handle_mw_command,
+ .handler = handle_mw_command,
.mode = COMMAND_EXEC,
.help = "write memory word",
- .usage = "[phys] <addr> <value> [count]",
+ .usage = "['phys'] address value [count]",
},
{
.name = "mwh",
- .handler = &handle_mw_command,
+ .handler = handle_mw_command,
.mode = COMMAND_EXEC,
.help = "write memory half-word",
- .usage = "[phys] <addr> <value> [count]",
+ .usage = "['phys'] address value [count]",
},
{
.name = "mwb",
- .handler = &handle_mw_command,
+ .handler = handle_mw_command,
.mode = COMMAND_EXEC,
.help = "write memory byte",
- .usage = "[phys] <addr> <value> [count]",
+ .usage = "['phys'] address value [count]",
},
{
-
.name = "bp",
- .handler = &handle_bp_command,
+ .handler = handle_bp_command,
.mode = COMMAND_EXEC,
- .help = "list or set breakpoint",
- .usage = "[<address> <length> [hw]]",
+ .help = "list or set hardware or software breakpoint",
+ .usage = "[address length ['hw']]",
},
{
.name = "rbp",
- .handler = &handle_rbp_command,
+ .handler = handle_rbp_command,
.mode = COMMAND_EXEC,
.help = "remove breakpoint",
- .usage = "<address>",
+ .usage = "address",
},
{
-
.name = "wp",
- .handler = &handle_wp_command,
+ .handler = handle_wp_command,
.mode = COMMAND_EXEC,
- .help = "list or set watchpoint",
- .usage = "[<address> <length> <r/w/a> [value] [mask]]",
+ .help = "list (no params) or create watchpoints",
+ .usage = "[address length [('r'|'w'|'a') value [mask]]]",
},
{
.name = "rwp",
- .handler = &handle_rwp_command,
+ .handler = handle_rwp_command,
.mode = COMMAND_EXEC,
.help = "remove watchpoint",
- .usage = "<address>",
-
+ .usage = "address",
},
{
.name = "load_image",
- .handler = &handle_load_image_command,
+ .handler = handle_load_image_command,
.mode = COMMAND_EXEC,
- .usage = "<file> <address> ['bin'|'ihex'|'elf'|'s19'] "
+ .usage = "filename address ['bin'|'ihex'|'elf'|'s19'] "
"[min_address] [max_length]",
},
{
.name = "dump_image",
- .handler = &handle_dump_image_command,
+ .handler = handle_dump_image_command,
.mode = COMMAND_EXEC,
- .usage = "<file> <address> <size>",
+ .usage = "filename address size",
},
{
.name = "verify_image",
- .handler = &handle_verify_image_command,
+ .handler = handle_verify_image_command,
.mode = COMMAND_EXEC,
- .usage = "<file> [offset] [type]",
+ .usage = "filename [offset [type]]",
},
{
.name = "test_image",
- .handler = &handle_test_image_command,
+ .handler = handle_test_image_command,
.mode = COMMAND_EXEC,
- .usage = "<file> [offset] [type]",
+ .usage = "filename [offset [type]]",
},
{
.name = "ocd_mem2array",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_mem2array,
- .help = "read memory and return as a TCL array "
+ .jim_handler = jim_mem2array,
+ .help = "read 8/16/32 bit memory and return as a TCL array "
"for script processing",
- .usage = "<arrayname> <width=32|16|8> <address> <count>",
+ .usage = "arrayname bitwidth address count",
},
{
.name = "ocd_array2mem",
.mode = COMMAND_EXEC,
- .jim_handler = &jim_array2mem,
+ .jim_handler = jim_array2mem,
.help = "convert a TCL array to memory locations "
- "and write the values",
- .usage = "<arrayname> <width=32|16|8> <address> <count>",
+ "and write the 8/16/32 bit values",
+ .usage = "arrayname bitwidth address count",
+ },
+ {
+ .name = "reset_nag",
+ .handler = handle_target_reset_nag,
+ .mode = COMMAND_ANY,
+ .help = "Nag after each reset about options that could have been "
+ "enabled to improve performance. ",
+ .usage = "['enable'|'disable']",
},
COMMAND_REGISTRATION_DONE
};
Code Review / openocd.git / blobdiff