{
int retval = ERROR_OK;
target_t *target;
+ struct timeval timeout, now;
/* prepare reset_halt where necessary */
target = targets;
while (target)
{
+ if (jtag_reset_config & RESET_SRST_PULLS_TRST)
+ {
+ 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;
+ }
+ }
switch (target->reset_mode)
{
case RESET_HALT:
while (target)
{
target->type->deassert_reset(target);
+ target = target->next;
+ }
+ jtag_execute_queue();
- switch (target->reset_mode)
+ /* 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();
+
+ target = targets;
+ while (target)
{
- 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->type->poll(target);
+ if ((target->reset_mode == RESET_RUN_AND_INIT) || (target->reset_mode == RESET_RUN_AND_HALT))
+ {
+ if (target->state != TARGET_HALTED)
+ {
+ 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 waiting for reset");
+ goto done;
+ }
+ usleep(100*1000); /* Do not eat all cpu */
+ goto again;
+ }
+ }
+ target = target->next;
}
+ /* All targets we're waiting for are halted */
+ break;
-
- target = target->next;
+ again:;
}
- jtag_execute_queue();
+ done:
+
+
+ /* We want any events to be processed before the prompt */
+ target_call_timer_callbacks();
return retval;
-}
+}
int target_init(struct command_context_s *cmd_ctx)
{
target_register_timer_callback(handle_target, 100, 1, NULL);
}
+ return ERROR_OK;
+}
+
+int target_init_reset(struct command_context_s *cmd_ctx)
+{
if (startup_mode == DAEMON_RESET)
target_process_reset(cmd_ctx);
size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
{
buffer = malloc(size);
+ if (buffer == NULL)
+ {
+ ERROR("error allocating buffer for section (%d bytes)", size);
+ return ERROR_OK;
+ }
target_read_buffer(target, address, size, buffer);
/* convert to target endianess */
(*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)->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);
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]);
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);
{
target_continous_poll = 0;
}
+ else
+ {
+ command_print(cmd_ctx, "arg is \"on\" or \"off\"");
+ }
}
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 int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
+{
+ struct timeval timeout, now;
+
+ 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))
{
- if (target->state == TARGET_HALTED)
+ target_call_timer_callbacks();
+ if (target->state == state)
{
- command_print(cmd_ctx, "target halted");
+ command_print(cmd_ctx, "target %s", target_state_strings[state]);
break;
}
- target_call_timer_callbacks();
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");
+ 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;
}
}
break;
case ERROR_TARGET_TIMEOUT:
command_print(cmd_ctx, "target timed out... shutting down");
- exit(-1);
+ return retval;
default:
command_print(cmd_ctx, "unknown error... shutting down");
- exit(-1);
+ return retval;
}
}
- return ERROR_OK;
-
+ return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
}
/* what to do on daemon startup */
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("-");
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;
}
}
}
- return ERROR_OK;
+ return wait_state(cmd_ctx, cmd, TARGET_RUNNING, 5000);
}
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)
{
+ const int line_bytecnt = 32;
int count = 1;
int size = 4;
u32 address = 0;
+ int line_modulo;
int i;
char output[128];
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)
{
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)
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;
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)
{
ERROR("image_read_section failed with error code: %i", retval);
u32 address;
u32 size;
u8 buffer[560];
+ int retval;
duration_t duration;
char *duration_text;
u32 size_written;
u32 this_run_size = (size > 560) ? 560 : size;
- target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
+ retval = target->type->read_memory(target, address, 4, this_run_size / 4, buffer);
+ if (retval != ERROR_OK)
+ {
+ command_print(cmd_ctx, "Reading memory failed %d", retval);
+ break;
+ }
+
fileio_write(&fileio, this_run_size, buffer, &size_written);
size -= this_run_size;
free(duration_text);
return ERROR_OK;
-
}
int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
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)
{
ERROR("image_read_section failed with error code: %i", retval);
return ERROR_OK;
}
-
-
Code Review / openocd.git / blobdiff