- adds two speeds to jtag_speed. reset and post reset speed. Default
authoroharboe <oharboe@b42882b7-edfa-0310-969c-e2dbd0fdcd60>
Thu, 13 Mar 2008 10:14:41 +0000 (10:14 +0000)
committeroharboe <oharboe@b42882b7-edfa-0310-969c-e2dbd0fdcd60>
Thu, 13 Mar 2008 10:14:41 +0000 (10:14 +0000)
is post reset = reset speed.
- removed infinite loop's and exit()'s upon poor arm7/9 communication
- cleaned up error messages a bit. Push ERROR() up into fn's that
  fail and can say something meaningful about what failed.

git-svn-id: svn://svn.berlios.de/openocd/trunk@511 b42882b7-edfa-0310-969c-e2dbd0fdcd60

src/jtag/jtag.c
src/jtag/jtag.h
src/server/gdb_server.c
src/target/arm7_9_common.c
src/target/target.c
src/target/target.h

index 2503a16..c2db331 100644 (file)
@@ -218,6 +218,7 @@ jtag_interface_t *jtag = NULL;
 /* configuration */
 jtag_interface_t *jtag_interface = NULL;
 int jtag_speed = 0;
+int jtag_speed_post_reset = 0;
 
 
 /* forward declarations */
@@ -1407,7 +1408,7 @@ int jtag_register_commands(struct command_context_s *cmd_ctx)
        register_command(cmd_ctx, NULL, "interface", handle_interface_command,
                COMMAND_CONFIG, NULL);
        register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
-               COMMAND_ANY, "set jtag speed (if supported) <speed>");
+               COMMAND_ANY, "set jtag speed (if supported) <reset speed> [<post reset speed, default value is reset speed>]");
        register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
                COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
        register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
@@ -1695,17 +1696,19 @@ int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd
 
 int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-       if (argc == 0)
-               command_print(cmd_ctx, "jtag_speed: %i", jtag_speed);
+       int cur_speed = 0;
+       if ((argc<1) || (argc>2))
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
-       if (argc > 0)
-       {
-               jtag_speed = strtoul(args[0], NULL, 0);
-               /* this command can be called during CONFIG, 
-                * in which case jtag isn't initialized */
-               if (jtag)
-                       jtag->speed(jtag_speed);
-       }
+       if (argc >= 1)
+               cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0);
+       if (argc == 2)
+               cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0);
+               
+       /* this command can be called during CONFIG, 
+        * in which case jtag isn't initialized */
+       if (jtag)
+               jtag->speed(cur_speed);
 
        return ERROR_OK;
 }
index e14d388..0e9a930 100644 (file)
@@ -222,6 +222,7 @@ extern enum tap_state end_state;
 extern enum tap_state cur_state;
 
 extern int jtag_speed;
+extern int jtag_speed_post_reset;
 
 enum reset_types
 {
index 1d29d21..a81b334 100644 (file)
@@ -1442,9 +1442,9 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
 
                        /* We want to print all debug output to GDB connection */
                        log_add_callback(gdb_log_callback, connection);
-                       target_call_timer_callbacks();
+                       target_call_timer_callbacks_now();
                        command_run_line(cmd_ctx, cmd);
-                       target_call_timer_callbacks();
+                       target_call_timer_callbacks_now();
                        log_remove_callback(gdb_log_callback, connection);
                        free(cmd);
                }
index a7d756a..5ce1db5 100644 (file)
@@ -1753,7 +1753,6 @@ int arm7_9_read_core_reg(struct target_s *target, int num, enum armv4_5_mode mod
 int arm7_9_write_core_reg(struct target_s *target, int num, enum armv4_5_mode mode, u32 value)
 {
        u32 reg[16];
-       int retval;
        armv4_5_common_t *armv4_5 = target->arch_info;
        arm7_9_common_t *arm7_9 = armv4_5->arch_info;
        enum armv4_5_mode reg_mode = ((armv4_5_core_reg_t*)ARMV4_5_CORE_REG_MODE(armv4_5->core_cache, mode, num).arch_info)->mode;
@@ -1805,14 +1804,7 @@ int arm7_9_write_core_reg(struct target_s *target, int num, enum armv4_5_mode mo
                arm7_9->write_xpsr_im8(target, buf_get_u32(armv4_5->core_cache->reg_list[ARMV4_5_CPSR].value, 0, 8) & ~0x20, 0, 0);
        }
        
-       if ((retval = jtag_execute_queue()) != ERROR_OK)
-       {
-               ERROR("JTAG failure");
-               exit(-1);
-       }
-       
-       return ERROR_OK;
-       
+       return jtag_execute_queue();
 }
 
 int arm7_9_read_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)
@@ -2217,8 +2209,18 @@ int arm7_9_bulk_write_memory(target_t *target, u32 address, u32 count, u8 *buffe
        
        target->type->halt(target);
        
-       while (target->state != TARGET_HALTED)
+       for (i=0; i<100; i++)
+       {
                target->type->poll(target);
+               if (target->state == TARGET_HALTED)
+                       break;
+               usleep(1000); /* sleep 1ms */
+       }
+       if (i == 100)
+       {
+               ERROR("bulk write timed out, target not halted");
+               return ERROR_TARGET_TIMEOUT;
+       }
        
        /* restore target state */
        buf_set_u32(armv4_5->core_cache->reg_list[0].value, 0, 32, r0);
@@ -2378,7 +2380,7 @@ int handle_arm7_9_write_xpsr_command(struct command_context_s *cmd_ctx, char *cm
        if ((retval = jtag_execute_queue()) != ERROR_OK)
        {
                ERROR("JTAG error while writing to xpsr");
-               exit(-1);
+               return retval;
        }
        
        return ERROR_OK;
@@ -2420,7 +2422,7 @@ int handle_arm7_9_write_xpsr_im8_command(struct command_context_s *cmd_ctx, char
        if ((retval = jtag_execute_queue()) != ERROR_OK)
        {
                ERROR("JTAG error while writing 8-bit immediate to xpsr");
-               exit(-1);
+               return retval;
        }
        
        return ERROR_OK;
index 51aef65..c90470c 100644 (file)
@@ -260,7 +260,9 @@ int target_process_reset(struct command_context_s *cmd_ctx)
        int retval = ERROR_OK;
        target_t *target;
        struct timeval timeout, now;
-       
+
+       jtag->speed(jtag_speed);
+
        /* prepare reset_halt where necessary */
        target = targets;
        while (target)
@@ -339,7 +341,7 @@ int target_process_reset(struct command_context_s *cmd_ctx)
                target = target->next;
        }
        jtag_execute_queue();
-
+       
        /* Wait for reset to complete, maximum 5 seconds. */    
        gettimeofday(&timeout, NULL);
        timeval_add_time(&timeout, 5, 0);
@@ -347,7 +349,7 @@ int target_process_reset(struct command_context_s *cmd_ctx)
        {
                gettimeofday(&now, NULL);
                
-               target_call_timer_callbacks();
+               target_call_timer_callbacks_now();
                
                target = targets;
                while (target)
@@ -379,7 +381,9 @@ int target_process_reset(struct command_context_s *cmd_ctx)
        
        
        /* We want any events to be processed before the prompt */
-       target_call_timer_callbacks();
+       target_call_timer_callbacks_now();
+
+       jtag->speed(jtag_speed_post_reset);
        
        return retval;
 }
@@ -608,6 +612,16 @@ int target_call_timer_callbacks()
        return ERROR_OK;
 }
 
+int target_call_timer_callbacks_now()
+{
+       /* TODO: this should invoke the timer callbacks now. This is used to ensure that
+        * any outstanding polls, etc. are in fact invoked before a synchronous command 
+        * completes. 
+        */
+       return target_call_timer_callbacks();
+}
+
+
 int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
 {
        working_area_t *c = target->working_areas;
@@ -1278,7 +1292,6 @@ int handle_run_and_halt_time_command(struct command_context_s *cmd_ctx, char *cm
        }
        
        target = get_target_by_num(strtoul(args[0], NULL, 0));
-       
        if (!target)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -1299,7 +1312,6 @@ int handle_working_area_command(struct command_context_s *cmd_ctx, char *cmd, ch
        }
        
        target = get_target_by_num(strtoul(args[0], NULL, 0));
-       
        if (!target)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -1531,7 +1543,7 @@ static void target_process_events(struct command_context_s *cmd_ctx)
 {
        target_t *target = get_current_target(cmd_ctx);
        target->type->poll(target);
-       target_call_timer_callbacks();
+       target_call_timer_callbacks_now();
 }
 
 static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_state state, int ms)
@@ -1547,7 +1559,7 @@ static int wait_state(struct command_context_s *cmd_ctx, char *cmd, enum target_
        {
                if ((retval=target->type->poll(target))!=ERROR_OK)
                        return retval;
-               target_call_timer_callbacks();
+               target_call_timer_callbacks_now();
                if (target->state == state)
                {
                        break;
@@ -1577,9 +1589,9 @@ int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **arg
        DEBUG("-");
 
        if ((retval = target->type->halt(target)) != ERROR_OK)
-               {
-                               return retval;
-               }
+       {
+               return retval;
+       }
        
        return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
 }
@@ -1745,51 +1757,37 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 
        buffer = calloc(count, size);
        retval  = target->type->read_memory(target, address, size, count, buffer);
-       if (retval != ERROR_OK)
+       if (retval == ERROR_OK)
        {
-               switch (retval)
+               output_len = 0;
+       
+               for (i = 0; i < count; i++)
                {
-                       case ERROR_TARGET_UNALIGNED_ACCESS:
-                               command_print(cmd_ctx, "error: address not aligned");
-                               break;
-                       case ERROR_TARGET_NOT_HALTED:
-                               command_print(cmd_ctx, "error: target must be halted for memory accesses");
-                               break;                  
-                       case ERROR_TARGET_DATA_ABORT:
-                               command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
-                               break;
-                       default:
-                               command_print(cmd_ctx, "error: unknown error");
-                               break;
+                       if (i%line_modulo == 0)
+                               output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
+                       
+                       switch (size)
+                       {
+                               case 4:
+                                       output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
+                                       break;
+                               case 2:
+                                       output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
+                                       break;
+                               case 1:
+                                       output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
+                                       break;
+                       }
+       
+                       if ((i%line_modulo == line_modulo-1) || (i == count - 1))
+                       {
+                               command_print(cmd_ctx, output);
+                               output_len = 0;
+                       }
                }
-               return ERROR_OK;
-       }
-
-       output_len = 0;
-
-       for (i = 0; i < count; i++)
+       } else
        {
-               if (i%line_modulo == 0)
-                       output_len += snprintf(output + output_len, 128 - output_len, "0x%8.8x: ", address + (i*size));
-               
-               switch (size)
-               {
-                       case 4:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
-                               break;
-                       case 2:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
-                               break;
-                       case 1:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
-                               break;
-               }
-
-               if ((i%line_modulo == line_modulo-1) || (i == count - 1))
-               {
-                       command_print(cmd_ctx, output);
-                       output_len = 0;
-               }
+               ERROR("Failure examining memory");
        }
 
        free(buffer);
@@ -1828,23 +1826,9 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                default:
                        return ERROR_OK;
        }
-
-       switch (retval)
+       if (retval!=ERROR_OK)
        {
-               case ERROR_TARGET_UNALIGNED_ACCESS:
-                       command_print(cmd_ctx, "error: address not aligned");
-                       break;
-               case ERROR_TARGET_DATA_ABORT:
-                       command_print(cmd_ctx, "error: access caused data abort, system possibly corrupted");
-                       break;
-               case ERROR_TARGET_NOT_HALTED:
-                       command_print(cmd_ctx, "error: target must be halted for memory accesses");
-                       break;
-               case ERROR_OK:
-                       break;
-               default:
-                       command_print(cmd_ctx, "error: unknown error");
-                       break;
+               ERROR("Failure examining memory");
        }
 
        return ERROR_OK;
@@ -2070,7 +2054,6 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
                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);
@@ -2095,7 +2078,6 @@ int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, ch
                                count /= 4;
                        }
                        retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
-       
                        if (retval == ERROR_OK)
                        {
                                int t;
@@ -2168,18 +2150,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
 
                if ((retval = breakpoint_add(target, strtoul(args[0], NULL, 0), length, hw)) != ERROR_OK)
                {
-                       switch (retval)
-                       {
-                               case ERROR_TARGET_NOT_HALTED:
-                                       command_print(cmd_ctx, "target must be halted to set breakpoints");
-                                       break;
-                               case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
-                                       command_print(cmd_ctx, "no more breakpoints available");
-                                       break;
-                               default:
-                                       command_print(cmd_ctx, "unknown error, breakpoint not set");
-                                       break;
-                       }
+                       ERROR("Failure setting breakpoints");
                }
                else
                {
@@ -2255,18 +2226,7 @@ int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                if ((retval = watchpoint_add(target, strtoul(args[0], NULL, 0),
                                strtoul(args[1], NULL, 0), type, data_value, data_mask)) != ERROR_OK)
                {
-                       switch (retval)
-                       {
-                               case ERROR_TARGET_NOT_HALTED:
-                                       command_print(cmd_ctx, "target must be halted to set watchpoints");
-                                       break;
-                               case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
-                                       command_print(cmd_ctx, "no more watchpoints available");
-                                       break;
-                               default:
-                                       command_print(cmd_ctx, "unknown error, watchpoint not set");
-                                       break;
-                       }       
+                       ERROR("Failure setting breakpoints");
                }
        }
        else
index e028665..b75317b 100644 (file)
@@ -239,9 +239,16 @@ extern int target_register_event_callback(int (*callback)(struct target_s *targe
 extern int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv);
 extern int target_call_event_callbacks(target_t *target, enum target_event event);
 
+/* The period is very approximate, the callback can happen much more often 
+ * or much more rarely than specified
+ */
 extern int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv);
 extern int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
-extern int target_call_timer_callbacks();
+extern int target_call_timer_callbacks_now();
+/* invoke this to ensure that e.g. polling timer callbacks happen before
+ * a syncrhonous command completes.
+ */
+extern int target_call_timer_callbacks_now_now();
 
 extern target_t* get_current_target(struct command_context_s *cmd_ctx);
 extern int get_num_by_target(target_t *query_target);