X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=f77de33939fa8dd232cf0e452f1fafd813d19261;hp=34dc60a70a799331b8098a3bc87532d33902ba71;hb=651ba91465d05f64b7650334499e320f6851936c;hpb=ef139a3a5e41fbcbabdf4be0ecbbb5591448ad2e diff --git a/src/target/target.c b/src/target/target.c index 34dc60a70a..f77de33939 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -17,8 +17,13 @@ * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ +#ifdef HAVE_CONFIG_H #include "config.h" +#endif + +#include "replacements.h" #include "target.h" +#include "target_request.h" #include "log.h" #include "configuration.h" @@ -27,6 +32,7 @@ #include #include +#include #include #include @@ -38,6 +44,9 @@ #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); @@ -58,8 +67,9 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_load_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_dump_binary_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); @@ -71,6 +81,10 @@ extern target_type_t arm7tdmi_target; extern target_type_t arm720t_target; 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 xscale_target; +extern target_type_t cortexm3_target; target_type_t *target_types[] = { @@ -78,6 +92,10 @@ target_type_t *target_types[] = &arm9tdmi_target, &arm920t_target, &arm720t_target, + &arm966e_target, + &arm926ejs_target, + &xscale_target, + &cortexm3_target, NULL, }; @@ -203,6 +221,8 @@ int target_init_handler(struct target_s *target, enum target_event event, void * if ((event == TARGET_EVENT_HALTED) && (target->reset_script)) { + target_unregister_event_callback(target_init_handler, priv); + script = fopen(target->reset_script, "r"); if (!script) { @@ -215,8 +235,6 @@ int target_init_handler(struct target_s *target, enum target_event event, void * fclose(script); jtag_execute_queue(); - - target_unregister_event_callback(target_init_handler, priv); } return ERROR_OK; @@ -235,7 +253,23 @@ int target_process_reset(struct command_context_s *cmd_ctx) { int retval = ERROR_OK; target_t *target; - + + /* prepare reset_halt where necessary */ + target = targets; + while (target) + { + switch (target->reset_mode) + { + case RESET_HALT: + case RESET_INIT: + target->type->prepare_reset_halt(target); + break; + default: + break; + } + target = target->next; + } + target = targets; while (target) { @@ -279,6 +313,23 @@ int target_process_reset(struct command_context_s *cmd_ctx) while (target) { target->type->deassert_reset(target); + + switch (target->reset_mode) + { + case RESET_INIT: + case RESET_HALT: + // If we're already halted, then this is harmless(reducing # of execution paths here) + // If nSRST & nTRST are tied together then the halt during reset failed(logged) and + // we use this as fallback(there is no other output to tell the user that reset halt + // didn't work). + target->type->poll(target); + target->type->halt(target); + break; + default: + break; + } + + target = target->next; } jtag_execute_queue(); @@ -621,6 +672,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff { if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK) return retval; + return ERROR_OK; } /* handle unaligned head bytes */ @@ -679,6 +731,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe { if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK) return retval; + return ERROR_OK; } /* handle unaligned head bytes */ @@ -689,6 +742,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK) return retval; + buffer += unaligned; address += unaligned; size -= unaligned; } @@ -701,6 +755,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK) return retval; + buffer += aligned; address += aligned; size -= aligned; } @@ -715,14 +770,147 @@ 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 ((retval = target->type->checksum_memory(target, address, + size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) + { + buffer = malloc(size); + target_read_buffer(target, address, size, buffer); + + /* 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]; + + 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); + } + else + { + *value = 0x0; + DEBUG("address: 0x%8.8x failed", address); + } + + return retval; +} + +int target_read_u16(struct target_s *target, u32 address, u16 *value) +{ + u8 value_buf[2]; + + 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); + } + else + { + *value = 0x0; + DEBUG("address: 0x%8.8x failed", address); + } + + return retval; +} + +int target_read_u8(struct target_s *target, u32 address, u8 *value) +{ + int retval = target->type->read_memory(target, address, 1, 1, value); + + if (retval == ERROR_OK) + { + DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, *value); + } + else + { + *value = 0x0; + DEBUG("address: 0x%8.8x failed", address); + } + + return retval; +} + +int target_write_u32(struct target_s *target, u32 address, u32 value) +{ + int retval; + u8 value_buf[4]; + + 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); + } + + return retval; +} + +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); + + 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); + } + + return retval; +} + +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 ((retval = target->type->read_memory(target, address, 1, 1, &value)) != ERROR_OK) + { + DEBUG("failed: %i", retval); + } + + return retval; +} + int target_register_user_commands(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL); 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"); + 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"); @@ -739,8 +927,14 @@ int target_register_user_commands(struct command_context_s *cmd_ctx) 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_binary", handle_load_binary_command, COMMAND_EXEC, "load binary
"); - register_command(cmd_ctx, NULL, "dump_binary", handle_dump_binary_command, COMMAND_EXEC, "dump binary
"); + 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; } @@ -846,13 +1040,13 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*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; (*last_target_p)->working_areas = NULL; (*last_target_p)->backup_working_area = 0; - (*last_target_p)->endianness = TARGET_LITTLE_ENDIAN; (*last_target_p)->state = TARGET_UNKNOWN; (*last_target_p)->reg_cache = NULL; (*last_target_p)->breakpoints = NULL; @@ -860,6 +1054,19 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a (*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; @@ -915,6 +1122,12 @@ 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]); @@ -1000,8 +1213,7 @@ int handle_target(void *priv) if (target_continous_poll) if ((retval = target->type->poll(target)) < 0) { - ERROR("couldn't poll target, exiting"); - exit(-1); + ERROR("couldn't poll target. It's due for a reset."); } } @@ -1018,7 +1230,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args int count = 0; char *value; - DEBUG(""); + DEBUG("-"); target = get_current_target(cmd_ctx); @@ -1033,7 +1245,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args int i; for (i = 0; i < cache->num_regs; i++) { - value = buf_to_char(cache->reg_list[i].value, cache->reg_list[i].size); + value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16); command_print(cmd_ctx, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count++, cache->reg_list[i].name, cache->reg_list[i].size, value, cache->reg_list[i].dirty, cache->reg_list[i].valid); free(value); } @@ -1098,7 +1310,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args } arch_type->get(reg); } - value = buf_to_char(reg->value, reg->size); + value = buf_to_str(reg->value, reg->size, 16); command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value); free(value); return ERROR_OK; @@ -1107,7 +1319,9 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args /* set register value */ if (argc == 2) { - u32 new_value = strtoul(args[1], NULL, 0); + u8 *buf = malloc(CEIL(reg->size, 8)); + str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0); + reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); if (arch_type == NULL) { @@ -1115,11 +1329,14 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } - arch_type->set(reg, new_value); - value = buf_to_char(reg->value, reg->size); + arch_type->set(reg, buf); + + value = buf_to_str(reg->value, reg->size, 16); command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value); free(value); + free(buf); + return ERROR_OK; } @@ -1165,7 +1382,17 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char struct timeval timeout, now; gettimeofday(&timeout, NULL); - timeval_add_time(&timeout, 5, 0); + if (!argc) + timeval_add_time(&timeout, 5, 0); + else { + char *end; + + timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0); + if (*end) { + command_print(cmd_ctx, "usage: wait_halt [seconds]"); + return ERROR_OK; + } + } command_print(cmd_ctx, "waiting for target halted..."); @@ -1195,7 +1422,7 @@ 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(""); + DEBUG("-"); command_print(cmd_ctx, "requesting target halt..."); @@ -1269,7 +1496,7 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar target_t *target = get_current_target(cmd_ctx); enum target_reset_mode reset_mode = RESET_RUN; - DEBUG(""); + DEBUG("-"); if (argc >= 1) { @@ -1313,7 +1540,7 @@ 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(""); + DEBUG("-"); if (argc == 0) retval = target->type->resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */ @@ -1345,7 +1572,7 @@ int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **arg { target_t *target = get_current_target(cmd_ctx); - DEBUG(""); + DEBUG("-"); if (argc == 0) target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */ @@ -1358,9 +1585,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; + u32 address = 0; + int line_modulo; int i; char output[128]; @@ -1383,20 +1612,21 @@ 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) { @@ -1413,29 +1643,30 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, command_print(cmd_ctx, "error: unknown error"); break; } + return ERROR_OK; } output_len = 0; for (i = 0; i < count; i++) { - if (i%8 == 0) + 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 ", ((u32*)buffer)[i]); + 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 ", ((u16*)buffer)[i]); + 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 ", ((u8*)buffer)[i]); + output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]); break; } - if ((i%8 == 7) || (i == count - 1)) + if ((i%line_modulo == line_modulo-1) || (i == count - 1)) { command_print(cmd_ctx, output); output_len = 0; @@ -1453,6 +1684,7 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, u32 value = 0; int retval; target_t *target = get_current_target(cmd_ctx); + u8 value_buf[4]; if (argc < 2) return ERROR_OK; @@ -1463,13 +1695,16 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, switch (cmd[2]) { case 'w': - retval = target->type->write_memory(target, address, 4, 1, (u8*)&value); + target_buffer_set_u32(target, value_buf, value); + retval = target->type->write_memory(target, address, 4, 1, value_buf); break; case 'h': - retval = target->type->write_memory(target, address, 2, 1, (u8*)&value); + target_buffer_set_u16(target, value_buf, value); + retval = target->type->write_memory(target, address, 2, 1, value_buf); break; case 'b': - retval = target->type->write_memory(target, address, 1, 1, (u8*)&value); + value_buf[0] = value; + retval = target->type->write_memory(target, address, 1, 1, value_buf); break; default: return ERROR_OK; @@ -1497,113 +1732,267 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, } -int handle_load_binary_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) { - FILE *binary; - u32 address; - struct stat binary_stat; - u32 binary_size; - u8 *buffer; u32 buf_cnt; + u32 image_size; + int i; + int retval; + + image_t image; + + duration_t duration; + char *duration_text; - struct timeval start, end; - target_t *target = get_current_target(cmd_ctx); - if (argc != 2) + if (argc < 1) { - command_print(cmd_ctx, "usage: load_binary
"); + command_print(cmd_ctx, "usage: load_image [address] [type]"); return ERROR_OK; } - - address = strtoul(args[1], NULL, 0); - - if (stat(args[0], &binary_stat) == -1) + + /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */ + if (argc >= 2) { - ERROR("couldn't stat() %s: %s", args[0], strerror(errno)); - command_print(cmd_ctx, "error accessing file %s", args[0]); - return ERROR_OK; + image.base_address_set = 1; + image.base_address = strtoul(args[1], NULL, 0); } + else + { + image.base_address_set = 0; + } + + image.start_address_set = 0; - if (!(binary = fopen(args[0], "r"))) + duration_start_measure(&duration); + + if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) { - ERROR("couldn't open %s: %s", args[0], strerror(errno)); - command_print(cmd_ctx, "error accessing file %s", args[0]); + command_print(cmd_ctx, "load_image error: %s", image.error_str); return ERROR_OK; } - buffer = malloc(128 * 1024); - - gettimeofday(&start, NULL); - - binary_size = binary_stat.st_size; - while (binary_size > 0) + image_size = 0x0; + for (i = 0; i < image.num_sections; i++) { - buf_cnt = fread(buffer, 1, 128*1024, binary); - 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) + { + ERROR("image_read_section failed with error code: %i", retval); + command_print(cmd_ctx, "image reading failed, download aborted"); + free(buffer); + image_close(&image); + return ERROR_OK; + } + target_write_buffer(target, image.sections[i].base_address, buf_cnt, buffer); + 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); } - gettimeofday(&end, NULL); - - free(buffer); - - command_print(cmd_ctx, "downloaded %lli byte in %is %ius", (long long) binary_stat.st_size, end.tv_sec - start.tv_sec, end.tv_usec - start.tv_usec); + duration_stop_measure(&duration, &duration_text); + command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text); + free(duration_text); - fclose(binary); + image_close(&image); return ERROR_OK; } -int handle_dump_binary_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) { - FILE *binary; + fileio_t fileio; + u32 address; u32 size; u8 buffer[560]; + duration_t duration; + char *duration_text; + target_t *target = get_current_target(cmd_ctx); if (argc != 3) { - command_print(cmd_ctx, "usage: dump_binary
"); + command_print(cmd_ctx, "usage: dump_image
"); return ERROR_OK; } address = strtoul(args[1], NULL, 0); size = strtoul(args[2], NULL, 0); - if (!(binary = fopen(args[0], "w"))) + if ((address & 3) || (size & 3)) { - ERROR("couldn't open %s for writing: %s", args[0], strerror(errno)); - command_print(cmd_ctx, "error accessing file %s", args[0]); + command_print(cmd_ctx, "only 32-bit aligned address and size are supported"); return ERROR_OK; } - - if ((address & 3) || (size & 3)) + + if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { - command_print(cmd_ctx, "only 32-bit aligned address and size are supported"); + command_print(cmd_ctx, "dump_image error: %s", fileio.error_str); return ERROR_OK; } - + + duration_start_measure(&duration); + while (size > 0) { + u32 size_written; u32 this_run_size = (size > 560) ? 560 : size; + target->type->read_memory(target, address, 4, this_run_size / 4, buffer); - fwrite(buffer, 1, this_run_size, binary); + fileio_write(&fileio, this_run_size, buffer, &size_written); + size -= this_run_size; address += this_run_size; } - fclose(binary); + fileio_close(&fileio); + duration_stop_measure(&duration, &duration_text); + 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) + { + command_print(cmd_ctx, "usage: verify_image [offset] [type]"); + return ERROR_OK; + } + + if (!target) + { + ERROR("no target selected"); + return ERROR_OK; + } + + 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 (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; + } + + image_size = 0x0; + for (i = 0; i < image.num_sections; i++) + { + buffer = malloc(image.sections[i].size); + if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK) + { + ERROR("image_read_section failed with error code: %i", retval); + command_print(cmd_ctx, "image reading failed, verify aborted"); + free(buffer); + image_close(&image); + return ERROR_OK; + } + + /* 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 ) + { + command_print(cmd_ctx, "image verify failed, verify aborted"); + free(buffer); + image_close(&image); + return ERROR_OK; + } + + if( checksum != mem_checksum ) + { + /* failed crc checksum, fall back to a binary compare */ + u8 *data; + + command_print(cmd_ctx, "image verify checksum failed - 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); + image_close(&image); + return ERROR_OK; + } + } + } + + free(data); + } + + free(buffer); + image_size += buf_cnt; + } + + duration_stop_measure(&duration, &duration_text); + command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text); + free(duration_text); + + image_close(&image); + + return ERROR_OK; +} + int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int retval; @@ -1617,7 +2006,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, { if (breakpoint->type == BKPT_SOFT) { - char* buf = buf_to_char(breakpoint->orig_instr, breakpoint->length); + char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16); command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf); free(buf); } @@ -1654,6 +2043,14 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, break; } } + else + { + command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0)); + } + } + else + { + command_print(cmd_ctx, "usage: bp
['hw']"); } return ERROR_OK; @@ -1672,6 +2069,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) { @@ -1715,7 +2113,23 @@ 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) + { + switch (retval) + { + case ERROR_TARGET_NOT_HALTED: + command_print(cmd_ctx, "target must be halted to set watchpoints"); + break; + case ERROR_TARGET_RESOURCE_NOT_AVAILABLE: + command_print(cmd_ctx, "no more watchpoints available"); + break; + default: + command_print(cmd_ctx, "unknown error, watchpoint not set"); + break; + } + } } else { @@ -1735,3 +2149,4 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_OK; } +