#include "jtag.h"
-static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
-static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
-static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
-static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv);
return retval;
}
-static int default_virt2phys(struct target_s *target, uint32_t virtual, uint32_t *physical)
+static int identity_virt2phys(struct target_s *target,
+ uint32_t virtual, uint32_t *physical)
{
*physical = virtual;
return ERROR_OK;
}
-static int default_mmu(struct target_s *target, int *enabled)
+static int no_mmu(struct target_s *target, int *enabled)
{
- LOG_ERROR("Not implemented.");
- return ERROR_FAIL;
-}
-
-static int default_has_mmu(struct target_s *target, bool *has_mmu)
-{
- *has_mmu = true;
+ *enabled = 0;
return ERROR_OK;
}
static int default_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
{
- LOG_ERROR("Not implemented");
+ LOG_ERROR("Not implemented: %s", __func__);
return ERROR_FAIL;
}
static int default_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
{
- LOG_ERROR("Not implemented");
+ LOG_ERROR("Not implemented: %s", __func__);
return ERROR_FAIL;
}
return ERROR_FAIL;
}
+ if (op1 > 7)
+ {
+ LOG_ERROR("Illegal op1");
+ return ERROR_FAIL;
+ }
+
+ if (op2 > 7)
+ {
+ LOG_ERROR("Illegal op2");
+ return ERROR_FAIL;
+ }
+
+ if (CRn > 15)
+ {
+ LOG_ERROR("Illegal CRn");
+ return ERROR_FAIL;
+ }
+
+ if (CRm > 15)
+ {
+ LOG_ERROR("Illegal CRm");
+ return ERROR_FAIL;
+ }
+
return ERROR_OK;
}
return target->type->mcr(target, cpnum, op1, op2, CRn, CRm, value);
}
-static int default_read_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int
+err_read_phys_memory(struct target_s *target, uint32_t address,
+ uint32_t size, uint32_t count, uint8_t *buffer)
{
- int retval;
- bool mmu;
- retval = target->type->has_mmu(target, &mmu);
- if (retval != ERROR_OK)
- return retval;
- if (mmu)
- {
- LOG_ERROR("Not implemented");
- return ERROR_FAIL;
- }
- return target_read_memory(target, address, size, count, buffer);
+ LOG_ERROR("Not implemented: %s", __func__);
+ return ERROR_FAIL;
}
-static int default_write_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int
+err_write_phys_memory(struct target_s *target, uint32_t address,
+ uint32_t size, uint32_t count, uint8_t *buffer)
{
- int retval;
- bool mmu;
- retval = target->type->has_mmu(target, &mmu);
- if (retval != ERROR_OK)
- return retval;
- if (mmu)
- {
- LOG_ERROR("Not implemented");
- return ERROR_FAIL;
- }
- return target_write_memory(target, address, size, count, buffer);
+ LOG_ERROR("Not implemented: %s", __func__);
+ return ERROR_FAIL;
}
-
int target_init(struct command_context_s *cmd_ctx)
{
- target_t *target = all_targets;
+ struct target_s *target;
int retval;
- while (target)
- {
+ for (target = all_targets; target; target = target->next) {
+ struct target_type_s *type = target->type;
+
target_reset_examined(target);
if (target->type->examine == NULL)
{
return retval;
}
- /* Set up default functions if none are provided by target */
- if (target->type->virt2phys == NULL)
- {
- target->type->virt2phys = default_virt2phys;
- }
-
- if (target->type->read_phys_memory == NULL)
- {
- target->type->read_phys_memory = default_read_phys_memory;
- }
-
- if (target->type->write_phys_memory == NULL)
- {
- target->type->write_phys_memory = default_write_phys_memory;
- }
-
+ /**
+ * @todo MCR/MRC are ARM-specific; don't require them in
+ * all targets, or for ARMs without coprocessors.
+ */
if (target->type->mcr == NULL)
{
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>");
}
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>");
}
+ /**
+ * @todo get rid of those *memory_imp() methods, now that all
+ * callers are using target_*_memory() accessors ... and make
+ * sure the "physical" paths handle the same issues.
+ */
+
/* a non-invasive way(in terms of patches) to add some code that
* runs before the type->write/read_memory implementation
*/
target->type->run_algorithm_imp = target->type->run_algorithm;
target->type->run_algorithm = target_run_algorithm_imp;
- if (target->type->mmu == NULL)
- {
- target->type->mmu = default_mmu;
- }
- if (target->type->has_mmu == NULL)
- {
- target->type->has_mmu = default_has_mmu;
+ /* Sanity-check MMU support ... stub in what we must, to help
+ * implement it in stages, but warn if we need to do so.
+ */
+ if (type->mmu) {
+ if (type->write_phys_memory == NULL) {
+ LOG_ERROR("type '%s' is missing %s",
+ type->name,
+ "write_phys_memory");
+ type->write_phys_memory = err_write_phys_memory;
+ }
+ if (type->read_phys_memory == NULL) {
+ LOG_ERROR("type '%s' is missing %s",
+ type->name,
+ "read_phys_memory");
+ type->read_phys_memory = err_read_phys_memory;
+ }
+ if (type->virt2phys == NULL) {
+ LOG_ERROR("type '%s' is missing %s",
+ type->name,
+ "virt2phys");
+ type->virt2phys = identity_virt2phys;
+ }
+
+ /* Make sure no-MMU targets all behave the same: make no
+ * distinction between physical and virtual addresses, and
+ * ensure that virt2phys() is always an identity mapping.
+ */
+ } else {
+ if (type->write_phys_memory
+ || type->read_phys_memory
+ || type->virt2phys)
+ LOG_WARNING("type '%s' has broken MMU hooks",
+ type->name);
+
+ type->mmu = no_mmu;
+ type->write_phys_memory = type->write_memory;
+ type->read_phys_memory = type->read_memory;
+ type->virt2phys = identity_virt2phys;
}
- target = target->next;
}
if (all_targets)
{
int retval;
int enabled;
+
retval = target->type->mmu(target, &enabled);
if (retval != ERROR_OK)
{
return retval;
}
- if (enabled)
- {
- if (target->working_area_phys_spec)
- {
- LOG_DEBUG("MMU disabled, using physical address for working memory 0x%08x", (unsigned)target->working_area_phys);
+ if (!enabled) {
+ if (target->working_area_phys_spec) {
+ LOG_DEBUG("MMU disabled, using physical "
+ "address for working memory 0x%08x",
+ (unsigned)target->working_area_phys);
target->working_area = target->working_area_phys;
- } else
- {
- LOG_ERROR("No working memory available. Specify -work-area-phys to target.");
+ } else {
+ LOG_ERROR("No working memory available. "
+ "Specify -work-area-phys to target.");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
- } else
- {
- if (target->working_area_virt_spec)
- {
- LOG_DEBUG("MMU enabled, using virtual address for working memory 0x%08x", (unsigned)target->working_area_virt);
+ } else {
+ if (target->working_area_virt_spec) {
+ LOG_DEBUG("MMU enabled, using virtual "
+ "address for working memory 0x%08x",
+ (unsigned)target->working_area_virt);
target->working_area = target->working_area_virt;
- } else
- {
- LOG_ERROR("No working memory available. Specify -work-area-virt to target.");
+ } else {
+ LOG_ERROR("No working memory available. "
+ "Specify -work-area-virt to target.");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
}
target_free_all_working_areas_restore(target, 1);
}
-int target_register_commands(struct command_context_s *cmd_ctx)
-{
-
- register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change the current command line target (one parameter) or lists targets (with no parameter)");
-
-
-
-
- register_jim(cmd_ctx, "target", jim_target, "configure target");
-
- return ERROR_OK;
-}
-
int target_arch_state(struct target_s *target)
{
int retval;
return retval;
}
-int target_register_user_commands(struct command_context_s *cmd_ctx)
-{
- int retval = ERROR_OK;
-
-
- /* script procedures */
- register_command(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>");
-
- register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
- register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
-
- register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
- "same args as load_image, image stored in memory - mainly for profiling purposes");
-
- register_command(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY,
- "loads active fast load image to current target - mainly for profiling purposes");
-
-
- register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
- register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
- register_command(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state");
- register_command(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]");
- register_command(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target");
- register_command(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]");
- register_command(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]");
- register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run | halt | init] - default is run");
- register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
-
- register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words [phys] <addr> [count]");
- register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [phys] <addr> [count]");
- register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [phys] <addr> [count]");
-
- register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [phys] <addr> <value> [count]");
- register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [phys] <addr> <value> [count]");
- register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [phys] <addr> <value> [count]");
-
- register_command(cmd_ctx, NULL, "bp",
- handle_bp_command, COMMAND_EXEC,
- "list or set breakpoint [<address> <length> [hw]]");
- register_command(cmd_ctx, NULL, "rbp",
- handle_rbp_command, COMMAND_EXEC,
- "remove breakpoint <address>");
- register_command(cmd_ctx, NULL, "wp",
- handle_wp_command, COMMAND_EXEC,
- "list or set watchpoint "
- "[<address> <length> <r/w/a> [value] [mask]]");
- register_command(cmd_ctx, NULL, "rwp",
- handle_rwp_command, COMMAND_EXEC,
- "remove watchpoint <address>");
-
- register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
- register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
- register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
- register_command(cmd_ctx, NULL, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image <file> [offset] [type]");
-
- if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
- return retval;
- if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
- return retval;
-
- return retval;
-}
-
static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = all_targets;
if ((args[0][0] >= '0') && (args[0][0] <= '9'))
{
unsigned num;
- int retval = parse_uint(args[0], &num);
- if (ERROR_OK != retval)
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(uint, args[0], num);
reg_cache_t *cache = target->reg_cache;
count = 0;
uint32_t addr = 0;
if (argc == 1)
{
- int retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
current = 0;
}
int current_pc = 1;
if (argc == 1)
{
- int retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
current_pc = 0;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
+
uint32_t address;
- int retval = parse_u32(args[0], &address);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], address);
unsigned count = 1;
if (argc == 2)
- {
- retval = parse_uint(args[1], &count);
- if (ERROR_OK != retval)
- return retval;
- }
+ COMMAND_PARSE_NUMBER(uint, args[1], count);
uint8_t *buffer = calloc(count, size);
target_t *target = get_current_target(cmd_ctx);
- retval = fn(target, address, size, count, buffer);
+ int retval = fn(target, address, size, count, buffer);
if (ERROR_OK == retval)
handle_md_output(cmd_ctx, target, address, size, count, buffer);
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t address;
- int retval = parse_u32(args[0], &address);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], address);
uint32_t value;
- retval = parse_u32(args[1], &value);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[1], value);
unsigned count = 1;
if (argc == 3)
- {
- retval = parse_uint(args[2], &count);
- if (ERROR_OK != retval)
- return retval;
- }
+ COMMAND_PARSE_NUMBER(uint, args[2], count);
target_t *target = get_current_target(cmd_ctx);
unsigned wordsize;
}
for (unsigned i = 0; i < count; i++)
{
- retval = fn(target,
+ int retval = fn(target,
address + i * wordsize, wordsize, 1, value_buf);
if (ERROR_OK != retval)
return retval;
}
-static int parse_load_image_command_args(char **args, int argc,
- image_t *image, uint32_t *min_address, uint32_t *max_address)
+static int parse_load_image_command_args(struct command_context_s *cmd_ctx,
+ char **args, int argc, image_t *image,
+ uint32_t *min_address, uint32_t *max_address)
{
if (argc < 1 || argc > 5)
return ERROR_COMMAND_SYNTAX_ERROR;
if (argc >= 2)
{
uint32_t addr;
- int retval = parse_u32(args[1], &addr);
- if (ERROR_OK != retval)
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(u32, args[1], addr);
image->base_address = addr;
image->base_address_set = 1;
}
if (argc >= 4)
{
- int retval = parse_u32(args[3], min_address);
- if (ERROR_OK != retval)
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
}
if (argc == 5)
{
- int retval = parse_u32(args[4], max_address);
- if (ERROR_OK != retval)
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
// use size (given) to find max (required)
*max_address += *min_address;
}
uint32_t min_address = 0;
uint32_t max_address = 0xffffffff;
int i;
- int retvaltemp;
-
image_t image;
- duration_t duration;
- char *duration_text;
-
- int retval = parse_load_image_command_args(args, argc,
+ int retval = parse_load_image_command_args(cmd_ctx, args, argc,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;
target_t *target = get_current_target(cmd_ctx);
- duration_start_measure(&duration);
+
+ struct duration bench;
+ duration_start(&bench);
if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
free(buffer);
}
- if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
- {
- image_close(&image);
- return retvaltemp;
- }
-
- if (retval == ERROR_OK)
+ if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
- command_print(cmd_ctx, "downloaded %u byte in %s",
- (unsigned int)image_size,
- duration_text);
+ command_print(cmd_ctx, "downloaded %" PRIu32 " bytes "
+ "in %fs (%0.3f kb/s)", image_size,
+ duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
- free(duration_text);
image_close(&image);
uint8_t buffer[560];
int retvaltemp;
- duration_t duration;
- char *duration_text;
target_t *target = get_current_target(cmd_ctx);
}
uint32_t address;
- int retval = parse_u32(args[1], &address);
- if (ERROR_OK != retval)
- return retval;
-
+ COMMAND_PARSE_NUMBER(u32, args[1], address);
uint32_t size;
- retval = parse_u32(args[2], &size);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[2], size);
if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
return ERROR_OK;
}
- duration_start_measure(&duration);
+ struct duration bench;
+ duration_start(&bench);
+ int retval = ERROR_OK;
while (size > 0)
{
uint32_t size_written;
uint32_t this_run_size = (size > 560) ? 560 : size;
-
retval = target_read_buffer(target, address, this_run_size, buffer);
if (retval != ERROR_OK)
{
if ((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
return retvaltemp;
- if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
- return retvaltemp;
-
- if (retval == ERROR_OK)
+ if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
- command_print(cmd_ctx, "dumped %lld byte in %s",
- fileio.size, duration_text);
- free(duration_text);
+ command_print(cmd_ctx,
+ "dumped %lld bytes in %fs (%0.3f kb/s)", fileio.size,
+ duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
}
return retval;
uint32_t buf_cnt;
uint32_t image_size;
int i;
- int retval, retvaltemp;
+ int retval;
uint32_t checksum = 0;
uint32_t mem_checksum = 0;
image_t image;
- duration_t duration;
- char *duration_text;
-
target_t *target = get_current_target(cmd_ctx);
if (argc < 1)
return ERROR_FAIL;
}
- duration_start_measure(&duration);
+ struct duration bench;
+ duration_start(&bench);
if (argc >= 2)
{
uint32_t addr;
- retval = parse_u32(args[1], &addr);
- if (ERROR_OK != retval)
- return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(u32, args[1], addr);
image.base_address = addr;
image.base_address_set = 1;
}
image_size += buf_cnt;
}
done:
-
- if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
- {
- image_close(&image);
- return retvaltemp;
- }
-
- if (retval == ERROR_OK)
+ if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
- command_print(cmd_ctx, "verified %u bytes in %s",
- (unsigned int)image_size,
- duration_text);
+ command_print(cmd_ctx, "verified %" PRIu32 " bytes "
+ "in %fs (%0.3f kb/s)", image_size,
+ duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
- free(duration_text);
image_close(&image);
}
uint32_t addr;
- int retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
-
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
uint32_t length;
- retval = parse_u32(args[1], &length);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[1], length);
int hw = BKPT_SOFT;
if (argc == 3)
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
- int retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
target_t *target = get_current_target(cmd_ctx);
breakpoint_remove(target, addr);
uint32_t length = 0;
uint32_t data_value = 0x0;
uint32_t data_mask = 0xffffffff;
- int retval;
switch (argc)
{
case 5:
- retval = parse_u32(args[4], &data_mask);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
// fall through
case 4:
- retval = parse_u32(args[3], &data_value);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[3], data_value);
// fall through
case 3:
switch (args[2][0])
}
// fall through
case 2:
- retval = parse_u32(args[1], &length);
- if (ERROR_OK != retval)
- return retval;
- retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[1], length);
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
break;
default:
return ERROR_COMMAND_SYNTAX_ERROR;
}
- retval = watchpoint_add(target, addr, length, type,
+ int retval = watchpoint_add(target, addr, length, type,
data_value, data_mask);
if (ERROR_OK != retval)
LOG_ERROR("Failure setting watchpoints");
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
- int retval = parse_u32(args[0], &addr);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], addr);
target_t *target = get_current_target(cmd_ctx);
watchpoint_remove(target, addr);
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t va;
- int retval = parse_u32(args[0], &va);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(u32, args[0], va);
uint32_t pa;
target_t *target = get_current_target(cmd_ctx);
- retval = target->type->virt2phys(target, va, &pa);
+ int retval = target->type->virt2phys(target, va, &pa);
if (retval == ERROR_OK)
command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
}
/* Dump a gmon.out histogram file. */
-static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
+static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
{
uint32_t i;
FILE *f = fopen(filename, "w");
return ERROR_COMMAND_SYNTAX_ERROR;
}
unsigned offset;
- int retval = parse_uint(args[0], &offset);
- if (ERROR_OK != retval)
- return retval;
+ COMMAND_PARSE_NUMBER(uint, args[0], offset);
timeval_add_time(&timeout, offset, 0);
for (;;)
{
+ int retval;
target_poll(target);
if (target->state == TARGET_HALTED)
{
image_t image;
- duration_t duration;
- char *duration_text;
-
- int retval = parse_load_image_command_args(args, argc,
+ int retval = parse_load_image_command_args(cmd_ctx, args, argc,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;
- duration_start_measure(&duration);
+ struct duration bench;
+ duration_start(&bench);
if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
free(buffer);
}
- duration_stop_measure(&duration, &duration_text);
- if (retval == ERROR_OK)
+ if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
- command_print(cmd_ctx, "Loaded %u bytes in %s", (unsigned int)image_size, duration_text);
- command_print(cmd_ctx, "NB!!! image has not been loaded to target, issue a subsequent 'fast_load' to do so.");
+ command_print(cmd_ctx, "Loaded %" PRIu32 " bytes "
+ "in %fs (%0.3f kb/s)", image_size,
+ duration_elapsed(&bench), duration_kbps(&bench, image_size));
+
+ command_print(cmd_ctx,
+ "WARNING: image has not been loaded to target!"
+ "You can issue a 'fast_load' to finish loading.");
}
- free(duration_text);
image_close(&image);
if (e != JIM_OK) {
return e;
}
- op2 = l;
+ CRn = l;
e = Jim_GetLong(interp, argv[4], &l);
if (e != JIM_OK) {
return e;
}
- CRn = l;
+ CRm = l;
e = Jim_GetLong(interp, argv[5], &l);
if (e != JIM_OK) {
return e;
}
- CRm = l;
+ op2 = l;
value = 0;
return JIM_OK;
}
+
+int target_register_commands(struct command_context_s *cmd_ctx)
+{
+
+ register_command(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;
+}
+
+int target_register_user_commands(struct command_context_s *cmd_ctx)
+{
+ int retval = ERROR_OK;
+ if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
+ return retval;
+
+ if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
+ return retval;
+
+ register_command(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>");
+
+ register_command(cmd_ctx, NULL, "fast_load_image",
+ handle_fast_load_image_command, COMMAND_ANY,
+ "same args as load_image, image stored in memory "
+ "- mainly for profiling purposes");
+
+ register_command(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 */
+ register_command(cmd_ctx, NULL, "virt2phys",
+ handle_virt2phys_command, COMMAND_ANY,
+ "translate a virtual address into a physical address");
+
+ register_command(cmd_ctx, NULL, "reg",
+ handle_reg_command, COMMAND_EXEC,
+ "display or set a register");
+
+ register_command(cmd_ctx, NULL, "poll",
+ handle_poll_command, COMMAND_EXEC,
+ "poll target state");
+ register_command(cmd_ctx, NULL, "wait_halt",
+ handle_wait_halt_command, COMMAND_EXEC,
+ "wait for target halt [time (s)]");
+ register_command(cmd_ctx, NULL, "halt",
+ handle_halt_command, COMMAND_EXEC,
+ "halt target");
+ register_command(cmd_ctx, NULL, "resume",
+ handle_resume_command, COMMAND_EXEC,
+ "resume target [addr]");
+ register_command(cmd_ctx, NULL, "reset",
+ handle_reset_command, COMMAND_EXEC,
+ "reset target [run | halt | init] - default is run");
+ register_command(cmd_ctx, NULL, "soft_reset_halt",
+ handle_soft_reset_halt_command, COMMAND_EXEC,
+ "halt the target and do a soft reset");
+
+ register_command(cmd_ctx, NULL, "step",
+ handle_step_command, COMMAND_EXEC,
+ "step one instruction from current PC or [addr]");
+
+ register_command(cmd_ctx, NULL, "mdw",
+ handle_md_command, COMMAND_EXEC,
+ "display memory words [phys] <addr> [count]");
+ register_command(cmd_ctx, NULL, "mdh",
+ handle_md_command, COMMAND_EXEC,
+ "display memory half-words [phys] <addr> [count]");
+ register_command(cmd_ctx, NULL, "mdb",
+ handle_md_command, COMMAND_EXEC,
+ "display memory bytes [phys] <addr> [count]");
+
+ register_command(cmd_ctx, NULL, "mww",
+ handle_mw_command, COMMAND_EXEC,
+ "write memory word [phys] <addr> <value> [count]");
+ register_command(cmd_ctx, NULL, "mwh",
+ handle_mw_command, COMMAND_EXEC,
+ "write memory half-word [phys] <addr> <value> [count]");
+ register_command(cmd_ctx, NULL, "mwb",
+ handle_mw_command, COMMAND_EXEC,
+ "write memory byte [phys] <addr> <value> [count]");
+
+ register_command(cmd_ctx, NULL, "bp",
+ handle_bp_command, COMMAND_EXEC,
+ "list or set breakpoint [<address> <length> [hw]]");
+ register_command(cmd_ctx, NULL, "rbp",
+ handle_rbp_command, COMMAND_EXEC,
+ "remove breakpoint <address>");
+
+ register_command(cmd_ctx, NULL, "wp",
+ handle_wp_command, COMMAND_EXEC,
+ "list or set watchpoint "
+ "[<address> <length> <r/w/a> [value] [mask]]");
+ register_command(cmd_ctx, NULL, "rwp",
+ handle_rwp_command, COMMAND_EXEC,
+ "remove watchpoint <address>");
+
+ register_command(cmd_ctx, NULL, "load_image",
+ handle_load_image_command, COMMAND_EXEC,
+ "load_image <file> <address> "
+ "['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
+ register_command(cmd_ctx, NULL, "dump_image",
+ handle_dump_image_command, COMMAND_EXEC,
+ "dump_image <file> <address> <size>");
+ register_command(cmd_ctx, NULL, "verify_image",
+ handle_verify_image_command, COMMAND_EXEC,
+ "verify_image <file> [offset] [type]");
+ register_command(cmd_ctx, NULL, "test_image",
+ handle_test_image_command, COMMAND_EXEC,
+ "test_image <file> [offset] [type]");
+
+ return ERROR_OK;
+}
Code Review / openocd.git / blobdiff