* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
- * Copyright (C) 2007,2008 Øyvind Harboe *
+ * Copyright (C) 2007,2008 Øyvind Harboe *
* oyvind.harboe@zylin.com *
* *
* Copyright (C) 2008, Duane Ellis *
* openocd@duaneeellis.com *
* *
+ * Copyright (C) 2008 by Spencer Oliver *
+ * spen@spen-soft.co.uk *
+ * *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
#include <fileio.h>
#include <image.h>
-static int USE_OLD_RESET = 0; // temp
-
int cli_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv);
int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_NEWreset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
}
const Jim_Nvp nvp_target_event[] = {
- { .value = TARGET_EVENT_OLD_pre_reset , .name = "old-pre_reset" },
{ .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
- { .value = TARGET_EVENT_OLD_post_reset , .name = "old-post_reset" },
{ .value = TARGET_EVENT_OLD_pre_resume , .name = "old-pre_resume" },
+ { .value = TARGET_EVENT_EARLY_HALTED, .name = "early-halted" },
{ .value = TARGET_EVENT_HALTED, .name = "halted" },
{ .value = TARGET_EVENT_RESUMED, .name = "resumed" },
{ .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
}
-static int NEW_target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
+int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
{
char buf[100];
+ int retval;
Jim_Nvp *n;
n = Jim_Nvp_value2name_simple( nvp_reset_modes, reset_mode );
if( n->name == NULL ){
}
sprintf( buf, "ocd_process_reset %s", n->name );
- Jim_Eval( interp, buf );
- return ERROR_OK;
-}
-
-// Next patch - this turns into TCL...
-static int OLD_target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
-{
- int retval = ERROR_OK;
- target_t *target;
-
- target = all_targets;
-
- target_all_handle_event( TARGET_EVENT_OLD_pre_reset );
-
- if ((retval = jtag_init_reset(cmd_ctx)) != ERROR_OK)
- return retval;
-
- keep_alive(); /* we might be running on a very slow JTAG clk */
-
- /* First time this is executed after launching OpenOCD, it will read out
- * the type of CPU, etc. and init Embedded ICE registers in host
- * memory.
- *
- * It will also set up ICE registers in the target.
- *
- * However, if we assert TRST later, we need to set up the registers again.
- *
- * For the "reset halt/init" case we must only set up the registers here.
- */
- if ((retval = target_examine()) != ERROR_OK)
- return retval;
-
- keep_alive(); /* we might be running on a very slow JTAG clk */
-
- target = all_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->reset_halt=((reset_mode==RESET_HALT)||(reset_mode==RESET_INIT));
- if ((retval = target->type->assert_reset(target))!=ERROR_OK)
- return retval;
- target = target->next;
- }
+ retval = Jim_Eval( interp, buf );
- target = all_targets;
- while (target)
- {
- if ((retval = target->type->deassert_reset(target))!=ERROR_OK)
- return retval;
- target = target->next;
- }
-
- target = all_targets;
- while (target)
- {
- /* We can fail to bring the target into the halted state, try after reset has been deasserted */
- if (target->reset_halt)
- {
- /* wait up to 1 second for halt. */
- target_wait_state(target, TARGET_HALTED, 1000);
- if (target->state != TARGET_HALTED)
- {
- LOG_WARNING("Failed to reset target into halted mode - issuing halt");
- if ((retval = target->type->halt(target))!=ERROR_OK)
- return retval;
- }
- }
-
- target = target->next;
- }
-
-
- LOG_DEBUG("Waiting for halted stated as appropriate");
-
- if ((reset_mode == RESET_HALT) || (reset_mode == RESET_INIT))
- {
- target = all_targets;
- while (target)
- {
- /* Wait for reset to complete, maximum 5 seconds. */
- if (((retval=target_wait_state(target, TARGET_HALTED, 5000)))==ERROR_OK)
- {
- if (reset_mode == RESET_INIT){
- target_handle_event( target, TARGET_EVENT_OLD_post_reset );
- }
-
- }
- target = target->next;
- }
+ if(retval != JIM_OK) {
+ Jim_PrintErrorMessage(interp);
+ return ERROR_FAIL;
}
/* We want any events to be processed before the prompt */
- target_call_timer_callbacks_now();
+ retval = target_call_timer_callbacks_now();
return retval;
}
-int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode)
-{
- if( USE_OLD_RESET ){
- return OLD_target_process_reset( cmd_ctx, reset_mode );
- } else {
- return NEW_target_process_reset( cmd_ctx, reset_mode );
- }
-}
-
static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
{
int target_init(struct command_context_s *cmd_ctx)
{
target_t *target = all_targets;
+ int retval;
while (target)
{
target->type->examine = default_examine;
}
- if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
+ if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
{
LOG_ERROR("target '%s' init failed", target->type->name);
- exit(-1);
+ return retval;
}
/* Set up default functions if none are provided by target */
if (all_targets)
{
- target_register_user_commands(cmd_ctx);
- target_register_timer_callback(handle_target, 100, 1, NULL);
+ if((retval = target_register_user_commands(cmd_ctx)) != ERROR_OK)
+ return retval;
+ if((retval = target_register_timer_callback(handle_target, 100, 1, NULL)) != ERROR_OK)
+ return retval;
}
return ERROR_OK;
target_event_callback_t *callback = target_event_callbacks;
target_event_callback_t *next_callback;
+ if (event == TARGET_EVENT_HALTED)
+ {
+ /* execute early halted first */
+ target_call_event_callbacks(target, TARGET_EVENT_EARLY_HALTED);
+ }
+
+
LOG_DEBUG("target event %i (%s)",
event,
Jim_Nvp_value2name_simple( nvp_target_event, event )->name );
}
}
else
- target_unregister_timer_callback(callback->callback, callback->priv);
+ {
+ int retval;
+ if((retval = target_unregister_timer_callback(callback->callback, callback->priv)) != ERROR_OK)
+ return retval;
+ }
}
}
if (target->backup_working_area)
{
+ int retval;
new_wa->backup = malloc(new_wa->size);
- target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup);
+ if((retval = target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
+ {
+ free(new_wa->backup);
+ free(new_wa);
+ return retval;
+ }
}
else
{
return ERROR_OK;
if (restore&&target->backup_working_area)
- target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
+ {
+ int retval;
+ if((retval = target->type->write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
+ return retval;
+ }
area->free = 1;
return target_free_working_area_restore(target, area, 1);
}
-int target_free_all_working_areas_restore(struct target_s *target, int restore)
+/* free resources and restore memory, if restoring memory fails,
+ * free up resources anyway
+ */
+void target_free_all_working_areas_restore(struct target_s *target, int restore)
{
working_area_t *c = target->working_areas;
}
target->working_areas = NULL;
-
- return ERROR_OK;
}
-int target_free_all_working_areas(struct target_s *target)
+void target_free_all_working_areas(struct target_s *target)
{
- return target_free_all_working_areas_restore(target, 1);
+ target_free_all_working_areas_restore(target, 1);
}
int target_register_commands(struct command_context_s *cmd_ctx)
{
- register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
- register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "working_area <target#> <address> <size> <'backup'|'nobackup'> [virtual address]");
- register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "virt2phys <virtual address>");
- register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "PRELIMINARY! - profile <seconds> <gmon.out>");
+ register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change the current command line target (one parameter) or lists targets (with no parameter)");
+ register_command(cmd_ctx, NULL, "working_area", handle_working_area_command, COMMAND_ANY, "set a new working space");
+ register_command(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address");
+ register_command(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC");
register_jim(cmd_ctx, "target", jim_target, "configure target" );
}
if ((retval = target->type->checksum_memory(target, address,
- size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
+ size, &checksum)) != ERROR_OK)
{
buffer = malloc(size);
if (buffer == NULL)
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)
+ if ((retval = target->type->write_memory(target, address, 1, 1, &value)) != ERROR_OK)
{
LOG_DEBUG("failed: %i", retval);
}
int target_register_user_commands(struct command_context_s *cmd_ctx)
{
- register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
+ int retval = ERROR_OK;
+ register_command(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register");
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 [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 from current PC or [addr]");
- register_command(cmd_ctx, NULL, "NEWreset", handle_NEWreset_command, COMMAND_EXEC, "reset target [run|halt|init] - default is run");
- register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "OLDreset target [run|halt|init] - default is run");
+ register_command(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init] - default is run");
register_command(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset");
register_command(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words <addr> [count]");
register_command(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image <file> <address> <size>");
register_command(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image <file> [offset] [type]");
- target_request_register_commands(cmd_ctx);
- trace_register_commands(cmd_ctx);
+ if((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)
+ return retval;
+ if((retval = trace_register_commands(cmd_ctx)) != ERROR_OK)
+ return retval;
+
- return ERROR_OK;
+ return retval;
}
int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
+ int retval = ERROR_OK;
target_t *target = NULL;
if ((argc < 4) || (argc > 5))
return ERROR_COMMAND_SYNTAX_ERROR;
}
- return ERROR_OK;
+ return retval;
}
/* process target state changes */
int handle_target(void *priv)
{
+ int retval = ERROR_OK;
target_t *target = all_targets;
while (target)
if (target_continous_poll)
{
/* polling may fail silently until the target has been examined */
- target_poll(target);
+ if((retval = target_poll(target)) != ERROR_OK)
+ return retval;
}
target = target->next;
}
- return ERROR_OK;
+ return retval;
}
int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
if (reg->valid == 0)
{
reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
- if (arch_type == NULL)
- {
- LOG_ERROR("BUG: encountered unregistered arch type");
- return ERROR_OK;
- }
arch_type->get(reg);
}
value = buf_to_str(reg->value, reg->size, 16);
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)
- {
- LOG_ERROR("BUG: encountered unregistered arch type");
- return ERROR_OK;
- }
-
arch_type->set(reg, buf);
value = buf_to_str(reg->value, reg->size, 16);
int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
+ int retval = ERROR_OK;
target_t *target = get_current_target(cmd_ctx);
if (argc == 0)
{
- target_poll(target);
- target_arch_state(target);
+ if((retval = target_poll(target)) != ERROR_OK)
+ return retval;
+ if((retval = target_arch_state(target)) != ERROR_OK)
+ return retval;
+
}
- else
+ else if (argc==1)
{
if (strcmp(args[0], "on") == 0)
{
{
command_print(cmd_ctx, "arg is \"on\" or \"off\"");
}
+ } else
+ {
+ return ERROR_COMMAND_SYNTAX_ERROR;
}
- return ERROR_OK;
+ return retval;
}
int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
return target_process_reset(cmd_ctx, reset_mode);
}
-int handle_NEWreset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
-{
- int x;
- char *cp;
-
- if (argc >= 1){
- x = strtol( args[0], &cp, 0 );
- if( *cp != 0 ){
- command_print( cmd_ctx, "Not numeric: %s\n", args[0] );
- return ERROR_COMMAND_SYNTAX_ERROR;
- }
- USE_OLD_RESET = !!x;
- }
- command_print( cmd_ctx, "reset method: %d (%s)\n",
- USE_OLD_RESET,
- USE_OLD_RESET ? "old-method" : "new-method" );
- return ERROR_OK;
-}
int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
LOG_DEBUG("-");
if (argc == 0)
- target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
+ return target->type->step(target, 1, 0, 1); /* current pc, addr = 0, handle breakpoints */
if (argc == 1)
- target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
+ return target->type->step(target, 0, strtoul(args[0], NULL, 0), 1); /* addr = args[0], handle breakpoints */
return ERROR_OK;
}
default:
return ERROR_OK;
}
+ keep_alive();
+
if (retval!=ERROR_OK)
{
return retval;
u32 min_address=0;
u32 max_address=0xffffffff;
int i;
- int retval;
+ int retval, retvaltemp;
image_t image;
free(buffer);
}
- duration_stop_measure(&duration, &duration_text);
+ if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
+ {
+ image_close(&image);
+ return retvaltemp;
+ }
+
if (retval==ERROR_OK)
{
command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
u32 address;
u32 size;
u8 buffer[560];
- int retval=ERROR_OK;
+ int retval=ERROR_OK, retvaltemp;
duration_t duration;
char *duration_text;
address += this_run_size;
}
- fileio_close(&fileio);
+ if((retvaltemp = fileio_close(&fileio)) != ERROR_OK)
+ return retvaltemp;
+
+ if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
+ return retvaltemp;
- duration_stop_measure(&duration, &duration_text);
if (retval==ERROR_OK)
{
command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
u32 buf_cnt;
u32 image_size;
int i;
- int retval;
+ int retval, retvaltemp;
u32 checksum = 0;
u32 mem_checksum = 0;
retval=ERROR_FAIL;
goto done;
}
+ if ((t%16384)==0)
+ {
+ keep_alive();
+ }
}
}
image_size += buf_cnt;
}
done:
- duration_stop_measure(&duration, &duration_text);
+
+ if((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
+ {
+ image_close(&image);
+ return retvaltemp;
+ }
+
if (retval==ERROR_OK)
{
command_print(cmd_ctx, "verified %u bytes in %s", image_size, duration_text);
} else if (target->state == TARGET_RUNNING)
{
// We want to quickly sample the PC.
- target_halt(target);
+ if((retval = target_halt(target)) != ERROR_OK)
+ {
+ free(samples);
+ return retval;
+ }
} else
{
command_print(cmd_ctx, "Target not halted or running");
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((retval = target_poll(target)) != ERROR_OK)
+ {
+ free(samples);
+ return retval;
+ }
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);
+ if((retval = target_poll(target)) != ERROR_OK)
+ {
+ free(samples);
+ return retval;
+ }
writeGmon(samples, numSamples, args[1]);
command_print(cmd_ctx, "Wrote %s", args[1]);
break;
{
long l;
u32 width;
- u32 len;
+ int len;
u32 addr;
u32 count;
u32 v;
{
long l;
u32 width;
- u32 len;
+ int len;
u32 addr;
u32 count;
u32 v;
e,
Jim_Nvp_value2name_simple( nvp_target_event, e )->name,
Jim_GetString( teap->body, NULL ) );
- Jim_EvalObj( interp, teap->body );
+ if (Jim_EvalObj( interp, teap->body )!=JIM_OK)
+ {
+ Jim_PrintErrorMessage(interp);
+ }
}
teap = teap->next;
}
}
if( goi->isconfigure ){
- if( goi->argc == 0 ){
+ if( goi->argc != 1 ){
Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
return JIM_ERR;
}
target, /* private data */
NULL ); /* no del proc */
- (*(target->type->target_create))( target, goi->interp );
return e;
}
}
if( target_types[x] ){
/* YES IT IS OLD SYNTAX */
+ int chain_position_offset;
Jim_Obj *new_argv[10];
int new_argc;
/* target_old_syntax
*
- * argv[0] typename (above)
- * argv[1] endian
- * argv[2] reset method, deprecated/ignored
- * argv[3] = old param
- * argv[4] = old param
+ * It appears that there are 2 old syntaxes:
+ *
+ * target <typename> <endian> <chain position> <variant>
+ *
+ * and
*
- * We will combine all "old params" into a single param.
- * Then later, split them again.
+ * target <typename> <endian> <reset mode> <chain position> <variant>
+ *
+ * The following uses the number of arguments to switch between them.
*/
- if( argc < 4 ){
- Jim_WrongNumArgs( interp, 1, argv, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?RESET? ?old-params?");
+ if( argc < 5 ){
+ Jim_WrongNumArgs( interp, 1, argv, "[OLDSYNTAX] ?TYPE? ?ENDIAN? ?CHAIN-POSITION? ?VARIANT?");
return JIM_ERR;
}
+
+ /* Use the correct argument offset for the chain position */
+ if (argc < 6) {
+ /* target <type> <endian> <chain position> <variant> */
+ chain_position_offset = 2;
+ } else {
+ chain_position_offset = 3;
+ /* target <type> <endian> <reset mode> <chain position> <variant> */
+ }
+
/* the command */
new_argv[0] = argv[0];
new_argv[1] = Jim_NewStringObj( interp, "create", -1 );
new_argv[4] = Jim_NewStringObj( interp, "-endian", -1 );
new_argv[5] = goi.argv[1];
new_argv[6] = Jim_NewStringObj( interp, "-chain-position", -1 );
- new_argv[7] = goi.argv[2];
+ new_argv[7] = goi.argv[chain_position_offset];
new_argv[8] = Jim_NewStringObj( interp, "-variant", -1 );
- new_argv[9] = goi.argv[3];
+ new_argv[9] = goi.argv[chain_position_offset + 1];
new_argc = 10;
+
/*
* new arg syntax:
* argv[0] = command
return JIM_ERR;
}
-
-
-
-/*
- * Local Variables: ***
- * c-basic-offset: 4 ***
- * tab-width: 4 ***
- * End: ***
- */
Code Review / openocd.git / blobdiff