X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=3e9cce5b06e104f2d34dad5b7204ca32c651902a;hp=050a523e712d964024ccdf57e2652ee1547f3643;hb=e18e23e1b6c7cdfd4294e1f05aeee2b841d3cca2;hpb=04dc98916d9acb57e0f5595534151a24ba4dc684 diff --git a/src/target/target.c b/src/target/target.c index 050a523e71..3e9cce5b06 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -23,6 +23,7 @@ #include "replacements.h" #include "target.h" +#include "target_request.h" #include "log.h" #include "configuration.h" @@ -31,6 +32,7 @@ #include #include +#include #include #include @@ -43,11 +45,12 @@ #include #include +#include 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_target_script_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -66,10 +69,13 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_bp_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); +int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); /* targets */ @@ -79,7 +85,10 @@ extern target_type_t arm9tdmi_target; 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[] = { @@ -89,7 +98,10 @@ target_type_t *target_types[] = &arm720t_target, &arm966e_target, &arm926ejs_target, + &feroceon_target, &xscale_target, + &cortexm3_target, + &arm11_target, NULL, }; @@ -110,7 +122,7 @@ char *target_debug_reason_strings[] = { "debug request", "breakpoint", "watchpoint", "watchpoint and breakpoint", "single step", - "target not halted" + "target not halted", "undefined" }; char *target_endianess_strings[] = @@ -119,8 +131,6 @@ char *target_endianess_strings[] = "little endian", }; -enum daemon_startup_mode startup_mode = DAEMON_ATTACH; - static int target_continous_poll = 1; /* read a u32 from a buffer in target memory endianness */ @@ -198,7 +208,7 @@ target_t* get_current_target(command_context_t *cmd_ctx) if (target == NULL) { - ERROR("BUG: current_target out of bounds"); + LOG_ERROR("BUG: current_target out of bounds"); exit(-1); } @@ -217,14 +227,14 @@ int target_init_handler(struct target_s *target, enum target_event event, void * { 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); + LOG_ERROR("couldn't open script file %s", target->reset_script); return ERROR_OK; } - INFO("executing reset script '%s'", target->reset_script); + LOG_INFO("executing reset script '%s'", target->reset_script); command_run_file(cmd_ctx, script, COMMAND_EXEC); fclose(script); @@ -238,28 +248,78 @@ int target_run_and_halt_handler(void *priv) { target_t *target = priv; - target->type->halt(target); + target_halt(target); return ERROR_OK; } +int target_poll(struct target_s *target) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + /* Fail silently lest we pollute the log */ + return ERROR_FAIL; + } + return target->type->poll(target); +} + +int target_halt(struct target_s *target) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->halt(target); +} + +int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution) +{ + /* We can't poll until after examine */ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->resume(target, current, address, handle_breakpoints, debug_execution); +} + + int target_process_reset(struct command_context_s *cmd_ctx) { int retval = ERROR_OK; target_t *target; + struct timeval timeout, now; + + jtag->speed(jtag_speed); + + if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK) + return retval; + + if ((retval = target_examine(cmd_ctx)) != ERROR_OK) + return retval; /* prepare reset_halt where necessary */ target = targets; while (target) { - switch (target->reset_mode) + if (jtag_reset_config & RESET_SRST_PULLS_TRST) { - case RESET_HALT: - case RESET_INIT: - target->type->prepare_reset_halt(target); - break; - default: - break; + switch (target->reset_mode) + { + case RESET_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\""); + target->reset_mode = RESET_RUN_AND_INIT; + break; + default: + break; + } } target = target->next; } @@ -267,10 +327,18 @@ int target_process_reset(struct command_context_s *cmd_ctx) target = targets; while (target) { + /* we have no idea what state the target is in, so we + * have to drop working areas + */ + target_free_all_working_areas_restore(target, 0); target->type->assert_reset(target); target = target->next; } - jtag_execute_queue(); + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed asserting reset."); + retval = ERROR_OK; + } /* request target halt if necessary, and schedule further action */ target = targets; @@ -291,28 +359,175 @@ int target_process_reset(struct command_context_s *cmd_ctx) target_register_event_callback(target_init_handler, cmd_ctx); break; case RESET_HALT: - target->type->halt(target); + target_halt(target); break; case RESET_INIT: - target->type->halt(target); + target_halt(target); target_register_event_callback(target_init_handler, cmd_ctx); break; default: - ERROR("BUG: unknown target->reset_mode"); + LOG_ERROR("BUG: unknown target->reset_mode"); } target = target->next; } + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed while reset was asserted. Consider using srst_only for reset_config."); + retval = ERROR_OK; + } + target = targets; while (target) { target->type->deassert_reset(target); target = target->next; } - jtag_execute_queue(); + if ((retval = jtag_execute_queue()) != ERROR_OK) + { + LOG_WARNING("JTAG communication failed while deasserting reset."); + retval = ERROR_OK; + } + + LOG_DEBUG("Waiting for halted stated as approperiate"); + + /* Wait for reset to complete, maximum 5 seconds. */ + gettimeofday(&timeout, NULL); + timeval_add_time(&timeout, 5, 0); + for(;;) + { + gettimeofday(&now, NULL); + + target_call_timer_callbacks_now(); + + target = targets; + while (target) + { + LOG_DEBUG("Polling target"); + target_poll(target); + if ((target->reset_mode == RESET_RUN_AND_INIT) || + (target->reset_mode == RESET_RUN_AND_HALT) || + (target->reset_mode == RESET_HALT) || + (target->reset_mode == RESET_INIT)) + { + if (target->state != TARGET_HALTED) + { + if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) + { + LOG_USER("Timed out waiting for halt after reset"); + goto done; + } + /* this will send alive messages on e.g. GDB remote protocol. */ + usleep(500*1000); + LOG_USER_N("%s", ""); /* avoid warning about zero length formatting message*/ + goto again; + } + } + target = target->next; + } + /* All targets we're waiting for are halted */ + break; + + again:; + } + done: + + + /* We want any events to be processed before the prompt */ + target_call_timer_callbacks_now(); + + /* if we timed out we need to unregister these handlers */ + target = targets; + while (target) + { + target_unregister_timer_callback(target_run_and_halt_handler, target); + target = target->next; + } + target_unregister_event_callback(target_init_handler, cmd_ctx); + + + jtag->speed(jtag_speed_post_reset); + + 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; +} + +static int default_examine(struct command_context_s *cmd_ctx, struct target_s *target) +{ + target->type->examined = 1; + return ERROR_OK; +} + + +/* Targets that correctly implement init+examine, i.e. + * no communication with target during init: + * + * XScale + */ +int target_examine(struct command_context_s *cmd_ctx) +{ + int retval = ERROR_OK; + target_t *target = targets; + while (target) + { + if ((retval = target->type->examine(cmd_ctx, target))!=ERROR_OK) + return retval; + target = target->next; + } return retval; -} +} + +static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->write_memory_imp(target, address, size, count, buffer); +} + +static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->read_memory_imp(target, address, size, count, buffer); +} + +static int target_soft_reset_halt_imp(struct target_s *target) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->soft_reset_halt_imp(target); +} + +static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info) +{ + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info); +} int target_init(struct command_context_s *cmd_ctx) { @@ -320,11 +535,41 @@ int target_init(struct command_context_s *cmd_ctx) while (target) { + target->type->examined = 0; + if (target->type->examine == NULL) + { + target->type->examine = default_examine; + } + if (target->type->init_target(cmd_ctx, target) != ERROR_OK) { - ERROR("target '%s' init failed", target->type->name); + LOG_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; + } + target->type->virt2phys = default_virt2phys; + /* a non-invasive way(in terms of patches) to add some code that + * runs before the type->write/read_memory implementation + */ + target->type->write_memory_imp = target->type->write_memory; + target->type->write_memory = target_write_memory_imp; + target->type->read_memory_imp = target->type->read_memory; + target->type->read_memory = target_read_memory_imp; + target->type->soft_reset_halt_imp = target->type->soft_reset_halt; + target->type->soft_reset_halt = target_soft_reset_halt_imp; + 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; + } target = target->next; } @@ -334,9 +579,6 @@ int target_init(struct command_context_s *cmd_ctx) target_register_timer_callback(handle_target, 100, 1, NULL); } - if (startup_mode == DAEMON_RESET) - target_process_reset(cmd_ctx); - return ERROR_OK; } @@ -461,7 +703,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event) target_event_callback_t *callback = target_event_callbacks; target_event_callback_t *next_callback; - DEBUG("target event %i", event); + LOG_DEBUG("target event %i", event); while (callback) { @@ -473,7 +715,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event) return ERROR_OK; } -int target_call_timer_callbacks() +static int target_call_timer_callbacks_check_time(int checktime) { target_timer_callback_t *callback = target_timer_callbacks; target_timer_callback_t *next_callback; @@ -485,8 +727,9 @@ int target_call_timer_callbacks() { next_callback = callback->next; - if (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec)) - || (now.tv_sec > callback->when.tv_sec)) + if ((!checktime&&callback->periodic)|| + (((now.tv_sec >= callback->when.tv_sec) && (now.tv_usec >= callback->when.tv_usec)) + || (now.tv_sec > callback->when.tv_sec))) { callback->callback(callback->priv); if (callback->periodic) @@ -511,15 +754,47 @@ int target_call_timer_callbacks() return ERROR_OK; } +int target_call_timer_callbacks() +{ + return target_call_timer_callbacks_check_time(1); +} + +/* invoke periodic callbacks immediately */ +int target_call_timer_callbacks_now() +{ + return target_call_timer_callbacks(0); +} + + int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area) { 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) { - ERROR("BUG: code tried to allocate unaligned number of bytes, padding"); + LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding"); size = CEIL(size, 4); } @@ -541,7 +816,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t u32 first_free = target->working_area; u32 free_size = target->working_area_size; - DEBUG("allocating new working area"); + LOG_DEBUG("allocating new working area"); c = target->working_areas; while (c) @@ -554,7 +829,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t if (free_size < size) { - WARNING("not enough working area available"); + LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size); return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; } @@ -587,12 +862,12 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t return ERROR_OK; } -int target_free_working_area(struct target_s *target, working_area_t *area) +int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore) { if (area->free) return ERROR_OK; - if (target->backup_working_area) + if (restore&&target->backup_working_area) target->type->write_memory(target, area->address, 4, area->size / 4, area->backup); area->free = 1; @@ -604,14 +879,19 @@ int target_free_working_area(struct target_s *target, working_area_t *area) return ERROR_OK; } -int target_free_all_working_areas(struct target_s *target) +int target_free_working_area(struct target_s *target, working_area_t *area) +{ + return target_free_working_area_restore(target, area, 1); +} + +int target_free_all_working_areas_restore(struct target_s *target, int restore) { working_area_t *c = target->working_areas; while (c) { working_area_t *next = c->next; - target_free_working_area(target, c); + target_free_working_area_restore(target, c, restore); if (c->backup) free(c->backup); @@ -626,29 +906,60 @@ int target_free_all_working_areas(struct target_s *target) return ERROR_OK; } +int target_free_all_working_areas(struct target_s *target) +{ + return target_free_all_working_areas_restore(target, 1); +} + int target_register_commands(struct command_context_s *cmd_ctx) { - register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, NULL); + register_command(cmd_ctx, NULL, "target", handle_target_command, COMMAND_CONFIG, "target [reset_init default - DEPRECATED] [cpu type specifc args]"); register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL); - 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, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, " "); + register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area
<'backup'|'nobackup'> [virtual address]"); + register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys "); + register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile "); return ERROR_OK; } +int target_arch_state(struct target_s *target) +{ + int retval; + if (target==NULL) + { + LOG_USER("No target has been configured"); + return ERROR_OK; + } + + LOG_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; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } - DEBUG("writing buffer of %i byte at 0x%8.8x", size, address); + LOG_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 target->type->write_memory(target, address, 2, 1, buffer); } /* handle unaligned head bytes */ @@ -656,6 +967,9 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff { 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; @@ -696,17 +1010,25 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff 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; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + + LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address); - 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 target->type->read_memory(target, address, 2, 1, buffer); } /* handle unaligned head bytes */ @@ -714,6 +1036,9 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe { 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; @@ -745,21 +1070,71 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe return ERROR_OK; } +int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc) +{ + u8 *buffer; + int retval; + int i; + u32 checksum = 0; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + + if ((retval = target->type->checksum_memory(target, address, + size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) + { + buffer = malloc(size); + if (buffer == NULL) + { + LOG_ERROR("error allocating buffer for section (%d bytes)", size); + return ERROR_INVALID_ARGUMENTS; + } + retval = target_read_buffer(target, address, size, buffer); + if (retval != ERROR_OK) + { + free(buffer); + return retval; + } + + /* convert to target endianess */ + for (i = 0; i < (size/sizeof(u32)); i++) + { + u32 target_data; + target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]); + target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data); + } + + retval = image_calculate_checksum( buffer, size, &checksum ); + free(buffer); + } + + *crc = checksum; + + return retval; +} + int target_read_u32(struct target_s *target, u32 address, u32 *value) { u8 value_buf[4]; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } int retval = target->type->read_memory(target, address, 4, 1, value_buf); if (retval == ERROR_OK) { *value = target_buffer_get_u32(target, value_buf); - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -768,18 +1143,23 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value) int target_read_u16(struct target_s *target, u32 address, u16 *value) { u8 value_buf[2]; - + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + int retval = target->type->read_memory(target, address, 2, 1, value_buf); if (retval == ERROR_OK) { *value = target_buffer_get_u16(target, value_buf); - DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%4.4x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -788,15 +1168,20 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value) int target_read_u8(struct target_s *target, u32 address, u8 *value) { int retval = target->type->read_memory(target, address, 1, 1, value); + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } if (retval == ERROR_OK) { - DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value); } else { *value = 0x0; - DEBUG("address: 0x%8.8x failed", address); + LOG_DEBUG("address: 0x%8.8x failed", address); } return retval; @@ -806,13 +1191,18 @@ int target_write_u32(struct target_s *target, u32 address, u32 value) { int retval; u8 value_buf[4]; + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); target_buffer_set_u32(target, value_buf, value); if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -822,13 +1212,18 @@ int target_write_u16(struct target_s *target, u32 address, u16 value) { int retval; u8 value_buf[2]; - - DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + + LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value); target_buffer_set_u16(target, value_buf, value); if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -837,12 +1232,17 @@ int target_write_u16(struct target_s *target, u32 address, u16 value) int target_write_u8(struct target_s *target, u32 address, u8 value) { int retval; - - DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value); + if (!target->type->examined) + { + LOG_ERROR("Target not examined yet"); + return ERROR_FAIL; + } + + LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value); if ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK) { - DEBUG("failed: %i", retval); + LOG_DEBUG("failed: %i", retval); } return retval; @@ -855,7 +1255,7 @@ int target_register_user_commands(struct command_context_s *cmd_ctx) 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"); + 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|run_and_halt|run_and_init]"); register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset"); @@ -863,20 +1263,24 @@ int target_register_user_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [count]"); register_command(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [count]"); - register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word "); - register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word "); - register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte "); + register_command(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [count]"); + register_command(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [count]"); + register_command(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [count]"); register_command(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint
[hw]"); register_command(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint "); register_command(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint
[value] [mask]"); register_command(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint "); - register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image
['bin'|'ihex']"); + register_command(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image
['bin'|'ihex'|'elf'|'s19']"); register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image
"); + register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image [offset] [type]"); register_command(cmd_ctx, NULL, "load_binary", handle_load_image_command, COMMAND_EXEC, "[DEPRECATED] load_binary
"); register_command(cmd_ctx, NULL, "dump_binary", handle_dump_image_command, COMMAND_EXEC, "[DEPRECATED] dump_binary
"); + target_request_register_commands(cmd_ctx); + trace_register_commands(cmd_ctx); + return ERROR_OK; } @@ -919,8 +1323,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a if (argc < 3) { - ERROR("target command requires at least three arguments: "); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } /* search for the specified target */ @@ -935,7 +1338,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a /* register target specific commands */ if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK) { - ERROR("couldn't register '%s' commands", args[0]); + LOG_ERROR("couldn't register '%s' commands", args[0]); exit(-1); } @@ -956,11 +1359,12 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN; else { - ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]); - exit(-1); + LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]); + return ERROR_COMMAND_SYNTAX_ERROR; } /* what to do on a target reset */ + (*last_target_p)->reset_mode = RESET_INIT; /* default */ if (strcmp(args[2], "reset_halt") == 0) (*last_target_p)->reset_mode = RESET_HALT; else if (strcmp(args[2], "reset_run") == 0) @@ -973,14 +1377,16 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->reset_mode = RESET_RUN_AND_INIT; else { - ERROR("unknown target startup mode %s", args[2]); - exit(-1); + /* Kludge! we want to make this reset arg optional while remaining compatible! */ + args--; + argc++; } (*last_target_p)->run_and_halt_time = 1000; /* default 1s */ (*last_target_p)->reset_script = NULL; (*last_target_p)->post_halt_script = NULL; (*last_target_p)->pre_resume_script = NULL; + (*last_target_p)->gdb_program_script = NULL; (*last_target_p)->working_area = 0x0; (*last_target_p)->working_area_size = 0x0; @@ -988,12 +1394,26 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*last_target_p)->backup_working_area = 0; (*last_target_p)->state = TARGET_UNKNOWN; + (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED; (*last_target_p)->reg_cache = NULL; (*last_target_p)->breakpoints = NULL; (*last_target_p)->watchpoints = NULL; (*last_target_p)->next = NULL; (*last_target_p)->arch_info = NULL; + /* initialize trace information */ + (*last_target_p)->trace_info = malloc(sizeof(trace_t)); + (*last_target_p)->trace_info->num_trace_points = 0; + (*last_target_p)->trace_info->trace_points_size = 0; + (*last_target_p)->trace_info->trace_points = NULL; + (*last_target_p)->trace_info->trace_history_size = 0; + (*last_target_p)->trace_info->trace_history = NULL; + (*last_target_p)->trace_info->trace_history_pos = 0; + (*last_target_p)->trace_info->trace_history_overflowed = 0; + + (*last_target_p)->dbgmsg = NULL; + (*last_target_p)->dbg_msg_enabled = 0; + (*last_target_p)->type->target_command(cmd_ctx, cmd, args, argc, *last_target_p); found = 1; @@ -1005,8 +1425,8 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a /* no matching target found */ if (!found) { - ERROR("target '%s' not found", args[0]); - exit(-1); + LOG_ERROR("target '%s' not found", args[0]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1019,16 +1439,15 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c if (argc < 3) { - ERROR("incomplete target_script command"); - exit(-1); + LOG_ERROR("incomplete target_script command"); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } if (strcmp(args[1], "reset") == 0) @@ -1049,10 +1468,16 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c free(target->pre_resume_script); target->pre_resume_script = strdup(args[2]); } + else if (strcmp(args[1], "gdb_program_config") == 0) + { + if (target->gdb_program_script) + free(target->gdb_program_script); + target->gdb_program_script = strdup(args[2]); + } else { - ERROR("unknown event type: '%s", args[1]); - exit(-1); + LOG_ERROR("unknown event type: '%s", args[1]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1064,16 +1489,13 @@ int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cm if (argc < 2) { - ERROR("incomplete run_and_halt_time command"); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); - if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target->run_and_halt_time = strtoul(args[1], NULL, 0); @@ -1085,21 +1507,23 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch { target_t *target = NULL; - if (argc < 4) + if ((argc < 4) || (argc > 5)) { - ERROR("incomplete working_area command. usage: working_area
<'backup'|'nobackup'>"); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } target = get_target_by_num(strtoul(args[0], NULL, 0)); - if (!target) { - ERROR("target number '%s' not defined", args[0]); - exit(-1); + return ERROR_COMMAND_SYNTAX_ERROR; } + 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) @@ -1112,8 +1536,8 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch } else { - ERROR("unrecognized argument (%s)", args[3]); - exit(-1); + LOG_ERROR("unrecognized argument (%s)", args[3]); + return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1123,20 +1547,14 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch /* process target state changes */ int handle_target(void *priv) { - int retval; target_t *target = targets; while (target) { - /* only poll if target isn't already halted */ - if (target->state != TARGET_HALTED) + if (target_continous_poll) { - if (target_continous_poll) - if ((retval = target->type->poll(target)) < 0) - { - ERROR("couldn't poll target, exiting"); - exit(-1); - } + /* polling may fail silently until the target has been examined */ + target_poll(target); } target = target->next; @@ -1152,7 +1570,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args int count = 0; char *value; - DEBUG("-"); + LOG_DEBUG("-"); target = get_current_target(cmd_ctx); @@ -1227,7 +1645,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); if (arch_type == NULL) { - ERROR("BUG: encountered unregistered arch type"); + LOG_ERROR("BUG: encountered unregistered arch type"); return ERROR_OK; } arch_type->get(reg); @@ -1247,7 +1665,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); if (arch_type == NULL) { - ERROR("BUG: encountered unregistered arch type"); + LOG_ERROR("BUG: encountered unregistered arch type"); return ERROR_OK; } @@ -1267,20 +1685,16 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } +static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms); + 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_poll(target); + target_arch_state(target); } else { @@ -1292,6 +1706,10 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg { target_continous_poll = 0; } + else + { + command_print(cmd_ctx, "arg is \"on\" or \"off\""); + } } @@ -1300,38 +1718,58 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - target_t *target = get_current_target(cmd_ctx); - struct timeval timeout, now; + int ms = 5000; - gettimeofday(&timeout, NULL); - if (!argc) - timeval_add_time(&timeout, 5, 0); - else { + if (argc > 0) + { char *end; - timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0); - if (*end) { - command_print(cmd_ctx, "usage: wait_halt [seconds]"); + ms = strtoul(args[0], &end, 0) * 1000; + if (*end) + { + command_print(cmd_ctx, "usage: %s [seconds]", cmd); return ERROR_OK; } } - command_print(cmd_ctx, "waiting for target halted..."); + return wait_state(cmd_ctx, cmd, TARGET_HALTED, ms); +} - while(target->type->poll(target)) +static void target_process_events(struct command_context_s *cmd_ctx) +{ + target_t *target = get_current_target(cmd_ctx); + target_poll(target); + target_call_timer_callbacks_now(); +} + +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); + + target_t *target = get_current_target(cmd_ctx); + for (;;) { - if (target->state == TARGET_HALTED) + if ((retval=target_poll(target))!=ERROR_OK) + return retval; + target_call_timer_callbacks_now(); + if (target->state == state) { - command_print(cmd_ctx, "target halted"); break; } - target_call_timer_callbacks(); + 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_usec >= timeout.tv_usec)) + 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 halt"); - ERROR("timed out while waiting for target halt"); + LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]); break; } } @@ -1344,71 +1782,24 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int retval; target_t *target = get_current_target(cmd_ctx); - DEBUG("-"); - - command_print(cmd_ctx, "requesting target halt..."); + LOG_DEBUG("-"); - 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"); - exit(-1); - default: - command_print(cmd_ctx, "unknown error... shutting down"); - exit(-1); - } - } - - return ERROR_OK; - -} - -/* what to do on daemon startup */ -int handle_daemon_startup_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - if (argc == 1) + if ((retval = target_halt(target)) != ERROR_OK) { - if (strcmp(args[0], "attach") == 0) - { - startup_mode = DAEMON_ATTACH; - return ERROR_OK; - } - else if (strcmp(args[0], "reset") == 0) - { - startup_mode = DAEMON_RESET; - return ERROR_OK; - } + return retval; } - WARNING("invalid daemon_startup configuration directive: %s", args[0]); - return ERROR_OK; - + return handle_wait_halt_command(cmd_ctx, cmd, args, argc); } + int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - int retval; - command_print(cmd_ctx, "requesting target halt and executing a soft reset"); + LOG_USER("requesting target halt and executing a soft reset"); - if ((retval = target->type->soft_reset_halt(target)) != ERROR_OK) - { - switch (retval) - { - case ERROR_TARGET_TIMEOUT: - command_print(cmd_ctx, "target timed out... shutting down"); - exit(-1); - default: - command_print(cmd_ctx, "unknown error... shutting down"); - exit(-1); - } - } + target->type->soft_reset_halt(target); return ERROR_OK; } @@ -1416,9 +1807,10 @@ int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - enum target_reset_mode reset_mode = RESET_RUN; + enum target_reset_mode reset_mode = target->reset_mode; + enum target_reset_mode save = target->reset_mode; - DEBUG("-"); + LOG_DEBUG("-"); if (argc >= 1) { @@ -1449,11 +1841,17 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]"); return ERROR_OK; } - target->reset_mode = reset_mode; } + /* temporarily modify mode of current reset target */ + target->reset_mode = reset_mode; + + /* reset *all* targets */ target_process_reset(cmd_ctx); + /* Restore default reset mode for this target */ + target->reset_mode = save; + return ERROR_OK; } @@ -1462,39 +1860,25 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a 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 */ + retval = target_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 */ + retval = target_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 ERROR_OK; + target_process_events(cmd_ctx); + + return retval; } int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); - DEBUG("-"); + LOG_DEBUG("-"); if (argc == 0) target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */ @@ -1507,9 +1891,11 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { + const int line_bytecnt = 32; int count = 1; int size = 4; u32 address = 0; + int line_modulo; int i; char output[128]; @@ -1532,64 +1918,51 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, switch (cmd[2]) { case 'w': - size = 4; + size = 4; line_modulo = line_bytecnt / 4; break; case 'h': - size = 2; + size = 2; line_modulo = line_bytecnt / 2; break; case 'b': - size = 1; + size = 1; line_modulo = line_bytecnt / 1; break; default: return ERROR_OK; } buffer = calloc(count, size); - if ((retval = target->type->read_memory(target, address, size, count, buffer)) != ERROR_OK) + retval = target->type->read_memory(target, address, size, count, buffer); + if (retval == ERROR_OK) { - switch (retval) + output_len = 0; + + for (i = 0; i < count; i++) { - case ERROR_TARGET_UNALIGNED_ACCESS: - command_print(cmd_ctx, "error: address not aligned"); - break; - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "error: target must be halted for memory accesses"); - break; - case ERROR_TARGET_DATA_ABORT: - command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted"); - break; - default: - command_print(cmd_ctx, "error: unknown error"); - break; + if (i%line_modulo == 0) + output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size)); + + switch (size) + { + case 4: + output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4])); + break; + case 2: + output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2])); + break; + case 1: + output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]); + break; + } + + if ((i%line_modulo == line_modulo-1) || (i == count - 1)) + { + command_print(cmd_ctx, output); + output_len = 0; + } } - return ERROR_OK; - } - - output_len = 0; - - for (i = 0; i < count; i++) + } else { - if (i%8 == 0) - output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size)); - - switch (size) - { - case 4: - output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4])); - break; - case 2: - output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2])); - break; - case 1: - output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]); - break; - } - - if ((i%8 == 7) || (i == count - 1)) - { - command_print(cmd_ctx, output); - output_len = 0; - } + LOG_ERROR("Failure examining memory"); } free(buffer); @@ -1601,50 +1974,59 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, { u32 address = 0; u32 value = 0; - int retval; + int count = 1; + int i; + int wordsize; target_t *target = get_current_target(cmd_ctx); u8 value_buf[4]; - if (argc < 2) - return ERROR_OK; + if ((argc < 2) || (argc > 3)) + return ERROR_COMMAND_SYNTAX_ERROR; address = strtoul(args[0], NULL, 0); value = strtoul(args[1], NULL, 0); + if (argc == 3) + count = strtoul(args[2], NULL, 0); + switch (cmd[2]) { case 'w': + wordsize = 4; target_buffer_set_u32(target, value_buf, value); - retval = target->type->write_memory(target, address, 4, 1, value_buf); break; case 'h': + wordsize = 2; target_buffer_set_u16(target, value_buf, value); - retval = target->type->write_memory(target, address, 2, 1, value_buf); break; case 'b': + wordsize = 1; value_buf[0] = value; - retval = target->type->write_memory(target, address, 1, 1, value_buf); break; default: - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } - - switch (retval) + for (i=0; itype->write_memory(target, address + i*wordsize, 4, 1, value_buf); + break; + case 2: + retval = target->type->write_memory(target, address + i*wordsize, 2, 1, value_buf); + break; + case 1: + retval = target->type->write_memory(target, address + i*wordsize, 1, 1, value_buf); break; + default: + return ERROR_OK; + } + if (retval!=ERROR_OK) + { + return retval; + } } return ERROR_OK; @@ -1653,74 +2035,93 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - u32 address; u8 *buffer; u32 buf_cnt; - u32 binary_size; - - fileio_t file; - enum fileio_pri_type pri_type = FILEIO_IMAGE; - fileio_image_t image_info; - enum fileio_sec_type sec_type; + u32 image_size; + int i; + int retval; + + image_t image; duration_t duration; char *duration_text; target_t *target = get_current_target(cmd_ctx); - if (argc < 2) + if (argc < 1) { - command_print(cmd_ctx, "usage: load_image
[type]"); + command_print(cmd_ctx, "usage: load_image [address] [type]"); return ERROR_OK; } - memset(&file, 0, sizeof(fileio_t)); - fileio_identify_image_type(&sec_type, (argc == 3) ? args[2] : NULL); - - image_info.base_address = strtoul(args[1], NULL, 0); - image_info.has_start_address = 0; + /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */ + if (argc >= 2) + { + image.base_address_set = 1; + image.base_address = strtoul(args[1], NULL, 0); + } + else + { + image.base_address_set = 0; + } - buffer = malloc(128 * 1024); + image.start_address_set = 0; duration_start_measure(&duration); - if (fileio_open(&file, args[0], FILEIO_READ, - pri_type, &image_info, sec_type) != ERROR_OK) + if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) { - command_print(cmd_ctx, "load_image error: %s", file.error_str); return ERROR_OK; } - binary_size = file.size; - address = image_info.base_address; - while ((binary_size > 0) && - (fileio_read(&file, 128 * 1024, buffer, &buf_cnt) == ERROR_OK)) + image_size = 0x0; + retval = ERROR_OK; + for (i = 0; i < image.num_sections; i++) { - target_write_buffer(target, address, buf_cnt, buffer); - address += buf_cnt; - binary_size -= buf_cnt; + buffer = malloc(image.sections[i].size); + if (buffer == NULL) + { + command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size); + break; + } + + if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK) + { + free(buffer); + break; + } + if ((retval = target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer)) != ERROR_OK) + { + free(buffer); + break; + } + image_size += buf_cnt; + command_print(cmd_ctx, "%u byte written at address 0x%8.8x", buf_cnt, image.sections[i].base_address); + + free(buffer); } - free(buffer); - duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "downloaded %lli byte in %s", file.size, duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text); + } free(duration_text); - fileio_close(&file); + image_close(&image); - return ERROR_OK; + return retval; } int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - fileio_t file; - fileio_image_t image_info; + fileio_t fileio; u32 address; u32 size; u8 buffer[560]; + int retval=ERROR_OK; duration_t duration; char *duration_text; @@ -1742,13 +2143,8 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } - image_info.base_address = address; - image_info.has_start_address = 0; - - if (fileio_open(&file, args[0], FILEIO_WRITE, - FILEIO_IMAGE, &image_info, FILEIO_PLAIN) != ERROR_OK) + if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { - command_print(cmd_ctx, "dump_image error: %s", file.error_str); return ERROR_OK; } @@ -1759,21 +2155,159 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char u32 size_written; u32 this_run_size = (size > 560) ? 560 : size; - target->type->read_memory(target, address, 4, this_run_size / 4, buffer); - fileio_write(&file, this_run_size, buffer, &size_written); + retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer); + if (retval != ERROR_OK) + { + break; + } + + retval = fileio_write(&fileio, this_run_size, buffer, &size_written); + if (retval != ERROR_OK) + { + break; + } size -= this_run_size; address += this_run_size; } - fileio_close(&file); + fileio_close(&fileio); duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "dumped %lli byte in %s", file.size, duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text); + } free(duration_text); return ERROR_OK; +} + +int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + u8 *buffer; + u32 buf_cnt; + u32 image_size; + int i; + int retval; + u32 checksum = 0; + u32 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_COMMAND_SYNTAX_ERROR; + } + + if (!target) + { + LOG_ERROR("no target selected"); + return ERROR_FAIL; + } + + duration_start_measure(&duration); + + if (argc >= 2) + { + image.base_address_set = 1; + image.base_address = strtoul(args[1], NULL, 0); + } + else + { + image.base_address_set = 0; + image.base_address = 0x0; + } + + image.start_address_set = 0; + + if ((retval=image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK) + { + return retval; + } + + image_size = 0x0; + retval=ERROR_OK; + for (i = 0; i < image.num_sections; i++) + { + buffer = malloc(image.sections[i].size); + if (buffer == NULL) + { + command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", image.sections[i].size); + break; + } + if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK) + { + free(buffer); + break; + } + + /* calculate checksum of image */ + image_calculate_checksum( buffer, buf_cnt, &checksum ); + + retval = target_checksum_memory(target, image.sections[i].base_address, buf_cnt, &mem_checksum); + if( retval != ERROR_OK ) + { + free(buffer); + break; + } + + if( checksum != mem_checksum ) + { + /* failed crc checksum, fall back to a binary compare */ + u8 *data; + + command_print(cmd_ctx, "checksum mismatch - attempting binary compare"); + + data = (u8*)malloc(buf_cnt); + + /* Can we use 32bit word accesses? */ + int size = 1; + int count = buf_cnt; + if ((count % 4) == 0) + { + size *= 4; + count /= 4; + } + retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data); + if (retval == ERROR_OK) + { + int t; + for (t = 0; t < buf_cnt; t++) + { + if (data[t] != buffer[t]) + { + command_print(cmd_ctx, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", t + image.sections[i].base_address, data[t], buffer[t]); + free(data); + free(buffer); + retval=ERROR_FAIL; + goto done; + } + } + } + + free(data); + } + + free(buffer); + image_size += buf_cnt; + } +done: + duration_stop_measure(&duration, &duration_text); + if (retval==ERROR_OK) + { + command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text); + } + free(duration_text); + + image_close(&image); + + return retval; } int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1813,18 +2347,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK) { - switch (retval) - { - case ERROR_TARGET_NOT_HALTED: - command_print(cmd_ctx, "target must be halted to set breakpoints"); - break; - case ERROR_TARGET_RESOURCE_NOT_AVAILABLE: - command_print(cmd_ctx, "no more breakpoints available"); - break; - default: - command_print(cmd_ctx, "unknown error, breakpoint not set"); - break; - } + LOG_ERROR("Failure setting breakpoints"); } else { @@ -1852,6 +2375,7 @@ int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target = get_current_target(cmd_ctx); + int retval; if (argc == 0) { @@ -1895,7 +2419,12 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, { data_mask = strtoul(args[4], NULL, 0); } - watchpoint_add(target, strtoul(args[0], NULL, 0), strtoul(args[1], NULL, 0), type, data_value, data_mask); + + if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0), + strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK) + { + LOG_ERROR("Failure setting breakpoints"); + } } else { @@ -1915,3 +2444,215 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args 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; +} +static void writeLong(FILE *f, int l) +{ + int i; + for (i=0; i<4; i++) + { + char c=(l>>(i*8))&0xff; + fwrite(&c, 1, 1, f); + } + +} +static void writeString(FILE *f, char *s) +{ + fwrite(s, 1, strlen(s), f); +} + + + +// Dump a gmon.out histogram file. +static void writeGmon(u32 *samples, int sampleNum, char *filename) +{ + int i; + FILE *f=fopen(filename, "w"); + if (f==NULL) + return; + fwrite("gmon", 1, 4, f); + writeLong(f, 0x00000001); // Version + writeLong(f, 0); // padding + writeLong(f, 0); // padding + writeLong(f, 0); // padding + + fwrite("", 1, 1, f); // GMON_TAG_TIME_HIST + + // figure out bucket size + u32 min=samples[0]; + u32 max=samples[0]; + for (i=0; isamples[i]) + { + min=samples[i]; + } + if (max maxBuckets) + { + length=maxBuckets; + } + int *buckets=malloc(sizeof(int)*length); + if (buckets==NULL) + { + fclose(f); + return; + } + memset(buckets, 0, sizeof(int)*length); + for (i=0; i65535) + { + val=65535; + } + data[i*2]=val&0xff; + data[i*2+1]=(val>>8)&0xff; + } + free(buckets); + fwrite(data, 1, length*2, f); + free(data); + } else + { + free(buckets); + } + + fclose(f); +} + +/* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */ +int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + target_t *target = get_current_target(cmd_ctx); + struct timeval timeout, now; + + gettimeofday(&timeout, NULL); + if (argc!=2) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + char *end; + timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0); + if (*end) + { + return ERROR_OK; + } + + command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can..."); + + static const int maxSample=10000; + u32 *samples=malloc(sizeof(u32)*maxSample); + if (samples==NULL) + return ERROR_OK; + + int numSamples=0; + int retval=ERROR_OK; + // hopefully it is safe to cache! We want to stop/restart as quickly as possible. + reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1); + + for (;;) + { + target_poll(target); + if (target->state == TARGET_HALTED) + { + u32 t=*((u32 *)reg->value); + samples[numSamples++]=t; + retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + target_poll(target); + usleep(10*1000); // sleep 10ms, i.e. <100 samples/second. + } else if (target->state == TARGET_RUNNING) + { + // We want to quickly sample the PC. + target_halt(target); + } else + { + command_print(cmd_ctx, "Target not halted or running"); + retval=ERROR_OK; + break; + } + if (retval!=ERROR_OK) + { + break; + } + + gettimeofday(&now, NULL); + if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) + { + command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples); + target_poll(target); + if (target->state == TARGET_HALTED) + { + target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */ + } + target_poll(target); + writeGmon(samples, numSamples, args[1]); + command_print(cmd_ctx, "Wrote %s", args[1]); + break; + } + } + free(samples); + + return ERROR_OK; +} +