Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Add target_run_algorithm wrapper:
[openocd.git] / src / target / target.c
diff --git a/src/target/target.c b/src/target/target.c
index 95e7e5b7cacc9f58bb6897f941afc3a94e22fe38..71eb9d2b104f4c67348f4daea369df7cb9c333ba 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -150,7 +150,7 @@ const char *target_strerror_safe( int err )
        }
 }
 
-const Jim_Nvp nvp_target_event[] = {
+static const Jim_Nvp nvp_target_event[] = {
        { .value = TARGET_EVENT_OLD_gdb_program_config , .name = "old-gdb_program_config" },
        { .value = TARGET_EVENT_OLD_pre_resume         , .name = "old-pre_resume" },
 
@@ -273,7 +273,7 @@ static int new_target_number(void)
 static int target_continous_poll = 1;
 
 /* read a u32 from a buffer in target memory endianness */
-u32 target_buffer_get_u32(target_t *target, u8 *buffer)
+u32 target_buffer_get_u32(target_t *target, const u8 *buffer)
 {
        if (target->endianness == TARGET_LITTLE_ENDIAN)
                return le_to_h_u32(buffer);
@@ -282,7 +282,7 @@ u32 target_buffer_get_u32(target_t *target, u8 *buffer)
 }
 
 /* read a u16 from a buffer in target memory endianness */
-u16 target_buffer_get_u16(target_t *target, u8 *buffer)
+u16 target_buffer_get_u16(target_t *target, const u8 *buffer)
 {
        if (target->endianness == TARGET_LITTLE_ENDIAN)
                return le_to_h_u16(buffer);
@@ -291,7 +291,7 @@ u16 target_buffer_get_u16(target_t *target, u8 *buffer)
 }
 
 /* read a u8 from a buffer in target memory endianness */
-u8 target_buffer_get_u8(target_t *target, u8 *buffer)
+u8 target_buffer_get_u8(target_t *target, const u8 *buffer)
 {
        return *buffer & 0x0ff;
 }
@@ -525,6 +525,30 @@ static int target_run_algorithm_imp(struct target_s *target, int num_mem_params,
        return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info);
 }
 
+int target_read_memory(struct target_s *target,
+               u32 address, u32 size, u32 count, u8 *buffer)
+{
+       return target->type->read_memory(target, address, size, count, buffer);
+}
+
+int target_write_memory(struct target_s *target,
+               u32 address, u32 size, u32 count, u8 *buffer)
+{
+       return target->type->write_memory(target, address, size, count, buffer);
+}
+
+int target_run_algorithm(struct target_s *target,
+               int num_mem_params, mem_param_t *mem_params,
+               int num_reg_params, reg_param_t *reg_param,
+               u32 entry_point, u32 exit_point,
+               int timeout_ms, void *arch_info)
+{
+       return target->type->run_algorithm(target,
+                       num_mem_params, mem_params, num_reg_params, reg_param,
+                       entry_point, exit_point, timeout_ms, arch_info);
+}
+
+
 int target_init(struct command_context_s *cmd_ctx)
 {
        target_t *target = all_targets;
@@ -858,7 +882,7 @@ int target_alloc_working_area(struct target_s *target, u32 size, working_area_t
                {
                        int retval;
                        new_wa->backup = malloc(new_wa->size);
-                       if((retval = target->type->read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
+                       if((retval = target_read_memory(target, new_wa->address, 4, new_wa->size / 4, new_wa->backup)) != ERROR_OK)
                        {
                                free(new_wa->backup);
                                free(new_wa);
@@ -892,7 +916,7 @@ int target_free_working_area_restore(struct target_s *target, working_area_t *ar
        if (restore&&target->backup_working_area)
        {
                int retval;
-               if((retval = target->type->write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
+               if((retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup)) != ERROR_OK)
                        return retval;
        }
 
@@ -998,7 +1022,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
 
        if (((address % 2) == 0) && (size == 2))
        {
-               return target->type->write_memory(target, address, 2, 1, buffer);
+               return target_write_memory(target, address, 2, 1, buffer);
        }
 
        /* handle unaligned head bytes */
@@ -1009,7 +1033,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
                if (unaligned > size)
                        unaligned = size;
 
-               if ((retval = target->type->write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+               if ((retval = target_write_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
                        return retval;
 
                buffer += unaligned;
@@ -1030,7 +1054,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
                }
                else
                {
-                       if ((retval = target->type->write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+                       if ((retval = target_write_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
                                return retval;
                }
 
@@ -1042,7 +1066,7 @@ int target_write_buffer(struct target_s *target, u32 address, u32 size, u8 *buff
        /* handle tail writes of less than 4 bytes */
        if (size > 0)
        {
-               if ((retval = target->type->write_memory(target, address, 1, size, buffer)) != ERROR_OK)
+               if ((retval = target_write_memory(target, address, 1, size, buffer)) != ERROR_OK)
                        return retval;
        }
 
@@ -1077,7 +1101,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
 
        if (((address % 2) == 0) && (size == 2))
        {
-               return target->type->read_memory(target, address, 2, 1, buffer);
+               return target_read_memory(target, address, 2, 1, buffer);
        }
 
        /* handle unaligned head bytes */
@@ -1088,7 +1112,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
                if (unaligned > size)
                        unaligned = size;
 
-               if ((retval = target->type->read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
+               if ((retval = target_read_memory(target, address, 1, unaligned, buffer)) != ERROR_OK)
                        return retval;
 
                buffer += unaligned;
@@ -1101,7 +1125,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
        {
                int aligned = size - (size % 4);
 
-               if ((retval = target->type->read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
+               if ((retval = target_read_memory(target, address, 4, aligned / 4, buffer)) != ERROR_OK)
                        return retval;
 
                buffer += aligned;
@@ -1112,7 +1136,7 @@ int target_read_buffer(struct target_s *target, u32 address, u32 size, u8 *buffe
        /* handle tail writes of less than 4 bytes */
        if (size > 0)
        {
-               if ((retval = target->type->read_memory(target, address, 1, size, buffer)) != ERROR_OK)
+               if ((retval = target_read_memory(target, address, 1, size, buffer)) != ERROR_OK)
                        return retval;
        }
 
@@ -1190,7 +1214,7 @@ int target_read_u32(struct target_s *target, u32 address, u32 *value)
                return ERROR_FAIL;
        }
 
-       int retval = target->type->read_memory(target, address, 4, 1, value_buf);
+       int retval = target_read_memory(target, address, 4, 1, value_buf);
 
        if (retval == ERROR_OK)
        {
@@ -1215,7 +1239,7 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value)
                return ERROR_FAIL;
        }
 
-       int retval = target->type->read_memory(target, address, 2, 1, value_buf);
+       int retval = target_read_memory(target, address, 2, 1, value_buf);
 
        if (retval == ERROR_OK)
        {
@@ -1233,7 +1257,7 @@ int target_read_u16(struct target_s *target, u32 address, u16 *value)
 
 int target_read_u8(struct target_s *target, u32 address, u8 *value)
 {
-       int retval = target->type->read_memory(target, address, 1, 1, value);
+       int retval = target_read_memory(target, address, 1, 1, value);
        if (!target->type->examined)
        {
                LOG_ERROR("Target not examined yet");
@@ -1266,7 +1290,7 @@ 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);
-       if ((retval = target->type->write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
+       if ((retval = target_write_memory(target, address, 4, 1, value_buf)) != ERROR_OK)
        {
                LOG_DEBUG("failed: %i", retval);
        }
@@ -1287,7 +1311,7 @@ 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);
-       if ((retval = target->type->write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
+       if ((retval = target_write_memory(target, address, 2, 1, value_buf)) != ERROR_OK)
        {
                LOG_DEBUG("failed: %i", retval);
        }
@@ -1306,7 +1330,7 @@ int target_write_u8(struct target_s *target, u32 address, u8 value)
 
        LOG_DEBUG("address: 0x%8.8x, value: 0x%2.2x", address, value);
 
-       if ((retval = target->type->write_memory(target, address, 1, 1, &value)) != ERROR_OK)
+       if ((retval = target_write_memory(target, address, 1, 1, &value)) != ERROR_OK)
        {
                LOG_DEBUG("failed: %i", retval);
        }
@@ -1844,77 +1868,80 @@ static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, cha
        return ERROR_OK;
 }
 
-static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static void handle_md_output(struct command_context_s *cmd_ctx,
+               struct target_s *target, u32 address, unsigned size,
+               unsigned count, const u8 *buffer)
 {
-       const int line_bytecnt = 32;
-       int count = 1;
-       int size = 4;
-       u32 address = 0;
-       int line_modulo;
-       int i;
+       const unsigned line_bytecnt = 32;
+       unsigned line_modulo = line_bytecnt / size;
 
-       char output[128];
-       int output_len;
+       char output[line_bytecnt * 4 + 1];
+       unsigned output_len = 0;
 
-       int retval;
+       const char *value_fmt;
+       switch (size) {
+       case 4: value_fmt = "%8.8x"; break;
+       case 2: value_fmt = "%4.2x"; break;
+       case 1: value_fmt = "%2.2x"; break;
+       default:
+               LOG_ERROR("invalid memory read size: %u", size);
+               exit(-1);
+       }
 
-       u8 *buffer;
-       target_t *target = get_current_target(cmd_ctx);
+       for (unsigned i = 0; i < count; i++)
+       {
+               if (i % line_modulo == 0)
+               {
+                       output_len += snprintf(output + output_len,
+                                       sizeof(output) - output_len,
+                                       "0x%8.8x: ", address + (i*size));
+               }
 
-       if (argc < 1)
-               return ERROR_OK;
+               u32 value;
+               const u8 *value_ptr = buffer + i * size;
+               switch (size) {
+               case 4: value = target_buffer_get_u32(target, value_ptr); break;
+               case 2: value = target_buffer_get_u16(target, value_ptr); break;
+               case 1: value = *value_ptr;
+               }
+               output_len += snprintf(output + output_len,
+                               sizeof(output) - output_len,
+                               value_fmt, value);
 
-       if (argc == 2)
-               count = strtoul(args[1], NULL, 0);
+               if ((i % line_modulo == line_modulo - 1) || (i == count - 1))
+               {
+                       command_print(cmd_ctx, "%s", output);
+                       output_len = 0;
+               }
+       }
+}
 
-       address = strtoul(args[0], NULL, 0);
+static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+       if (argc < 1)
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
-       switch (cmd[2])
-       {
-               case 'w':
-                       size = 4; line_modulo = line_bytecnt / 4;
-                       break;
-               case 'h':
-                       size = 2; line_modulo = line_bytecnt / 2;
-                       break;
-               case 'b':
-                       size = 1; line_modulo = line_bytecnt / 1;
-                       break;
-               default:
-                       return ERROR_OK;
+       unsigned size = 0;
+       switch (cmd[2]) {
+       case 'w': size = 4; break;
+       case 'h': size = 2; break;
+       case 'b': size = 1; break;
+       default: return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       buffer = calloc(count, size);
-       retval  = target->type->read_memory(target, address, size, count, buffer);
-       if (retval == ERROR_OK)
-       {
-               output_len = 0;
+       u32 address = strtoul(args[0], NULL, 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));
+       unsigned count = 1;
+       if (argc == 2)
+               count = strtoul(args[1], NULL, 0);
 
-                       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;
-                       }
+       u8 *buffer = calloc(count, size);
 
-                       if ((i%line_modulo == line_modulo-1) || (i == count - 1))
-                       {
-                               command_print(cmd_ctx, "%s", output);
-                               output_len = 0;
-                       }
-               }
-       }
+       target_t *target = get_current_target(cmd_ctx);
+       int retval = target_read_memory(target,
+                               address, size, count, buffer);
+       if (ERROR_OK == retval)
+               handle_md_output(cmd_ctx, target, address, size, count, buffer);
 
        free(buffer);
 
@@ -1958,7 +1985,7 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char
        }
        for (i=0; i<count; i++)
        {
-               int retval = target->type->write_memory(target,
+               int retval = target_write_memory(target,
                                address + i * wordsize, wordsize, 1, value_buf);
                if (ERROR_OK != retval)
                        return retval;
@@ -2253,7 +2280,7 @@ static int handle_verify_image_command_internal(struct command_context_s *cmd_ct
                                        size *= 4;
                                        count /= 4;
                                }
-                               retval = target->type->read_memory(target, image.sections[i].base_address, size, count, data);
+                               retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
                                if (retval == ERROR_OK)
                                {
                                        u32 t;
@@ -2826,7 +2853,7 @@ static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_
                        count = (sizeof(buffer)/width);
                }
 
-               retval = target->type->read_memory( target, addr, width, count, buffer );
+               retval = target_read_memory( target, addr, width, count, buffer );
                if (retval != ERROR_OK) {
                        /* BOO !*/
                        LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
@@ -3025,7 +3052,7 @@ static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_
                }
                len -= count;
 
-               retval = target->type->write_memory(target, addr, width, count, buffer);
+               retval = target_write_memory(target, addr, width, count, buffer);
                if (retval != ERROR_OK) {
                        /* BOO !*/
                        LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count);
@@ -3516,7 +3543,7 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
                        break;
                }
                for( x = 0 ; x < c ; x++ ){
-                       e = target->type->write_memory( target, a, b, 1, target_buf );
+                       e = target_write_memory( target, a, b, 1, target_buf );
                        if( e != ERROR_OK ){
                                Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
                                return JIM_ERR;
@@ -3572,7 +3599,7 @@ static int tcl_target_func( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
                        if( y > 16 ){
                                y = 16;
                        }
-                       e = target->type->read_memory( target, a, b, y / b, target_buf );
+                       e = target_read_memory( target, a, b, y / b, target_buf );
                        if( e != ERROR_OK ){
                                Jim_SetResult_sprintf( interp, "error reading target @ 0x%08lx", (int)(a) );
                                return JIM_ERR;
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)