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)
{
*enabled = 0;
return ERROR_OK;
}
static int
-default_read_phys_memory(struct target_s *target, uint32_t address,
+err_read_phys_memory(struct target_s *target, uint32_t address,
uint32_t size, uint32_t count, uint8_t *buffer)
{
LOG_ERROR("Not implemented: %s", __func__);
}
static int
-default_write_phys_memory(struct target_s *target, uint32_t address,
+err_write_phys_memory(struct target_s *target, uint32_t address,
uint32_t size, uint32_t count, uint8_t *buffer)
{
LOG_ERROR("Not implemented: %s", __func__);
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;
}
+ /**
+ * @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;
+ /* 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)
return retval;
}
-static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_targets_command)
{
target_t *target = all_targets;
return retval;
}
-static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_reg_command)
{
target_t *target;
reg_t *reg = NULL;
return ERROR_OK;
}
-static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_poll_command)
{
int retval = ERROR_OK;
target_t *target = get_current_target(cmd_ctx);
return retval;
}
-static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_wait_halt_command)
{
if (argc > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = parse_uint(args[0], &ms);
if (ERROR_OK != retval)
{
- command_print(cmd_ctx, "usage: %s [seconds]", cmd);
+ command_print(cmd_ctx, "usage: %s [seconds]", CMD_NAME);
return ERROR_COMMAND_SYNTAX_ERROR;
}
// convert seconds (given) to milliseconds (needed)
return ERROR_OK;
}
-static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_halt_command)
{
LOG_DEBUG("-");
return ERROR_OK;
}
- return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
+ return CALL_COMMAND_HANDLER(handle_wait_halt_command);
}
-static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_soft_reset_halt_command)
{
target_t *target = get_current_target(cmd_ctx);
return ERROR_OK;
}
-static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_reset_command)
{
if (argc > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
}
-static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_resume_command)
{
int current = 1;
if (argc > 1)
return target_resume(target, current, addr, 1, 0);
}
-static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_step_command)
{
if (argc > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
-static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_md_command)
{
if (argc < 1)
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned size = 0;
- switch (cmd[2]) {
+ switch (CMD_NAME[2]) {
case 'w': size = 4; break;
case 'h': size = 2; break;
case 'b': size = 1; break;
return retval;
}
-static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_mw_command)
{
if (argc < 2)
{
target_t *target = get_current_target(cmd_ctx);
unsigned wordsize;
uint8_t value_buf[4];
- switch (cmd[2])
+ switch (CMD_NAME[2])
{
case 'w':
wordsize = 4;
}
-static int parse_load_image_command_args(struct command_context_s *cmd_ctx,
- char **args, int argc, image_t *image,
+static COMMAND_HELPER(parse_load_image_command_args, image_t *image,
uint32_t *min_address, uint32_t *max_address)
{
if (argc < 1 || argc > 5)
return ERROR_OK;
}
-static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_load_image_command)
{
uint8_t *buffer;
uint32_t buf_cnt;
int i;
image_t image;
- int retval = parse_load_image_command_args(cmd_ctx, args, argc,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;
}
-static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_dump_image_command)
{
fileio_t fileio;
return retval;
}
-static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
+static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
{
uint8_t *buffer;
uint32_t buf_cnt;
return retval;
}
-static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_verify_image_command)
{
- return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1);
+ return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1);
}
-static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_test_image_command)
{
- return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0);
+ return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0);
}
static int handle_bp_command_list(struct command_context_s *cmd_ctx)
return retval;
}
-static int handle_bp_command(struct command_context_s *cmd_ctx,
- char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_bp_command)
{
if (argc == 0)
return handle_bp_command_list(cmd_ctx);
return handle_bp_command_set(cmd_ctx, addr, length, hw);
}
-static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_rbp_command)
{
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_OK;
}
-static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_wp_command)
{
target_t *target = get_current_target(cmd_ctx);
return retval;
}
-static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_rwp_command)
{
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
* The low-level target implementation must have logged a detailed error
* which is forwarded to telnet/GDB session.
*/
-static int handle_virt2phys_command(command_context_t *cmd_ctx,
- char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_virt2phys_command)
{
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
}
/* 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");
}
/* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
-static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_profile_command)
{
target_t *target = get_current_target(cmd_ctx);
struct timeval timeout, now;
-static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_fast_load_image_command)
{
uint8_t *buffer;
uint32_t buf_cnt;
image_t image;
- int retval = parse_load_image_command_args(cmd_ctx, args, argc,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;
return retval;
}
-static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(handle_fast_load_command)
{
if (argc > 0)
return ERROR_COMMAND_SYNTAX_ERROR;
"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");