]> git.sur5r.net Git - openocd/commitdiff
retired reset run_and_init/halt
authoroharboe <oharboe@b42882b7-edfa-0310-969c-e2dbd0fdcd60>
Mon, 28 Jul 2008 06:08:05 +0000 (06:08 +0000)
committeroharboe <oharboe@b42882b7-edfa-0310-969c-e2dbd0fdcd60>
Mon, 28 Jul 2008 06:08:05 +0000 (06:08 +0000)
git-svn-id: svn://svn.berlios.de/openocd/trunk@877 b42882b7-edfa-0310-969c-e2dbd0fdcd60

38 files changed:
doc/openocd.texi
src/target/target.c
src/target/target.h
src/target/target/at91r40008.cfg
src/target/target/at91sam9260.cfg
src/target/target/at91sam9260minimal.cfg
src/target/target/eir-sam7se512.cfg
src/target/target/hammer.cfg
src/target/target/ipx42x.cfg
src/target/target/lpc2129.cfg
src/target/target/lpc2148.cfg
src/target/target/lpc2294.cfg
src/target/target/mx31.cfg
src/target/target/netx500.cfg
src/target/target/nslu2.cfg
src/target/target/omap5912.cfg
src/target/target/pic32mx.cfg
src/target/target/pxa255.cfg
src/target/target/pxa270.cfg
src/target/target/sam7s256.cfg
src/target/target/sam7x256.cfg
src/target/target/stm32.cfg
src/target/target/stm32stick.cfg
src/target/target/str710.cfg
src/target/target/str730.cfg
src/target/target/str750.cfg
src/target/target/str912.cfg
src/target/target/str9comstick.cfg
src/target/target/wi-9c.cfg
src/target/target/xba_revA3.cfg
testing/examples/AT91R40008Test/prj/at91r40008_turtle.cfg
testing/examples/LPC2148Test/prj/lpc2148_jtagkey.cfg
testing/examples/LPC2294Test/prj/lpc2294_jtagkey.cfg
testing/examples/SAM7S256Test/prj/sam7s256_jtagkey.cfg
testing/examples/SAM7X256Test/prj/sam7x256_jtagkey.cfg
testing/examples/STR710JtagSpeed/prj/str710_jtagkey.cfg
testing/examples/STR710Test/prj/str710_jtagkey.cfg
testing/examples/STR912Test/prj/str912_jtagkey.cfg

index 8f9ca93e41f5f86710db7379351466ce155db29e..04605f09d7a922002ea2f87654c5771ec6043716 100644 (file)
@@ -540,11 +540,6 @@ Event is one of the following:
 @option{pre_resume} or @option{gdb_program_config}.
 @option{post_reset} and @option{reset} will produce the same results.
 
-@item @b{run_and_halt_time} <@var{target#}> <@var{time_in_ms}>
-@cindex run_and_halt_time
-The amount of time the debugger should wait after releasing reset before it asserts
-a debug request. This is used by the @option{run_and_halt} and @option{run_and_init}
-reset modes. 
 @item @b{working_area} <@var{target#}> <@var{address}> <@var{size}>
 <@var{backup}|@var{nobackup}>
 @cindex working_area
@@ -795,8 +790,7 @@ OpenOCD will wait 5 seconds for the target to resume.
 @cindex step
 Single-step the target at its current code position, or at an optional address. 
 
-@item @b{reset} [@option{run}|@option{halt}|@option{init}|@option{run_and_halt}
-|@option{run_and_init}]
+@item @b{reset} [@option{run}|@option{halt}|@option{init}]
 @cindex reset
 Perform a hard-reset. The optional parameter specifies what should happen after the reset.
 
@@ -812,15 +806,7 @@ Immediately halt the target (works only with certain configurations).
 @cindex reset init
 Immediately halt the target, and execute the reset script (works only with certain
 configurations)
-@item @b{run_and_halt}
-@cindex reset run_and_halt
-Let the target run for a certain amount of time, then request a halt.
-@item @b{run_and_init}
-@cindex reset run_and_init
-Let the target run for a certain amount of time, then request a halt. Execute the
-reset script once the target enters debug mode.
 @end itemize
-The runtime can be set using the @option{run_and_halt_time} command.
 @end itemize
 
 @subsection Memory access commands
index 7c6beb0fc501d59a269f00ab3943851ce43d238d..52a4fbbae06009c87f30b8fb488aa9db7ced2e2b 100644 (file)
@@ -55,7 +55,6 @@ int cli_target_callback_event_handler(struct target_s *target, enum target_event
 int handle_target_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_run_and_halt_time_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 handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
@@ -194,8 +193,8 @@ target_t* get_target_by_num(int num)
 int get_num_by_target(target_t *query_target)
 {
        target_t *target = targets;
-       int i = 0;      
-       
+       int i = 0;
+
        while (target)
        {
                if (target == query_target)
@@ -203,48 +202,23 @@ int get_num_by_target(target_t *query_target)
                target = target->next;
                i++;
        }
-       
+
        return -1;
 }
 
 target_t* get_current_target(command_context_t *cmd_ctx)
 {
        target_t *target = get_target_by_num(cmd_ctx->current_target);
-       
+
        if (target == NULL)
        {
                LOG_ERROR("BUG: current_target out of bounds");
                exit(-1);
        }
-       
-       return target;
-}
 
-/* Process target initialization, when target entered debug out of reset
- * the handler is unregistered at the end of this function, so it's only called once
- */
-int target_init_handler(struct target_s *target, enum target_event event, void *priv)
-{
-       struct command_context_s *cmd_ctx = priv;
-       
-       if (event == TARGET_EVENT_HALTED)
-       {
-               target_unregister_event_callback(target_init_handler, priv);
-               target_invoke_script(cmd_ctx, target, "post_reset");
-               jtag_execute_queue();
-       }
-       
-       return ERROR_OK;
+       return target;
 }
 
-int target_run_and_halt_handler(void *priv)
-{
-       target_t *target = priv;
-       
-       target_halt(target);
-       
-       return ERROR_OK;
-}
 
 int target_poll(struct target_s *target)
 {
@@ -271,21 +245,21 @@ int target_halt(struct target_s *target)
 int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
 {
        int retval;
-       
+
        /* We can't poll until after examine */
        if (!target->type->examined)
        {
                LOG_ERROR("Target not examined yet");
                return ERROR_FAIL;
        }
-       
+
        /* note that resume *must* be asynchronous. The CPU can halt before we poll. The CPU can
         * even halt at the current PC as a result of a software breakpoint being inserted by (a bug?)
         * the application.
         */
        if ((retval = target->type->resume(target, current, address, handle_breakpoints, debug_execution)) != ERROR_OK)
                return retval;
-       
+
        return retval;
 }
 
@@ -301,27 +275,27 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo
                target_invoke_script(cmd_ctx, target, "pre_reset");
                target = target->next;
        }
-       
+
        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 
+
+       /* 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. 
-        * 
+        * 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. 
-        * 
+        *
+        * 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(cmd_ctx)) != ERROR_OK)
                return retval;
-       
+
        keep_alive(); /* we might be running on a very slow JTAG clk */
-               
+
        target = targets;
        while (target)
        {
@@ -338,46 +312,25 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo
                LOG_WARNING("JTAG communication failed asserting reset.");
                retval = ERROR_OK;
        }
-       
+
        /* request target halt if necessary, and schedule further action */
        target = targets;
        while (target)
        {
-               switch (reset_mode)
+               if (reset_mode!=RESET_RUN)
                {
-                       case RESET_RUN:
-                               /* nothing to do if target just wants to be run */
-                               break;
-                       case RESET_RUN_AND_HALT:
-                               /* schedule halt */
-                               target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
-                               break;
-                       case RESET_RUN_AND_INIT:
-                               /* schedule halt */
-                               target_register_timer_callback(target_run_and_halt_handler, target->run_and_halt_time, 0, target);
-                               target_register_event_callback(target_init_handler, cmd_ctx);
-                               break;
-                       case RESET_HALT:
-                               if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
-                                       target_halt(target);
-                               break;
-                       case RESET_INIT:
-                               if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
-                                       target_halt(target);
-                               target_register_event_callback(target_init_handler, cmd_ctx);
-                               break;
-                       default:
-                               LOG_ERROR("BUG: unknown target->reset_mode");
+                       if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
+                               target_halt(target);
                }
                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;              
+               retval = ERROR_OK;
        }
-       
+
        target = targets;
        while (target)
        {
@@ -389,10 +342,10 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo
                        LOG_WARNING("Failed to reset target into halted mode - issuing halt");
                        target->type->halt(target);
                }
-               
+
                target = target->next;
        }
-       
+
        if ((retval = jtag_execute_queue()) != ERROR_OK)
        {
                LOG_WARNING("JTAG communication failed while deasserting reset.");
@@ -404,64 +357,23 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo
                /* If TRST was asserted we need to set up registers again */
                if ((retval = target_examine(cmd_ctx)) != ERROR_OK)
                        return retval;
-       }               
-       
+       }
+
        LOG_DEBUG("Waiting for halted stated as appropriate");
-       
-       /* Wait for reset to complete, maximum 5 seconds. */    
-       gettimeofday(&timeout, NULL);
-       timeval_add_time(&timeout, 5, 0);
-       for(;;)
+
+       if ((reset_mode == RESET_HALT) || (reset_mode == RESET_INIT))
        {
-               gettimeofday(&now, NULL);
-               
-               target_call_timer_callbacks_now();
-               
-               target = targets;
-               while (target)
+               /* Wait for reset to complete, maximum 5 seconds. */
+               if (((retval=target_wait_state(target, TARGET_HALTED, 5000)))==ERROR_OK)
                {
-                       LOG_DEBUG("Polling target");
-                       target_poll(target);
-                       if ((reset_mode == RESET_RUN_AND_INIT) || 
-                                       (reset_mode == RESET_RUN_AND_HALT) ||
-                                       (reset_mode == RESET_HALT) ||
-                                       (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;
+                       if (reset_mode == RESET_INIT)
+                               target_invoke_script(cmd_ctx, target, "post_reset");
                }
-               /* 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);
-       
        return retval;
 }
 
@@ -486,8 +398,8 @@ static int default_examine(struct command_context_s *cmd_ctx, struct target_s *t
 
 /* Targets that correctly implement init+examine, i.e.
  * no communication with target during init:
- * 
- * XScale 
+ *
+ * XScale
  */
 int target_examine(struct command_context_s *cmd_ctx)
 {
@@ -545,7 +457,7 @@ static int target_run_algorithm_imp(struct target_s *target, int num_mem_params,
 int target_init(struct command_context_s *cmd_ctx)
 {
        target_t *target = targets;
-       
+
        while (target)
        {
                target->type->examined = 0;
@@ -553,13 +465,13 @@ int target_init(struct command_context_s *cmd_ctx)
                {
                        target->type->examine = default_examine;
                }
-               
+
                if (target->type->init_target(cmd_ctx, target) != ERROR_OK)
                {
                        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)
                {
@@ -578,44 +490,44 @@ int target_init(struct command_context_s *cmd_ctx)
                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;
        }
-       
+
        if (targets)
        {
                target_register_user_commands(cmd_ctx);
                target_register_timer_callback(handle_target, 100, 1, NULL);
        }
-               
+
        return ERROR_OK;
 }
 
 int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv)
 {
        target_event_callback_t **callbacks_p = &target_event_callbacks;
-       
+
        if (callback == NULL)
        {
                return ERROR_INVALID_ARGUMENTS;
        }
-       
+
        if (*callbacks_p)
        {
                while ((*callbacks_p)->next)
                        callbacks_p = &((*callbacks_p)->next);
                callbacks_p = &((*callbacks_p)->next);
        }
-       
+
        (*callbacks_p) = malloc(sizeof(target_event_callback_t));
        (*callbacks_p)->callback = callback;
        (*callbacks_p)->priv = priv;
        (*callbacks_p)->next = NULL;
-       
+
        return ERROR_OK;
 }
 
@@ -623,24 +535,24 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 {
        target_timer_callback_t **callbacks_p = &target_timer_callbacks;
        struct timeval now;
-       
+
        if (callback == NULL)
        {
                return ERROR_INVALID_ARGUMENTS;
        }
-       
+
        if (*callbacks_p)
        {
                while ((*callbacks_p)->next)
                        callbacks_p = &((*callbacks_p)->next);
                callbacks_p = &((*callbacks_p)->next);
        }
-       
+
        (*callbacks_p) = malloc(sizeof(target_timer_callback_t));
        (*callbacks_p)->callback = callback;
        (*callbacks_p)->periodic = periodic;
        (*callbacks_p)->time_ms = time_ms;
-       
+
        gettimeofday(&now, NULL);
        (*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
        time_ms -= (time_ms % 1000);
@@ -650,10 +562,10 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
                (*callbacks_p)->when.tv_usec = (*callbacks_p)->when.tv_usec - 1000000;
                (*callbacks_p)->when.tv_sec += 1;
        }
-       
+
        (*callbacks_p)->priv = priv;
        (*callbacks_p)->next = NULL;
-       
+
        return ERROR_OK;
 }
 
@@ -661,12 +573,12 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en
 {
        target_event_callback_t **p = &target_event_callbacks;
        target_event_callback_t *c = target_event_callbacks;
-       
+
        if (callback == NULL)
        {
                return ERROR_INVALID_ARGUMENTS;
        }
-               
+
        while (c)
        {
                target_event_callback_t *next = c->next;
@@ -680,7 +592,7 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en
                        p = &(c->next);
                c = next;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -688,12 +600,12 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 {
        target_timer_callback_t **p = &target_timer_callbacks;
        target_timer_callback_t *c = target_timer_callbacks;
-       
+
        if (callback == NULL)
        {
                return ERROR_INVALID_ARGUMENTS;
        }
-               
+
        while (c)
        {
                target_timer_callback_t *next = c->next;
@@ -707,7 +619,7 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
                        p = &(c->next);
                c = next;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -715,16 +627,16 @@ 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;
-       
+
        LOG_DEBUG("target event %i", event);
-       
+
        while (callback)
        {
                next_callback = callback->next;
                callback->callback(target, event, callback->priv);
                callback = next_callback;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -735,13 +647,13 @@ static int target_call_timer_callbacks_check_time(int checktime)
        struct timeval now;
 
        keep_alive();
-       
+
        gettimeofday(&now, NULL);
-       
+
        while (callback)
        {
                next_callback = callback->next;
-               
+
                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)))
@@ -765,10 +677,10 @@ static int target_call_timer_callbacks_check_time(int checktime)
                                        target_unregister_timer_callback(callback->callback, callback->priv);
                        }
                }
-                       
+
                callback = next_callback;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -787,7 +699,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
 {
        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)
        {
@@ -807,14 +719,14 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
                        target->working_area = target->working_area_phys;
                }
        }
-       
+
        /* only allocate multiples of 4 byte */
        if (size % 4)
        {
                LOG_ERROR("BUG: code tried to allocate unaligned number of bytes, padding");
                size = CEIL(size, 4);
        }
-       
+
        /* see if there's already a matching working area */
        while (c)
        {
@@ -825,16 +737,16 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
                }
                c = c->next;
        }
-       
+
        /* if not, allocate a new one */
        if (!new_wa)
        {
                working_area_t **p = &target->working_areas;
                u32 first_free = target->working_area;
                u32 free_size = target->working_area_size;
-               
+
                LOG_DEBUG("allocating new working area");
-               
+
                c = target->working_areas;
                while (c)
                {
@@ -843,18 +755,18 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
                        p = &c->next;
                        c = c->next;
                }
-               
+
                if (free_size < size)
                {
                        LOG_WARNING("not enough working area available(requested %d, free %d)", size, free_size);
                        return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
                }
-               
+
                new_wa = malloc(sizeof(working_area_t));
                new_wa->next = NULL;
                new_wa->size = size;
                new_wa->address = first_free;
-               
+
                if (target->backup_working_area)
                {
                        new_wa->backup = malloc(new_wa->size);
@@ -864,18 +776,18 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
                {
                        new_wa->backup = NULL;
                }
-               
+
                /* put new entry in list */
                *p = new_wa;
        }
-       
+
        /* mark as used, and return the new (reused) area */
        new_wa->free = 0;
        *area = new_wa;
-       
+
        /* user pointer */
        new_wa->user = area;
-       
+
        return ERROR_OK;
 }
 
@@ -883,16 +795,16 @@ int target_free_working_area_restore(struct target_s *target, working_area_t *ar
 {
        if (area->free)
                return ERROR_OK;
-       
+
        if (restore&&target->backup_working_area)
                target->type->write_memory(target, area->address, 4, area->size / 4, area->backup);
-       
+
        area->free = 1;
-       
+
        /* mark user pointer invalid */
        *area->user = NULL;
        area->user = NULL;
-       
+
        return ERROR_OK;
 }
 
@@ -909,30 +821,29 @@ int target_free_all_working_areas_restore(struct target_s *target, int restore)
        {
                working_area_t *next = c->next;
                target_free_working_area_restore(target, c, restore);
-               
+
                if (c->backup)
                        free(c->backup);
-               
+
                free(c);
-               
+
                c = next;
        }
-       
+
        target->working_areas = NULL;
-       
+
        return ERROR_OK;
 }
 
 int target_free_all_working_areas(struct target_s *target)
 {
-       return target_free_all_working_areas_restore(target, 1); 
+       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, "target <cpu> [reset_init default - DEPRECATED] <chainpos> <endianness> <variant> [cpu type specifc args]");
        register_command(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, NULL);
-       register_command(cmd_ctx, NULL, "run_and_halt_time", handle_run_and_halt_time_command, COMMAND_CONFIG, "<target> <run time ms>");
        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>");
@@ -952,18 +863,18 @@ int target_arch_state(struct target_s *target)
                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 
+/* 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)
@@ -976,40 +887,40 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
                LOG_ERROR("Target not examined yet");
                return ERROR_FAIL;
        }
-       
+
        if (address+size<address)
        {
                /* GDB can request this when e.g. PC is 0xfffffffc*/
                LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
                return ERROR_FAIL;
        }
-       
+
        if (((address % 2) == 0) && (size == 2))
        {
                return target->type->write_memory(target, address, 2, 1, buffer);
        }
-       
+
        /* handle unaligned head bytes */
        if (address % 4)
        {
                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;
-               
+
                buffer += unaligned;
                address += unaligned;
                size -= unaligned;
        }
-               
+
        /* handle aligned words */
        if (size >= 4)
        {
                int aligned = size - (size % 4);
-       
+
                /* use bulk writes above a certain limit. This may have to be changed */
                if (aligned > 128)
                {
@@ -1021,25 +932,25 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
                        if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
                                return retval;
                }
-               
+
                buffer += aligned;
                address += aligned;
                size -= aligned;
        }
-       
+
        /* handle tail writes of less than 4 bytes */
        if (size > 0)
        {
                if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
                        return retval;
        }
-       
+
        return ERROR_OK;
 }
 
 
-/* Single aligned words are guaranteed to use 16 or 32 bit access 
- * mode respectively, otherwise data is handled as quickly as 
+/* 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)
@@ -1052,55 +963,55 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
                LOG_ERROR("Target not examined yet");
                return ERROR_FAIL;
        }
-       
+
        if (address+size<address)
        {
                /* GDB can request this when e.g. PC is 0xfffffffc*/
                LOG_ERROR("address+size wrapped(0x%08x, 0x%08x)", address, size);
                return ERROR_FAIL;
        }
-       
+
        if (((address % 2) == 0) && (size == 2))
        {
                return target->type->read_memory(target, address, 2, 1, buffer);
        }
-       
+
        /* handle unaligned head bytes */
        if (address % 4)
        {
                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;
-               
+
                buffer += unaligned;
                address += unaligned;
                size -= unaligned;
        }
-               
+
        /* handle aligned words */
        if (size >= 4)
        {
                int aligned = size - (size % 4);
-       
+
                if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
                        return retval;
-               
+
                buffer += aligned;
                address += aligned;
                size -= aligned;
        }
-       
+
        /* handle tail writes of less than 4 bytes */
        if (size > 0)
        {
                if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
                        return retval;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -1115,7 +1026,7 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32*
                LOG_ERROR("Target not examined yet");
                return ERROR_FAIL;
        }
-       
+
        if ((retval = target->type->checksum_memory(target, address,
                size, &checksum)) == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
        {
@@ -1143,9 +1054,9 @@ int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32*
                retval = image_calculate_checksum( buffer, size, &checksum );
                free(buffer);
        }
-       
+
        *crc = checksum;
-       
+
        return retval;
 }
 
@@ -1157,12 +1068,12 @@ int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u3
                LOG_ERROR("Target not examined yet");
                return ERROR_FAIL;
        }
-       
+
        if (target->type->blank_check_memory == 0)
                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
-       
+
        retval = target->type->blank_check_memory(target, address, size, blank);
-                       
+
        return retval;
 }
 
@@ -1176,7 +1087,7 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value)
        }
 
        int retval = target->type->read_memory(target, address, 4, 1, value_buf);
-       
+
        if (retval == ERROR_OK)
        {
                *value = target_buffer_get_u32(target, value_buf);
@@ -1187,7 +1098,7 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value)
                *value = 0x0;
                LOG_DEBUG("address: 0x%8.8x failed", address);
        }
-       
+
        return retval;
 }
 
@@ -1201,7 +1112,7 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value)
        }
 
        int retval = target->type->read_memory(target, address, 2, 1, value_buf);
-       
+
        if (retval == ERROR_OK)
        {
                *value = target_buffer_get_u16(target, value_buf);
@@ -1212,7 +1123,7 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value)
                *value = 0x0;
                LOG_DEBUG("address: 0x%8.8x failed", address);
        }
-       
+
        return retval;
 }
 
@@ -1234,7 +1145,7 @@ int target_read_u8(struct target_s *target, u32 address, u8 *value)
                *value = 0x0;
                LOG_DEBUG("address: 0x%8.8x failed", address);
        }
-       
+
        return retval;
 }
 
@@ -1250,12 +1161,12 @@ int target_write_u32(struct target_s *target, u32 address, u32 value)
 
        LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 
-       target_buffer_set_u32(target, value_buf, value);        
+       target_buffer_set_u32(target, value_buf, value);
        if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
        {
                LOG_DEBUG("failed: %i", retval);
        }
-       
+
        return retval;
 }
 
@@ -1271,12 +1182,12 @@ int target_write_u16(struct target_s *target, u32 address, u16 value)
 
        LOG_DEBUG("address: 0x%8.8x, value: 0x%8.8x", address, value);
 
-       target_buffer_set_u16(target, value_buf, value);        
+       target_buffer_set_u16(target, value_buf, value);
        if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
        {
                LOG_DEBUG("failed: %i", retval);
        }
-       
+
        return retval;
 }
 
@@ -1295,7 +1206,7 @@ int target_write_u8(struct target_s *target, u32 address, u8 value)
        {
                LOG_DEBUG("failed: %i", retval);
        }
-       
+
        return retval;
 }
 
@@ -1307,29 +1218,29 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
        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, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init|run_and_halt|run_and_init]");
+       register_command(cmd_ctx,  NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run|halt|init]");
        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, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words <addr> [count]");
        register_command(cmd_ctx,  NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes <addr> [count]");
-       
+
        register_command(cmd_ctx,  NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word <addr> <value> [count]");
        register_command(cmd_ctx,  NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word <addr> <value> [count]");
        register_command(cmd_ctx,  NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte <addr> <value> [count]");
-       
-       register_command(cmd_ctx,  NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");      
+
+       register_command(cmd_ctx,  NULL, "bp", handle_bp_command, COMMAND_EXEC, "set breakpoint <address> <length> [hw]");
        register_command(cmd_ctx,  NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint <adress>");
-       register_command(cmd_ctx,  NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");    
+       register_command(cmd_ctx,  NULL, "wp", handle_wp_command, COMMAND_EXEC, "set watchpoint <address> <length> <r/w/a> [value] [mask]");
        register_command(cmd_ctx,  NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint <adress>");
-       
+
        register_command(cmd_ctx,  NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image <file> <address> ['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
        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);
-       
+
        return ERROR_OK;
 }
 
@@ -1337,31 +1248,31 @@ int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **
 {
        target_t *target = targets;
        int count = 0;
-       
+
        if (argc == 1)
        {
                int num = strtoul(args[0], NULL, 0);
-               
+
                while (target)
                {
                        count++;
                        target = target->next;
                }
-               
+
                if (num < count)
                        cmd_ctx->current_target = num;
                else
                        command_print(cmd_ctx, "%i is out of bounds, only %i targets are configured", num, count);
-                       
+
                return ERROR_OK;
        }
-               
+
        while (target)
        {
                command_print(cmd_ctx, "%i: %s (%s), state: %s", count++, target->type->name, target_endianess_strings[target->endianness], target_state_strings[target->state]);
                target = target->next;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -1369,12 +1280,12 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 {
        int i;
        int found = 0;
-       
+
        if (argc < 3)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
        /* search for the specified target */
        if (args[0] && (args[0][0] != 0))
        {
@@ -1383,7 +1294,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                        if (strcmp(args[0], target_types[i]->name) == 0)
                        {
                                target_t **last_target_p = &targets;
-                               
+
                                /* register target specific commands */
                                if (target_types[i]->register_commands(cmd_ctx) != ERROR_OK)
                                {
@@ -1399,11 +1310,11 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                                }
 
                                *last_target_p = malloc(sizeof(target_t));
-                               
+
                                /* allocate memory for each unique target type */
                                (*last_target_p)->type = (target_type_t*)malloc(sizeof(target_type_t));
-                               *((*last_target_p)->type) = *target_types[i]; 
-                               
+                               *((*last_target_p)->type) = *target_types[i];
+
                                if (strcmp(args[1], "big") == 0)
                                        (*last_target_p)->endianness = TARGET_BIG_ENDIAN;
                                else if (strcmp(args[1], "little") == 0)
@@ -1413,7 +1324,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                                        LOG_ERROR("endianness must be either 'little' or 'big', not '%s'", args[1]);
                                        return ERROR_COMMAND_SYNTAX_ERROR;
                                }
-                               
+
                                if (strcmp(args[2], "reset_halt") == 0)
                                {
                                        LOG_WARNING("reset_mode argument is obsolete.");
@@ -1445,13 +1356,12 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                                        args--;
                                        argc++;
                                }
-                               (*last_target_p)->run_and_halt_time = 1000; /* default 1s */
-                               
+
                                (*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)->state = TARGET_UNKNOWN;
                                (*last_target_p)->debug_reason = DBG_REASON_UNDEFINED;
                                (*last_target_p)->reg_cache = NULL;
@@ -1459,7 +1369,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                                (*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;
@@ -1469,18 +1379,18 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
                                (*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;
                                break;
                        }
                }
        }
-       
+
        /* no matching target found */
        if (!found)
        {
@@ -1493,54 +1403,34 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 
 int target_invoke_script(struct command_context_s *cmd_ctx, target_t *target, char *name)
 {
-       return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}", 
-                       get_num_by_target(target), name, 
+       return command_run_linef(cmd_ctx, " if {[catch {info body target_%d_%s} t]==0} {target_%d_%s}",
+                       get_num_by_target(target), name,
                        get_num_by_target(target), name);
 }
 
-int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
-{
-       target_t *target = NULL;
-       
-       if (argc < 2)
-       {
-               return ERROR_COMMAND_SYNTAX_ERROR;
-       }
-       
-       target = get_target_by_num(strtoul(args[0], NULL, 0));
-       if (!target)
-       {
-               return ERROR_COMMAND_SYNTAX_ERROR;
-       }
-       
-       target->run_and_halt_time = strtoul(args[1], NULL, 0);
-       
-       return ERROR_OK;
-}
-
 int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        target_t *target = NULL;
-       
+
        if ((argc < 4) || (argc > 5))
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
        target = get_target_by_num(strtoul(args[0], NULL, 0));
        if (!target)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        target_free_all_working_areas(target);
-       
+
        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)
        {
                target->backup_working_area = 1;
@@ -1554,7 +1444,7 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
                LOG_ERROR("unrecognized <backup|nobackup> argument (%s)", args[3]);
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -1563,7 +1453,7 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
 int handle_target(void *priv)
 {
        target_t *target = targets;
-       
+
        while (target)
        {
                if (target_continous_poll)
@@ -1571,10 +1461,10 @@ int handle_target(void *priv)
                        /* polling may fail silently until the target has been examined */
                        target_poll(target);
                }
-       
+
                target = target->next;
        }
-       
+
        return ERROR_OK;
 }
 
@@ -1584,16 +1474,16 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
        reg_t *reg = NULL;
        int count = 0;
        char *value;
-       
+
        LOG_DEBUG("-");
-       
+
        target = get_current_target(cmd_ctx);
-       
+
        /* list all available registers for the current target */
        if (argc == 0)
        {
                reg_cache_t *cache = target->reg_cache;
-               
+
                count = 0;
                while(cache)
                {
@@ -1606,16 +1496,16 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                        }
                        cache = cache->next;
                }
-               
+
                return ERROR_OK;
        }
-       
+
        /* access a single register by its ordinal number */
        if ((args[0][0] >= '0') && (args[0][0] <= '9'))
        {
                int num = strtoul(args[0], NULL, 0);
                reg_cache_t *cache = target->reg_cache;
-               
+
                count = 0;
                while(cache)
                {
@@ -1632,7 +1522,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                                break;
                        cache = cache->next;
                }
-               
+
                if (!reg)
                {
                        command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
@@ -1641,7 +1531,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
        } else /* access a single register by its name */
        {
                reg = register_get_by_name(target->reg_cache, args[0], 1);
-               
+
                if (!reg)
                {
                        command_print(cmd_ctx, "register %s not found in current target", args[0]);
@@ -1654,7 +1544,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
        {
                if ((argc == 2) && (strcmp(args[1], "force") == 0))
                        reg->valid = 0;
-               
+
                if (reg->valid == 0)
                {
                        reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
@@ -1670,7 +1560,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                free(value);
                return ERROR_OK;
        }
-       
+
        /* set register value */
        if (argc == 2)
        {
@@ -1683,20 +1573,20 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                        LOG_ERROR("BUG: encountered unregistered arch type");
                        return ERROR_OK;
                }
-               
+
                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;
        }
-       
+
        command_print(cmd_ctx, "usage: reg <#|name> [value]");
-       
+
        return ERROR_OK;
 }
 
@@ -1725,15 +1615,15 @@ int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
                        command_print(cmd_ctx, "arg is \"on\" or \"off\"");
                }
        }
-       
-       
+
+
        return ERROR_OK;
 }
 
 int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        int ms = 5000;
-       
+
        if (argc > 0)
        {
                char *end;
@@ -1747,7 +1637,7 @@ int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char
        }
        target_t *target = get_current_target(cmd_ctx);
 
-       return target_wait_state(target, TARGET_HALTED, ms); 
+       return target_wait_state(target, TARGET_HALTED, ms);
 }
 
 int target_wait_state(target_t *target, enum target_state state, int ms)
@@ -1757,7 +1647,7 @@ int target_wait_state(target_t *target, enum target_state state, int ms)
        int once=1;
        gettimeofday(&timeout, NULL);
        timeval_add_time(&timeout, 0, ms * 1000);
-       
+
        for (;;)
        {
                if ((retval=target_poll(target))!=ERROR_OK)
@@ -1772,15 +1662,15 @@ int target_wait_state(target_t *target, enum target_state state, int ms)
                        once=0;
                        LOG_USER("waiting for target %s...", target_state_strings[state]);
                }
-               
+
                gettimeofday(&now, NULL);
                if ((now.tv_sec > timeout.tv_sec) || ((now.tv_sec == timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
                {
                        LOG_ERROR("timed out while waiting for target %s", target_state_strings[state]);
-                       break;
+                       return ERROR_FAIL;
                }
        }
-       
+
        return ERROR_OK;
 }
 
@@ -1795,18 +1685,18 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
        {
                return retval;
        }
-       
+
        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);
-       
+
        LOG_USER("requesting target halt and executing a soft reset");
-       
+
        target->type->soft_reset_halt(target);
-       
+
        return ERROR_OK;
 }
 
@@ -1814,9 +1704,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;
-       
-       LOG_DEBUG("-");
-       
+
        if (argc >= 1)
        {
                if (strcmp("run", args[0]) == 0)
@@ -1825,32 +1713,15 @@ int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **ar
                        reset_mode = RESET_HALT;
                else if (strcmp("init", args[0]) == 0)
                        reset_mode = RESET_INIT;
-               else if (strcmp("run_and_halt", args[0]) == 0)
-               {
-                       reset_mode = RESET_RUN_AND_HALT;
-                       if (argc >= 2)
-                       {
-                               target->run_and_halt_time = strtoul(args[1], NULL, 0);
-                       }
-               }
-               else if (strcmp("run_and_init", args[0]) == 0)
-               {
-                       reset_mode = RESET_RUN_AND_INIT;
-                       if (argc >= 2)
-                       {
-                               target->run_and_halt_time = strtoul(args[1], NULL, 0);
-                       }
-               }
                else
                {
-                       command_print(cmd_ctx, "usage: reset ['run', 'halt', 'init', 'run_and_halt', 'run_and_init]");
-                       return ERROR_OK;
+                       return ERROR_COMMAND_SYNTAX_ERROR;
                }
        }
-       
+
        /* reset *all* targets */
        target_process_reset(cmd_ctx, reset_mode);
-       
+
        return ERROR_OK;
 }
 
@@ -1858,9 +1729,9 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a
 {
        int retval;
        target_t *target = get_current_target(cmd_ctx);
-       
+
        target_invoke_script(cmd_ctx, target, "pre_resume");
-       
+
        if (argc == 0)
                retval = target_resume(target, 1, 0, 1, 0); /* current pc, addr = 0, handle breakpoints, not debugging */
        else if (argc == 1)
@@ -1869,22 +1740,22 @@ int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **a
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
        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);
-       
+
        LOG_DEBUG("-");
-       
+
        if (argc == 0)
                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 ERROR_OK;
 }
 
@@ -1912,7 +1783,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                count = strtoul(args[1], NULL, 0);
 
        address = strtoul(args[0], NULL, 0);
-       
+
 
        switch (cmd[2])
        {
@@ -1934,12 +1805,12 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        if (retval == ERROR_OK)
        {
                output_len = 0;
-       
+
                for (i = 0; i < count; i++)
                {
                        if (i%line_modulo == 0)
                                output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
-                       
+
                        switch (size)
                        {
                                case 4:
@@ -1952,7 +1823,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                                        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);
@@ -1962,7 +1833,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        }
 
        free(buffer);
-       
+
        return retval;
 }
 
@@ -1983,7 +1854,7 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        value = strtoul(args[1], NULL, 0);
        if (argc == 3)
                count = strtoul(args[2], NULL, 0);
-       
+
        switch (cmd[2])
        {
                case 'w':
@@ -2038,18 +1909,18 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
        int i;
        int retval;
 
-       image_t image;  
-       
+       image_t image;
+
        duration_t duration;
        char *duration_text;
-       
+
        target_t *target = get_current_target(cmd_ctx);
 
        if ((argc < 1)||(argc > 5))
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
        /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
        if (argc >= 2)
        {
@@ -2060,10 +1931,10 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
        {
                image.base_address_set = 0;
        }
-       
-       
+
+
        image.start_address_set = 0;
-       
+
        if (argc>=4)
        {
                min_address=strtoul(args[3], NULL, 0);
@@ -2072,20 +1943,20 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
        {
                max_address=strtoul(args[4], NULL, 0)+min_address;
        }
-       
+
        if (min_address>max_address)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       
+
 
        duration_start_measure(&duration);
-       
+
        if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
        {
                return ERROR_OK;
        }
-       
+
        image_size = 0x0;
        retval = ERROR_OK;
        for (i = 0; i < image.num_sections; i++)
@@ -2096,19 +1967,19 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                        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;
                }
-               
+
                u32 offset=0;
                u32 length=buf_cnt;
-               
-               
+
+
                /* DANGER!!! beware of unsigned comparision here!!! */
-               
+
                if ((image.sections[i].base_address+buf_cnt>=min_address)&&
                                (image.sections[i].base_address<max_address))
                {
@@ -2118,12 +1989,12 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                                offset+=min_address-image.sections[i].base_address;
                                length-=offset;
                        }
-                       
+
                        if (image.sections[i].base_address+buf_cnt>max_address)
                        {
                                length-=(image.sections[i].base_address+buf_cnt)-max_address;
                        }
-                       
+
                        if ((retval = target_write_buffer(target, image.sections[i].base_address+offset, length, buffer+offset)) != ERROR_OK)
                        {
                                free(buffer);
@@ -2132,7 +2003,7 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                        image_size += length;
                        command_print(cmd_ctx, "%u byte written at address 0x%8.8x", length, image.sections[i].base_address+offset);
                }
-               
+
                free(buffer);
        }
 
@@ -2142,7 +2013,7 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                command_print(cmd_ctx, "downloaded %u byte in %s", image_size, duration_text);
        }
        free(duration_text);
-       
+
        image_close(&image);
 
        return retval;
@@ -2152,15 +2023,15 @@ int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char
 int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        fileio_t fileio;
-       
+
        u32 address;
        u32 size;
        u8 buffer[560];
        int retval=ERROR_OK;
-       
+
        duration_t duration;
        char *duration_text;
-       
+
        target_t *target = get_current_target(cmd_ctx);
 
        if (argc != 3)
@@ -2177,31 +2048,31 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                command_print(cmd_ctx, "only 32-bit aligned address and size are supported");
                return ERROR_OK;
        }
-       
+
        if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
        {
                return ERROR_OK;
        }
-       
+
        duration_start_measure(&duration);
-       
+
        while (size > 0)
        {
                u32 size_written;
                u32 this_run_size = (size > 560) ? 560 : size;
-               
+
                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;
        }
@@ -2214,7 +2085,7 @@ int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char
                command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text);
        }
        free(duration_text);
-       
+
        return ERROR_OK;
 }
 
@@ -2228,26 +2099,26 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
        u32 checksum = 0;
        u32 mem_checksum = 0;
 
-       image_t image;  
-       
+       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;
@@ -2265,7 +2136,7 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
        {
                return retval;
        }
-       
+
        image_size = 0x0;
        retval=ERROR_OK;
        for (i = 0; i < image.num_sections; i++)
@@ -2281,26 +2152,26 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
                        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;
@@ -2325,23 +2196,23 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
                                        }
                                }
                        }
-                       
+
                        free(data);
                }
-               
+
                free(buffer);
                image_size += buf_cnt;
        }
-done:  
+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;
 }
 
@@ -2375,7 +2246,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                u32 length = 0;
 
                length = strtoul(args[1], NULL, 0);
-               
+
                if (argc >= 3)
                        if (strcmp(args[2], "hw") == 0)
                                hw = BKPT_HARD;
@@ -2421,13 +2292,13 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                        command_print(cmd_ctx, "address: 0x%8.8x, len: 0x%8.8x, r/w/a: %i, value: 0x%8.8x, mask: 0x%8.8x", watchpoint->address, watchpoint->length, watchpoint->rw, watchpoint->value, watchpoint->mask);
                        watchpoint = watchpoint->next;
                }
-       } 
+       }
        else if (argc >= 2)
        {
                enum watchpoint_rw type = WPT_ACCESS;
                u32 data_value = 0x0;
                u32 data_mask = 0xffffffff;
-               
+
                if (argc >= 3)
                {
                        switch(args[2][0])
@@ -2454,7 +2325,7 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                {
                        data_mask = strtoul(args[4], NULL, 0);
                }
-               
+
                if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
                                strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
                {
@@ -2465,7 +2336,7 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        {
                command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
        }
-               
+
        return ERROR_OK;
 }
 
@@ -2475,7 +2346,7 @@ int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args
 
        if (argc > 0)
                watchpoint_remove(target, strtoul(args[0], NULL, 0));
-       
+
        return ERROR_OK;
 }
 
@@ -2499,8 +2370,8 @@ int handle_virt2phys_command(command_context_t *cmd_ctx, char *cmd, char **args,
        }
        else
        {
-               /* lower levels will have logged a detailed error which is 
-                * forwarded to telnet/GDB session.  
+               /* lower levels will have logged a detailed error which is
+                * forwarded to telnet/GDB session.
                 */
        }
        return retval;
@@ -2511,13 +2382,13 @@ static void writeLong(FILE *f, int l)
        for (i=0; i<4; i++)
        {
                char c=(l>>(i*8))&0xff;
-               fwrite(&c, 1, 1, f); 
+               fwrite(&c, 1, 1, f);
        }
-       
+
 }
 static void writeString(FILE *f, char *s)
 {
-       fwrite(s, 1, strlen(s), f); 
+       fwrite(s, 1, strlen(s), f);
 }
 
 
@@ -2534,8 +2405,8 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
        writeLong(f, 0); // padding
        writeLong(f, 0); // padding
        writeLong(f, 0); // padding
-                               
-       fwrite("", 1, 1, f);  // GMON_TAG_TIME_HIST 
+
+       fwrite("", 1, 1, f);  // GMON_TAG_TIME_HIST
 
        // figure out bucket size
        u32 min=samples[0];
@@ -2553,12 +2424,12 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
        }
 
        int addressSpace=(max-min+1);
-       
+
        static int const maxBuckets=256*1024; // maximum buckets.
        int length=addressSpace;
        if (length > maxBuckets)
        {
-               length=maxBuckets; 
+               length=maxBuckets;
        }
        int *buckets=malloc(sizeof(int)*length);
        if (buckets==NULL)
@@ -2573,10 +2444,10 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
                long long a=address-min;
                long long b=length-1;
                long long c=addressSpace-1;
-               int index=(a*b)/c; // danger!!!! int32 overflows 
+               int index=(a*b)/c; // danger!!!! int32 overflows
                buckets[index]++;
        }
-       
+
        //                         append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr))
        writeLong(f, min);                                      // low_pc
        writeLong(f, max);              // high_pc
@@ -2588,9 +2459,9 @@ static void writeGmon(u32 *samples, int sampleNum, char *filename)
                fwrite("", 1, 1, f);  // padding
        }
        writeString(f, "s");
-               
+
 //                        append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size)
-       
+
        char *data=malloc(2*length);
        if (data!=NULL)
        {
@@ -2621,7 +2492,7 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **
 {
        target_t *target = get_current_target(cmd_ctx);
        struct timeval timeout, now;
-       
+
        gettimeofday(&timeout, NULL);
        if (argc!=2)
        {
@@ -2629,23 +2500,23 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **
        }
        char *end;
        timeval_add_time(&timeout, strtoul(args[0], &end, 0), 0);
-       if (*end) 
+       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);
@@ -2670,7 +2541,7 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **
                {
                        break;
                }
-               
+
                gettimeofday(&now, NULL);
                if ((numSamples>=maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
                {
@@ -2687,7 +2558,7 @@ int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **
                }
        }
        free(samples);
-       
+
        return ERROR_OK;
 }
 
@@ -2700,7 +2571,7 @@ static int new_int_array_element(Jim_Interp * interp, const char *varname, int i
        namebuf = alloc_printf("%s(%d)", varname, idx);
        if (!namebuf)
                return JIM_ERR;
-       
+
        nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
        valObjPtr = Jim_NewIntObj(interp, val);
        if (!nameObjPtr || !valObjPtr)
@@ -2735,7 +2606,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
        /* argv[1] = name of array to receive the data
         * argv[2] = desired width
-        * argv[3] = memory address 
+        * argv[3] = memory address
         * argv[4] = count of times to read
         */
        if (argc != 5) {
@@ -2750,7 +2621,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        if (e != JIM_OK) {
                return e;
        }
-       
+
        e = Jim_GetLong(interp, argv[3], &l);
        addr = l;
        if (e != JIM_OK) {
@@ -2791,8 +2662,8 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
                Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
                return JIM_ERR;
-       }               
-               
+       }
+
        if ((width == 1) ||
                ((width == 2) && ((addr & 1) == 0)) ||
                ((width == 4) && ((addr & 3) == 0))) {
@@ -2800,7 +2671,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        } else {
                char buf[100];
                Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-               sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width); 
+               sprintf(buf, "mem2array address: 0x%08x is not aligned for %d byte reads", addr, width);
                Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
                return JIM_ERR;
        }
@@ -2817,7 +2688,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                LOG_ERROR("mem2array: no current target");
                return JIM_ERR;
        }
-       
+
        /* Transfer loop */
 
        /* index counter */
@@ -2826,12 +2697,12 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        e = JIM_OK;
        while (len) {
                /* Slurp... in buffer size chunks */
-               
+
                count = len; /* in objects.. */
                if (count > (sizeof(buffer)/width)) {
                        count = (sizeof(buffer)/width);
                }
-               
+
                retval = target->type->read_memory( target, addr, width, count, buffer );
                if (retval != ERROR_OK) {
                        /* BOO !*/
@@ -2859,7 +2730,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                        len -= count;
                }
        }
-       
+
        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
 
        return JIM_OK;
@@ -2912,7 +2783,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
        /* argv[1] = name of array to get the data
         * argv[2] = desired width
-        * argv[3] = memory address 
+        * argv[3] = memory address
         * argv[4] = count to write
         */
        if (argc != 5) {
@@ -2927,7 +2798,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        if (e != JIM_OK) {
                return e;
        }
-       
+
        e = Jim_GetLong(interp, argv[3], &l);
        addr = l;
        if (e != JIM_OK) {
@@ -2968,8 +2839,8 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
                Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL);
                return JIM_ERR;
-       }               
-               
+       }
+
        if ((width == 1) ||
                ((width == 2) && ((addr & 1) == 0)) ||
                ((width == 4) && ((addr & 3) == 0))) {
@@ -2977,7 +2848,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        } else {
                char buf[100];
                Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
-               sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width); 
+               sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width);
                Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL);
                return JIM_ERR;
        }
@@ -2994,7 +2865,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                LOG_ERROR("array2mem: no current target");
                return JIM_ERR;
        }
-       
+
        /* Transfer loop */
 
        /* index counter */
@@ -3003,7 +2874,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        e = JIM_OK;
        while (len) {
                /* Slurp... in buffer size chunks */
-               
+
                count = len; /* in objects.. */
                if (count > (sizeof(buffer)/width)) {
                        count = (sizeof(buffer)/width);
@@ -3036,7 +2907,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                        len = 0;
                }
        }
-       
+
        Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
 
        return JIM_OK;
index 51a9dfc497cc2373cd34c2a1bc8db3701dc220ad..5d1e5773ce7d961a8613222422a20f68a1943efe 100644 (file)
@@ -62,8 +62,6 @@ enum target_reset_mode
        RESET_RUN = 0,          /* reset and let target run */
        RESET_HALT = 1,         /* reset and halt target out of reset */
        RESET_INIT = 2,         /* reset and halt target out of reset, then run init script */
-       RESET_RUN_AND_HALT = 3, /* reset and let target run, halt after n milliseconds */
-       RESET_RUN_AND_INIT = 4, /* reset and let target run, halt after n milliseconds, then run init script */
 };
 
 enum target_debug_reason
@@ -202,7 +200,6 @@ typedef struct target_s
 {
        target_type_t *type;                            /* target type definition (name, access functions) */
        int reset_halt;                                         /* attempt resetting the CPU into the halted mode? */
-       int run_and_halt_time;                          /* how long the target should run after a run_and_halt reset */
        u32 working_area;                                       /* working area (initialized RAM). Evaluated 
                                                                                   upon first allocation from virtual/physical address. */
        u32 working_area_virt;                          /* virtual address */
index 54c99006cf20bd88aa456916e38a0db5c5aa7435..efcbd1c0ea637faa46b7078fee2370d806c18981 100644 (file)
@@ -11,7 +11,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/at91r40008_reset.script
 
index 41d7b1ffd9daf3f268d809eaf7c7ce22de94e4b1..21f92d79524f3522b0e4c598189357f0f40dbbd5 100644 (file)
@@ -18,7 +18,7 @@ jtag_ntrst_delay 0
 target arm926ejs little 0 arm926ejs
 
 target_script 0 reset event/at91sam9260_reset.script
-run_and_halt_time 0 30
+
 
 #working area <target#> <address> <size> <backup|nobackup>
 working_area 0 0x00300000 0x1000 backup
index 9b06f143627a2e949f6d44abac74c79a9a4cb75a..70e887498ccda0bea72ff9dc8bbe97652123a2c9 100644 (file)
@@ -16,5 +16,5 @@ jtag_ntrst_delay 200
 
 #target <type> <endianess> <reset mode> <JTAG pos> <variant>
 target arm926ejs little 0 arm926ejs
-run_and_halt_time 0 30
+
 
index 52ba9e456e9f492e751abf00f43b618ab18b669e..c33b42984d3e71752b8c4566c239c0170cbe48f8 100644 (file)
@@ -6,7 +6,7 @@ reset_config srst_only srst_pulls_trst
 jtag_device 4 0x1 0xf 0xe
 
 target arm7tdmi little 0 arm7tdmi
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/eir-sam7se512_reset.script
 
index 8e450cfc0d8d38570d3f50bf2144c1b871fad7a9..9daef590cdcb1707623ac914ebc2d79b2cf0e5ba 100644 (file)
@@ -18,7 +18,7 @@ arm7_9 dcc_downloads enable
 target_script 0 reset event/hammer_reset.script
 
 working_area 0 0x30800000 0x20000 nobackup
-run_and_halt_time 0 1000
+
 
 #flash configuration
 #flash bank <driver> <base> <size> <chip_width> <bus_width> [driver_options ...]
index c1518b17025f20b02e7adf11502540fdff6358c7..9445992ccc4df580d9c67b60e6c13c9841fc7ca3 100644 (file)
@@ -6,4 +6,4 @@ reset_config srst_only srst_pulls_trst
 #format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE)
 jtag_device 7 0x1 0x7f 0x7e
 target xscale big 0 IXP42x
-run_and_halt_time 0 30
+
index 8294a8e5a366837a237f52230e8d66a40cd83617..b9a33089d72833356faedabbe65166288cef2763 100644 (file)
@@ -5,7 +5,7 @@ reset_config trst_and_srst srst_pulls_trst
 #format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE)
 jtag_device 4 0x1 0xf 0xe
 target arm7tdmi little 0 arm7tdmi-s_r4
-run_and_halt_time 0 30
+
 working_area 0 0x40000000 0x4000 nobackup
 #flash bank <driver> <base> <size> <chip_width> <bus_width>
 flash bank lpc2000 0x0 0x40000 0 0 0 lpc2000_v1 14765 calc_checksum
index e30a3c8558f77e957ae82dc89d096fd17854766a..64e65b12679b91b34463a65ce179d02e56cd9679 100644 (file)
@@ -16,7 +16,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi-s_r4
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/lpc2148_reset.script
 
index bc365523d9e1a680aa1e7cdaf75f60dddf7d2de3..4a2adcbcbea6fbf21671649e1209285ed53afdac 100644 (file)
@@ -8,7 +8,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi-s_r4
-run_and_halt_time 0 30
+
 
 working_area 0 0x40000000 0x4000 nobackup
 
index 71d249d2e71bf9f7b91977481294248504500a6b..71dd5e59e91df88d68cea6e80d5831bda43a123c 100644 (file)
@@ -12,5 +12,5 @@ jtag_device 5 0x1 0x0 0x1e
 
 #target <type> <endianess> <reset mode>
 target arm11 little 1
-run_and_halt_time 0 0
+
 
index 84c24b9caf26de83f23ec74d95208f826bc85216..21a0e10c4244b9747986ac28c02bf18e77eeb43d 100644 (file)
@@ -7,4 +7,4 @@ jtag_device 4 0x1 0xf 0xe
 jtag_nsrst_delay 100
 jtag_ntrst_delay 100
 target arm926ejs little 0 arm926ejs
-run_and_halt_time 0 500
+
index 7f8ea2814fe4bdeaaedb8f23b03f1b4fb9ef948b..53907bc5e0c1228377650d9073cfd96cb9955b95 100644 (file)
@@ -7,7 +7,7 @@ jtag_device 7 0x1 0x7f 0x7e
 
 # target configuration
 target xscale big 0 ixp42x
-run_and_halt_time 0 30
+
 
 # maps to PXA internal RAM.  If you are using a PXA255
 # you must initialize SDRAM or leave this option off
index c7fd65099f90741ad4b6b6d2360132e32b694a1c..3a8f4154b4a2e36458a625ac1717c48091447e2b 100644 (file)
@@ -12,7 +12,7 @@ jtag_device 8  0x0 0x0 0x0
 
 target arm926ejs little 1 arm926ejs
 target_script 0 reset event/omap5912_reset.script
-run_and_halt_time 0 30
+
 
 # omap5912 lcd frame buffer as working area
 working_area 0 0x20000000 0x3e800 nobackup
index 25ef0294cbd5300e82ed96c28b56a2a593dc70c7..6ebf882e0a4721c241e4c24d03041a16c50e592a 100644 (file)
@@ -11,7 +11,7 @@ jtag_device 5 0x1 0x1 0x1e
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target mips_m4k little 0
-run_and_halt_time 0 30
+
 
 working_area 0 0xa0000000 16384 nobackup
 
index 50d0bafc1e072876a1a7f3c035cb59b4c10d4329..b712cf37131bb475f7d996e94183897fc7f98da3 100644 (file)
@@ -3,7 +3,7 @@ jtag_nsrst_delay 200
 jtag_ntrst_delay 200
 target xscale little 0 pxa255
 reset_config trst_and_srst
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/pxa255_reset.script
 
index deb31dd8db42aa9b12ec503ae8bff773bc8bcead..5818dc2d1cf2c922a2875239954085c937f54549 100644 (file)
@@ -14,7 +14,7 @@ target xscale little 0 pxa27x
 # maps to PXA internal RAM. If you are using a PXA255
 # you must initialize SDRAM or leave this option off
 working_area 0 0x5c000000 0x10000 nobackup
-run_and_halt_time 0 30
+
 #flash bank <driver> <base> <size> <chip_width> <bus_width>
 # works for P30 flash
 flash bank cfi 0x00000000 0x1000000 2 4 0
index 2be0ec5279eb116812c1cb8c614897b631abfd49..e96c4f13753f8d9ad9da1b2861b5be44ea876d0d 100644 (file)
@@ -8,7 +8,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/sam7s256_reset.script
 
index fa332ce801be471f6af4939bb8a44f2467fe9928..1d61b4ccf9609986646c5287bf3dcc6880315c6a 100644 (file)
@@ -8,7 +8,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi
-run_and_halt_time 0 30
+
 
 target_script 0 reset event/sam7x256_reset.script
 
index 8bdfdff0670064f373b2c38dd2dc3a29ea8bdbb4..0b97278a62329b6aab9280ec37612013d95cddf7 100644 (file)
@@ -17,7 +17,7 @@ jtag_device 5 0x1 0x1 0x1e
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target cortex_m3 little 0
-run_and_halt_time 0 30
+
 
 working_area 0 0x20000000 16384 nobackup
 
index 745c62347359c6bb8197f5d839a910bcb813b99c..3f224a738deefdd842a85061ff925b82cf78bfd2 100644 (file)
@@ -18,7 +18,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target cortex_m3 little 0
-run_and_halt_time 0 30
+
 
 working_area 0 0x20000000 16384 nobackup
 
index 8eb8775db226b2f3905249ca411bf05eed9b9adf..b765fa76c319120e7ea6e315b208d6865152b939 100644 (file)
@@ -17,7 +17,7 @@ jtag_device 4 0x1 0xf 0xe
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi
-run_and_halt_time 0 30
+
 
 target_script 0 gdb_program_config event/str710_program.script
 
index 491a3a596adc52b96016619aa4d4700c1271eba5..837dbcf40fa82ea052d8727331a09cf1e6b1ca8b 100644 (file)
@@ -24,7 +24,7 @@ jtag_ntrst_delay 500
 
 target arm7tdmi little 0 arm7tdmi
 
-run_and_halt_time 0 30
+
 
 target_script 0 gdb_program_config event/str730_program.script
 
index d00eae092b84bb9cd7b51fc30727ee43942b6804..8572e1bd71080f30921012cfafa119af7932b7ff 100644 (file)
@@ -25,7 +25,7 @@ jtag_ntrst_delay 500
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm7tdmi little 0 arm7tdmi
 
-run_and_halt_time 0 30
+
 
 target_script 0 gdb_program_config event/str750_program.script
 
index 14bb4973cad140ff184f0d7a54004aea0299e58d..c9bef81bc4948149dad66382ceb46e1de7fe689a 100644 (file)
@@ -37,7 +37,7 @@ jtag_device 5 0x1 0x1 0x1e
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
 target arm966e little 1 arm966e
-run_and_halt_time 0 30
+
 
 
 working_area 0 0x50000000 16384 nobackup
index b601a6534b1082a3ed0ad505b2c668e29d1a4a91..f9dbe01c5c1af18e5d135fed23d01f8e521daa64 100644 (file)
@@ -13,7 +13,7 @@ jtag_device 8 0x1 0x1 0xfe
 jtag_device 4 0x1 0xf 0xe
 jtag_device 5 0x1 0x1 0x1e
 target arm966e little 1 arm966e
-run_and_halt_time 0 30
+
 working_area 0 0x50000000 16384 nobackup
 #flash bank <driver> <base> <size> <chip_width> <bus_width>
 flash bank str9x 0x00000000 0x00080000 0 0 0
index 02a109323b74bd01b5ad8618187086956f40b5a9..eccb8fa456665698098109337c426a058baa940d 100644 (file)
@@ -18,7 +18,7 @@ jtag_ntrst_delay 0
 target arm926ejs big 0 arm926ejs
 
 target_script 0 reset event/wi-9c_reset.script
-run_and_halt_time 0 30
+
 
 #working area <target#> <address> <size> <backup|nobackup>
 working_area 0 0x00000000 0x1000 backup
index 7741b0f69d6ab58572909f24ab0f9dee1ca12297..c65f7350df426d7049531d0d2e693dc45c6f30c9 100644 (file)
@@ -12,7 +12,6 @@ jtag_device 7 0x1 0x7f 0x7e
 target  xscale big           0          ixp42x
 target_script 0 reset event/xba_revA3.script
 
-run_and_halt_time 0 100
 
 flash bank cfi 0x50000000 0x400000 2 2 0
 working_area 0 0x20010000 0x8060 nobackup
index 807564c531708bd83cf54cf4e51ddcda674ec072..1f101a88e1bf2f61b7ed899d7e89e9a4fe7d43d0 100644 (file)
@@ -28,8 +28,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_init 0 arm7tdmi
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi
 
 target_script 0 reset .\prj\at91r40008_reset.script
 
index 842687f3e416e44de701ebd72b712b1e628decc6..c24a2517caa0dac930a632d08abea230932ea55c 100644 (file)
@@ -26,8 +26,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_halt 0 arm7tdmi-s_r4
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi-s_r4
 
 working_area 0 0x40000000 0x4000 nobackup
 
index 1afbf1e943723b723802aff68ae028eb04e65f51..d2dfd45f9bf55d60ce9788335cf6eee39a76236d 100644 (file)
@@ -26,8 +26,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_halt 0 arm7tdmi-s_r4
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi-s_r4
 
 working_area 0 0x40000000 0x4000 nobackup
 
index d526dd2492f65f1f42d7abb5fb6b78ee16d7c2b9..634b5026ce9bf7357ce79744d3d52ac2b9c60c56 100644 (file)
@@ -29,8 +29,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_init 0 arm7tdmi
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi
 
 target_script 0 reset .\prj\sam7s256_reset.script
 
index 5dde1d75f6ca654f3781b852ae66cdefca86f65d..978512d4b023244f6b8a53381277e44a7257419b 100644 (file)
@@ -29,8 +29,7 @@ daemon_startup reset
 \r
 #target <type> <startup mode>\r
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>\r
-target arm7tdmi little run_and_init 0 arm7tdmi\r
-run_and_halt_time 0 30\r
+target arm7tdmi little 0 arm7tdmi\r
 \r
 target_script 0 reset .\prj\sam7x256_reset.script\r
 \r
index a20cabeef88a8cdcd265af4af01b6fb0d8cd0f1f..79ce94b1042f77bf8220c4f99dbdf45badfb2a46 100644 (file)
@@ -26,8 +26,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_halt 0 arm7tdmi
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi
 
 working_area 0 0x2000C000 0x4000 nobackup
 
index 62d67ddf06a1dcef787c556d6eac0fc1b4a29af6..ed98ca19b0ebfa939d3348ea05f14ff98200000e 100644 (file)
@@ -26,8 +26,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm7tdmi little run_and_halt 0 arm7tdmi
-run_and_halt_time 0 30
+target arm7tdmi little 0 arm7tdmi
 
 target_script 0 gdb_program_config .\prj\str710_program.script
 
index 614e04220236b35c99f178f4ce7f26b8415584da..57488033309b652efc9c612f0331e638167dfbb7 100644 (file)
@@ -31,8 +31,7 @@ daemon_startup reset
 
 #target <type> <startup mode>
 #target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
-target arm966e little reset_halt 1 arm966e
-run_and_halt_time 0 30
+target arm966e little 1 arm966e
 
 target_script 0 gdb_program_config .\prj\str912_program.script