Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
- str9x flash support (Thanks to Spencer Oliver)
[openocd.git] / src / target / target.c
diff --git a/src/target/target.c b/src/target/target.c
index 8b9939af7e30ea22d4b97988f5c1948466034ef7..531d632e698384ddec9dd321be8e12c84a0afe1d 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -21,6 +21,7 @@
 #include "config.h"
 #endif
 
+#include "replacements.h"
 #include "target.h"
 
 #include "log.h"
@@ -74,6 +75,7 @@ extern target_type_t arm7tdmi_target;
 extern target_type_t arm720t_target;
 extern target_type_t arm9tdmi_target;
 extern target_type_t arm920t_target;
+extern target_type_t arm966e_target;
 
 target_type_t *target_types[] =
 {
@@ -81,6 +83,7 @@ target_type_t *target_types[] =
        &arm9tdmi_target,
        &arm920t_target,
        &arm720t_target,
+       &arm966e_target,
        NULL,
 };
 
@@ -692,6 +695,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
                if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
                        return retval;
                
+               buffer += unaligned;
                address += unaligned;
                size -= unaligned;
        }
@@ -704,6 +708,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
                if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
                        return retval;
                
+               buffer += aligned;
                address += aligned;
                size -= aligned;
        }
@@ -718,6 +723,50 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
        return ERROR_OK;
 }
 
+void target_read_u32(struct target_s *target, u32 address, u32 *value)
+{
+       u8 value_buf[4];
+       
+       target->type->read_memory(target, address, 4, 1, value_buf);
+       
+       *value = target_buffer_get_u32(target, value_buf);
+}
+
+void target_read_u16(struct target_s *target, u32 address, u16 *value)
+{
+       u8 value_buf[2];
+       
+       target->type->read_memory(target, address, 2, 1, value_buf);
+       
+       *value = target_buffer_get_u16(target, value_buf);
+}
+
+void target_read_u8(struct target_s *target, u32 address, u8 *value)
+{
+       target->type->read_memory(target, address, 1, 1, value);
+}
+
+void target_write_u32(struct target_s *target, u32 address, u32 value)
+{
+       u8 value_buf[4];
+
+       target_buffer_set_u32(target, value_buf, value);        
+       target->type->write_memory(target, address, 4, 1, value_buf);
+}
+
+void target_write_u16(struct target_s *target, u32 address, u16 value)
+{
+       u8 value_buf[2];
+       
+       target_buffer_set_u16(target, value_buf, value);        
+       target->type->write_memory(target, address, 2, 1, value_buf);
+}
+
+void target_write_u8(struct target_s *target, u32 address, u8 value)
+{
+       target->type->read_memory(target, address, 1, 1, &value);
+}
+
 int target_register_user_commands(struct command_context_s *cmd_ctx)
 {
        register_command(cmd_ctx,  NULL, "reg", handle_reg_command, COMMAND_EXEC, NULL);
@@ -1036,7 +1085,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                        int i;
                        for (i = 0; i < cache->num_regs; i++)
                        {
-                               value = buf_to_char(cache->reg_list[i].value, cache->reg_list[i].size);
+                               value = buf_to_str(cache->reg_list[i].value, cache->reg_list[i].size, 16);
                                command_print(cmd_ctx, "(%i) %s (/%i): 0x%s (dirty: %i, valid: %i)", count++, cache->reg_list[i].name, cache->reg_list[i].size, value, cache->reg_list[i].dirty, cache->reg_list[i].valid);
                                free(value);
                        }
@@ -1101,7 +1150,7 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                        }
                        arch_type->get(reg);
                }
-               value = buf_to_char(reg->value, reg->size);
+               value = buf_to_str(reg->value, reg->size, 16);
                command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
                free(value);
                return ERROR_OK;
@@ -1110,7 +1159,9 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
        /* set register value */
        if (argc == 2)
        {
-               u32 new_value = strtoul(args[1], NULL, 0);
+               u8 *buf = malloc(CEIL(reg->size, 8));
+               str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
+
                reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type);
                if (arch_type == NULL)
                {
@@ -1118,11 +1169,14 @@ int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args
                        return ERROR_OK;
                }
                
-               arch_type->set(reg, new_value);
-               value = buf_to_char(reg->value, reg->size);
+               arch_type->set(reg, buf);
+               
+               value = buf_to_str(reg->value, reg->size, 16);
                command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, reg->size, value);
                free(value);
                
+               free(buf);
+               
                return ERROR_OK;
        }
        
@@ -1416,6 +1470,7 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                                command_print(cmd_ctx, "error: unknown error");
                                break;
                }
+               return ERROR_OK;
        }
 
        output_len = 0;
@@ -1428,13 +1483,13 @@ int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                switch (size)
                {
                        case 4:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", ((u32*)buffer)[i]);
+                               output_len += snprintf(output + output_len, 128 - output_len, "%8.8x ", target_buffer_get_u32(target, &buffer[i*4]));
                                break;
                        case 2:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", ((u16*)buffer)[i]);
+                               output_len += snprintf(output + output_len, 128 - output_len, "%4.4x ", target_buffer_get_u16(target, &buffer[i*2]));
                                break;
                        case 1:
-                               output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", ((u8*)buffer)[i]);
+                               output_len += snprintf(output + output_len, 128 - output_len, "%2.2x ", buffer[i*1]);
                                break;
                }
 
@@ -1456,6 +1511,7 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        u32 value = 0;
        int retval;
        target_t *target = get_current_target(cmd_ctx);
+       u8 value_buf[4];
 
        if (argc < 2)
                return ERROR_OK;
@@ -1466,13 +1522,16 @@ int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
        switch (cmd[2])
        {
                case 'w':
-                       retval = target->type->write_memory(target, address, 4, 1, (u8*)&value);
+                       target_buffer_set_u32(target, value_buf, value);
+                       retval = target->type->write_memory(target, address, 4, 1, value_buf);
                        break;
                case 'h':
-                       retval = target->type->write_memory(target, address, 2, 1, (u8*)&value);
+                       target_buffer_set_u16(target, value_buf, value);
+                       retval = target->type->write_memory(target, address, 2, 1, value_buf);
                        break;
                case 'b':
-                       retval = target->type->write_memory(target, address, 1, 1, (u8*)&value);
+                       value_buf[0] = value;
+                       retval = target->type->write_memory(target, address, 1, 1, value_buf);
                        break;
                default:
                        return ERROR_OK;
@@ -1569,6 +1628,8 @@ int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, cha
        u32 size;
        u8 buffer[560];
        
+       struct timeval start, end, duration;
+       
        target_t *target = get_current_target(cmd_ctx);
 
        if (argc != 3)
@@ -1593,6 +1654,8 @@ int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, cha
                return ERROR_OK;
        }
 
+       gettimeofday(&start, NULL);     
+       
        while (size > 0)
        {
                u32 this_run_size = (size > 560) ? 560 : size;
@@ -1604,6 +1667,11 @@ int handle_dump_binary_command(struct command_context_s *cmd_ctx, char *cmd, cha
 
        fclose(binary);
 
+       gettimeofday(&end, NULL);       
+
+       timeval_subtract(&duration, &end, &start);
+       command_print(cmd_ctx, "dumped %i byte in %is %ius", strtoul(args[2], NULL, 0), duration.tv_sec, duration.tv_usec);
+       
        return ERROR_OK;
 
 }
@@ -1621,7 +1689,7 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                {
                        if (breakpoint->type == BKPT_SOFT)
                        {
-                               char* buf = buf_to_char(breakpoint->orig_instr, breakpoint->length);
+                               char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16);
                                command_print(cmd_ctx, "0x%8.8x, 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf);
                                free(buf);
                        }
@@ -1658,6 +1726,14 @@ int handle_bp_command(struct command_context_s *cmd_ctx, char *cmd, char **args,
                                        break;
                        }
                }
+               else
+               {
+                       command_print(cmd_ctx, "breakpoint added at address 0x%8.8x", strtoul(args[0], NULL, 0));
+               }
+       }
+       else
+       {
+               command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
        }
 
        return ERROR_OK;
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)