int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
+
int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc);
/* targets
*/
extern target_type_t arm920t_target;
extern target_type_t arm966e_target;
extern target_type_t arm926ejs_target;
+extern target_type_t feroceon_target;
extern target_type_t xscale_target;
extern target_type_t cortexm3_target;
+extern target_type_t arm11_target;
target_type_t *target_types[] =
{
&arm720t_target,
&arm966e_target,
&arm926ejs_target,
+ &feroceon_target,
&xscale_target,
&cortexm3_target,
+ &arm11_target,
NULL,
};
{
target_unregister_event_callback(target_init_handler, priv);
- script = fopen(target->reset_script, "r");
+ script = open_file_from_path(target->reset_script, "r");
if (!script)
{
ERROR("couldn't open script file %s", target->reset_script);
switch (target->reset_mode)
{
case RESET_HALT:
- command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_HALT");
+ command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_halt\"");
target->reset_mode = RESET_RUN_AND_HALT;
break;
case RESET_INIT:
- command_print(cmd_ctx, "nSRST pulls nTRST, falling back to RESET_RUN_AND_INIT");
+ command_print(cmd_ctx, "nSRST pulls nTRST, falling back to \"reset run_and_init\"");
target->reset_mode = RESET_RUN_AND_INIT;
break;
default:
return retval;
}
+static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
+{
+ *physical = virtual;
+ return ERROR_OK;
+}
+
+static int default_mmu(struct target_s *target, int *enabled)
+{
+ *enabled = 0;
+ return ERROR_OK;
+}
+
int target_init(struct command_context_s *cmd_ctx)
{
target_t *target = targets;
ERROR("target '%s' init failed", target->type->name);
exit(-1);
}
+
+ /* Set up default functions if none are provided by target */
+ if (target->type->virt2phys == NULL)
+ {
+ target->type->virt2phys = default_virt2phys;
+ }
+ if (target->type->mmu == NULL)
+ {
+ target->type->mmu = default_mmu;
+ }
target = target->next;
}
working_area_t *c = target->working_areas;
working_area_t *new_wa = NULL;
+ /* Reevaluate working area address based on MMU state*/
+ if (target->working_areas == NULL)
+ {
+ int retval;
+ int enabled;
+ retval = target->type->mmu(target, &enabled);
+ if (retval != ERROR_OK)
+ {
+ return retval;
+ }
+ if (enabled)
+ {
+ target->working_area = target->working_area_virt;
+ }
+ else
+ {
+ target->working_area = target->working_area_phys;
+ }
+ }
+
/* only allocate multiples of 4 byte */
if (size % 4)
{
if (free_size < size)
{
- WARNING("not enough working area available");
+ WARNING("not enough working area available(requested %d, free %d)", size, free_size);
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
register_command(cmd_ctx, NULL, "daemon_startup", handle_daemon_startup_command, COMMAND_CONFIG, NULL);
register_command(cmd_ctx, NULL, "target_script", handle_target_script_command, COMMAND_CONFIG, NULL);
register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, NULL);
- register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_CONFIG, NULL);
+ register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
+ register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
return ERROR_OK;
}
+int target_arch_state(struct target_s *target)
+{
+ int retval;
+ if (target==NULL)
+ {
+ USER("No target has been configured");
+ return ERROR_OK;
+ }
+
+ USER("target state: %s", target_state_strings[target->state]);
+
+ if (target->state!=TARGET_HALTED)
+ return ERROR_OK;
+
+ retval=target->type->arch_state(target);
+ return retval;
+}
+
+/* Single aligned words are guaranteed to use 16 or 32 bit access
+ * mode respectively, otherwise data is handled as quickly as
+ * possible
+ */
int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
{
int retval;
DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
- /* handle writes of less than 4 byte */
- if (size < 4)
+ if (((address % 2) == 0) && (size == 2))
{
- if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
- return retval;
- return ERROR_OK;
+ return target->type->write_memory(target, address, 2, 1, buffer);
}
/* handle unaligned head bytes */
{
int unaligned = 4 - (address % 4);
+ if (unaligned > size)
+ unaligned = size;
+
if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
return retval;
return ERROR_OK;
}
+
+/* Single aligned words are guaranteed to use 16 or 32 bit access
+ * mode respectively, otherwise data is handled as quickly as
+ * possible
+ */
int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffer)
{
int retval;
DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
- /* handle reads of less than 4 byte */
- if (size < 4)
+ if (((address % 2) == 0) && (size == 2))
{
- if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
- return retval;
- return ERROR_OK;
+ return target->type->read_memory(target, address, 2, 1, buffer);
}
/* handle unaligned head bytes */
{
int unaligned = 4 - (address % 4);
+ if (unaligned > size)
+ unaligned = size;
+
if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
return retval;
if (buffer == NULL)
{
ERROR("error allocating buffer for section (%d bytes)", size);
- return ERROR_OK;
+ return ERROR_INVALID_ARGUMENTS;
+ }
+ retval = target_read_buffer(target, address, size, buffer);
+ if (retval != ERROR_OK)
+ {
+ free(buffer);
+ return retval;
}
- target_read_buffer(target, address, size, buffer);
/* convert to target endianess */
for (i = 0; i < (size/sizeof(u32)); i++)
{
target_t *target = NULL;
- if (argc < 4)
+ if ((argc < 4) || (argc > 5))
{
- ERROR("incomplete working_area command. usage: working_area <target#> <address> <size> <'backup'|'nobackup'>");
- exit(-1);
+ return ERROR_COMMAND_SYNTAX_ERROR;
}
target = get_target_by_num(strtoul(args[0], NULL, 0));
ERROR("target number '%s' not defined", args[0]);
exit(-1);
}
+ target_free_all_working_areas(target);
- target->working_area = strtoul(args[1], NULL, 0);
+ target->working_area_phys = target->working_area_virt = strtoul(args[1], NULL, 0);
+ if (argc == 5)
+ {
+ target->working_area_virt = strtoul(args[4], NULL, 0);
+ }
target->working_area_size = strtoul(args[2], NULL, 0);
if (strcmp(args[3], "backup") == 0)
else
{
ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
- exit(-1);
+ return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
if (target->state != TARGET_HALTED)
{
if (target_continous_poll)
- if ((retval = target->type->poll(target)) < 0)
+ if ((retval = target->type->poll(target)) != ERROR_OK)
{
- ERROR("couldn't poll target. It's due for a reset.");
+ ERROR("couldn't poll target(%d). It's due for a reset.", retval);
}
}
int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target = get_current_target(cmd_ctx);
- char buffer[512];
if (argc == 0)
{
- command_print(cmd_ctx, "target state: %s", target_state_strings[target->type->poll(target)]);
- if (target->state == TARGET_HALTED)
- {
- target->type->arch_state(target, buffer, 512);
- buffer[511] = 0;
- command_print(cmd_ctx, "%s", buffer);
- }
+ target->type->poll(target);
+ target_arch_state(target);
}
else
{
return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms);
}
+static void target_process_events(struct command_context_s *cmd_ctx)
+{
+ target_t *target = get_current_target(cmd_ctx);
+ target->type->poll(target);
+ target_call_timer_callbacks();
+}
+
static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
{
+ int retval;
struct timeval timeout, now;
-
+ int once=1;
gettimeofday(&timeout, NULL);
timeval_add_time(&timeout, 0, ms * 1000);
- command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
target_t *target = get_current_target(cmd_ctx);
- while (target->type->poll(target))
+ for (;;)
{
+ if ((retval=target->type->poll(target))!=ERROR_OK)
+ return retval;
target_call_timer_callbacks();
if (target->state == state)
{
- command_print(cmd_ctx, "target %s", target_state_strings[state]);
break;
}
+ if (once)
+ {
+ once=0;
+ command_print(cmd_ctx, "waiting for target %s...", target_state_strings[state]);
+ }
gettimeofday(&now, NULL);
if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
{
- command_print(cmd_ctx, "timed out while waiting for target %s", target_state_strings[state]);
ERROR("timed out while waiting for target %s", target_state_strings[state]);
break;
}
target_t *target = get_current_target(cmd_ctx);
DEBUG("-");
-
- command_print(cmd_ctx, "requesting target halt...");
if ((retval = target->type->halt(target)) != ERROR_OK)
- {
- switch (retval)
{
- case ERROR_TARGET_ALREADY_HALTED:
- command_print(cmd_ctx, "target already halted");
- break;
- case ERROR_TARGET_TIMEOUT:
- command_print(cmd_ctx, "target timed out... shutting down");
- return retval;
- default:
- command_print(cmd_ctx, "unknown error... shutting down");
return retval;
}
- }
return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
}
int retval;
target_t *target = get_current_target(cmd_ctx);
- DEBUG("-");
-
if (argc == 0)
retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
else if (argc == 1)
retval = target->type->resume(target, 0, strtoul(args[0], NULL, 0), 1, 0); /* addr = args[0], handle breakpoints, not debugging */
else
{
- command_print(cmd_ctx, "usage: resume [address]");
- return ERROR_OK;
- }
-
- if (retval != ERROR_OK)
- {
- switch (retval)
- {
- case ERROR_TARGET_NOT_HALTED:
- command_print(cmd_ctx, "target not halted");
- break;
- default:
- command_print(cmd_ctx, "unknown error... shutting down");
- exit(-1);
- }
+ return ERROR_COMMAND_SYNTAX_ERROR;
}
- return wait_state(cmd_ctx, cmd, TARGET_RUNNING, 5000);
+ target_process_events(cmd_ctx);
+
+ return retval;
}
int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
{
- command_print(cmd_ctx, "load_image error: %s", image.error_str);
return ERROR_OK;
}
if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
{
- command_print(cmd_ctx, "dump_image error: %s", fileio.error_str);
return ERROR_OK;
}
if (image_open(&image, args[0], (argc == 3) ? args[2] : NULL) != ERROR_OK)
{
- command_print(cmd_ctx, "verify_image error: %s", image.error_str);
return ERROR_OK;
}
if( retval != ERROR_OK )
{
- command_print(cmd_ctx, "image verify failed, verify aborted");
+ command_print(cmd_ctx, "could not calculate checksum, verify aborted");
free(buffer);
image_close(&image);
return ERROR_OK;
/* failed crc checksum, fall back to a binary compare */
u8 *data;
- command_print(cmd_ctx, "image verify checksum failed - attempting binary compare");
+ command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
data = (u8*)malloc(buf_cnt);
return ERROR_OK;
}
+
+int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args, int argc)
+{
+ int retval;
+ target_t *target = get_current_target(cmd_ctx);
+ u32 va;
+ u32 pa;
+
+ if (argc != 1)
+ {
+ return ERROR_COMMAND_SYNTAX_ERROR;
+ }
+ va = strtoul(args[0], NULL, 0);
+
+ retval = target->type->virt2phys(target, va, &pa);
+ if (retval == ERROR_OK)
+ {
+ command_print(cmd_ctx, "Physical address 0x%08x", pa);
+ }
+ else
+ {
+ /* lower levels will have logged a detailed error which is
+ * forwarded to telnet/GDB session.
+ */
+ }
+ return retval;
+}
projects / fw / openocd / blobdiff