Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target: don't swap MMU/no-MMU work areas
[openocd.git] / src / target / target.c
diff --git a/src/target/target.c b/src/target/target.c
index 9289d37b825a75df2c35ae4d3c45f88c6033e5c1..5eec09c8953e3178d84da60cb70380448c6227a9 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -496,7 +496,13 @@ static int default_virt2phys(struct target_s *target, uint32_t virtual, uint32_t
 
 static int default_mmu(struct target_s *target, int *enabled)
 {
-       *enabled = 0;
+       LOG_ERROR("Not implemented.");
+       return ERROR_FAIL;
+}
+
+static int default_has_mmu(struct target_s *target, bool *has_mmu)
+{
+       *has_mmu = true;
        return ERROR_OK;
 }
 
@@ -716,6 +722,30 @@ static int arm_cp_check(struct target_s *target, int cpnum, uint32_t op1, uint32
                return ERROR_FAIL;
        }
 
+       if (op1 > 7)
+       {
+               LOG_ERROR("Illegal op1");
+               return ERROR_FAIL;
+       }
+
+       if (op2 > 7)
+       {
+               LOG_ERROR("Illegal op2");
+               return ERROR_FAIL;
+       }
+
+       if (CRn > 15)
+       {
+               LOG_ERROR("Illegal CRn");
+               return ERROR_FAIL;
+       }
+
+       if (CRm > 15)
+       {
+               LOG_ERROR("Illegal CRm");
+               return ERROR_FAIL;
+       }
+
        return ERROR_OK;
 }
 
@@ -741,6 +771,36 @@ int target_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, u
        return target->type->mcr(target, cpnum, op1, op2, CRn, CRm, value);
 }
 
+static int default_read_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+{
+       int retval;
+       bool mmu;
+       retval = target->type->has_mmu(target, &mmu);
+       if (retval != ERROR_OK)
+               return retval;
+       if (mmu)
+       {
+               LOG_ERROR("Not implemented");
+               return ERROR_FAIL;
+       }
+       return target_read_memory(target, address, size, count, buffer);
+}
+
+static int default_write_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+{
+       int retval;
+       bool mmu;
+       retval = target->type->has_mmu(target, &mmu);
+       if (retval != ERROR_OK)
+               return retval;
+       if (mmu)
+       {
+               LOG_ERROR("Not implemented");
+               return ERROR_FAIL;
+       }
+       return target_write_memory(target, address, size, count, buffer);
+}
+
 
 int target_init(struct command_context_s *cmd_ctx)
 {
@@ -769,22 +829,33 @@ int target_init(struct command_context_s *cmd_ctx)
 
                if (target->type->read_phys_memory == NULL)
                {
-                       target->type->read_phys_memory = target->type->read_memory;
+                       target->type->read_phys_memory = default_read_phys_memory;
                }
 
                if (target->type->write_phys_memory == NULL)
                {
-                       target->type->write_phys_memory = target->type->write_memory;
+                       target->type->write_phys_memory = default_write_phys_memory;
                }
 
                if (target->type->mcr == NULL)
                {
                        target->type->mcr = default_mcr;
+               } else
+               {
+                       /* FIX! multiple targets will generally register global commands
+                        * multiple times. Only register this one if *one* of the
+                        * targets need the command. Hmm... make it a command on the
+                        * Jim Tcl target object?
+                        */
+                       register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
                }
 
                if (target->type->mrc == NULL)
                {
                        target->type->mrc = default_mrc;
+               } else
+               {
+                       register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
                }
 
 
@@ -804,6 +875,10 @@ int target_init(struct command_context_s *cmd_ctx)
                {
                        target->type->mmu = default_mmu;
                }
+               if (target->type->has_mmu == NULL)
+               {
+                       target->type->has_mmu = default_has_mmu;
+               }
                target = target->next;
        }
 
@@ -1040,32 +1115,33 @@ int target_alloc_working_area(struct target_s *target, uint32_t size, working_ar
        {
                int retval;
                int enabled;
+
                retval = target->type->mmu(target, &enabled);
                if (retval != ERROR_OK)
                {
                        return retval;
                }
 
-               if (enabled)
-               {
-                       if (target->working_area_phys_spec)
-                       {
-                               LOG_DEBUG("MMU disabled, using physical address for working memory 0x%08x", (unsigned)target->working_area_phys);
+               if (!enabled) {
+                       if (target->working_area_phys_spec) {
+                               LOG_DEBUG("MMU disabled, using physical "
+                                       "address for working memory 0x%08x",
+                                       (unsigned)target->working_area_phys);
                                target->working_area = target->working_area_phys;
-                       } else
-                       {
-                               LOG_ERROR("No working memory available. Specify -work-area-phys to target.");
+                       } else {
+                               LOG_ERROR("No working memory available. "
+                                       "Specify -work-area-phys to target.");
                                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
                        }
-               } else
-               {
-                       if (target->working_area_virt_spec)
-                       {
-                               LOG_DEBUG("MMU enabled, using virtual address for working memory 0x%08x", (unsigned)target->working_area_virt);
+               } else {
+                       if (target->working_area_virt_spec) {
+                               LOG_DEBUG("MMU enabled, using virtual "
+                                       "address for working memory 0x%08x",
+                                       (unsigned)target->working_area_virt);
                                target->working_area = target->working_area_virt;
-                       } else
-                       {
-                               LOG_ERROR("No working memory available. Specify -work-area-virt to target.");
+                       } else {
+                               LOG_ERROR("No working memory available. "
+                                       "Specify -work-area-virt to target.");
                                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
                        }
                }
@@ -1620,9 +1696,6 @@ int target_register_user_commands(struct command_context_s *cmd_ctx)
        register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array, "read memory and return as a TCL array for script processing <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
        register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem, "convert a TCL array to memory locations and write the values  <ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
 
-       register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
-       register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
-
        register_command(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY,
                        "same args as load_image, image stored in memory - mainly for profiling purposes");
 
@@ -1942,9 +2015,7 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char
        if ((args[0][0] >= '0') && (args[0][0] <= '9'))
        {
                unsigned num;
-               int retval = parse_uint(args[0], &num);
-               if (ERROR_OK != retval)
-                       return ERROR_COMMAND_SYNTAX_ERROR;
+               COMMAND_PARSE_NUMBER(uint, args[0], num);
 
                reg_cache_t *cache = target->reg_cache;
                count = 0;
@@ -2198,9 +2269,7 @@ static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, c
        uint32_t addr = 0;
        if (argc == 1)
        {
-               int retval = parse_u32(args[0], &addr);
-               if (ERROR_OK != retval)
-                       return retval;
+               COMMAND_PARSE_NUMBER(u32, args[0], addr);
                current = 0;
        }
 
@@ -2221,9 +2290,7 @@ static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, cha
        int current_pc = 1;
        if (argc == 1)
        {
-               int retval = parse_u32(args[0], &addr);
-               if (ERROR_OK != retval)
-                       return retval;
+               COMMAND_PARSE_NUMBER(u32, args[0], addr);
                current_pc = 0;
        }
 
@@ -2310,23 +2377,18 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
+
        uint32_t address;
-       int retval = parse_u32(args[0], &address);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[0], address);
 
        unsigned count = 1;
        if (argc == 2)
-       {
-               retval = parse_uint(args[1], &count);
-               if (ERROR_OK != retval)
-                       return retval;
-       }
+               COMMAND_PARSE_NUMBER(uint, args[1], count);
 
        uint8_t *buffer = calloc(count, size);
 
        target_t *target = get_current_target(cmd_ctx);
-       retval = fn(target, address, size, count, buffer);
+       int retval = fn(target, address, size, count, buffer);
        if (ERROR_OK == retval)
                handle_md_output(cmd_ctx, target, address, size, count, buffer);
 
@@ -2357,22 +2419,14 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t address;
-       int retval = parse_u32(args[0], &address);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[0], address);
 
        uint32_t value;
-       retval = parse_u32(args[1], &value);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[1], value);
 
        unsigned count = 1;
        if (argc == 3)
-       {
-               retval = parse_uint(args[2], &count);
-               if (ERROR_OK != retval)
-                       return retval;
-       }
+               COMMAND_PARSE_NUMBER(uint, args[2], count);
 
        target_t *target = get_current_target(cmd_ctx);
        unsigned wordsize;
@@ -2396,7 +2450,7 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char
        }
        for (unsigned i = 0; i < count; i++)
        {
-               retval = fn(target,
+               int retval = fn(target,
                                address + i * wordsize, wordsize, 1, value_buf);
                if (ERROR_OK != retval)
                        return retval;
@@ -2407,8 +2461,9 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char
 
 }
 
-static int parse_load_image_command_args(char **args, int argc,
-               image_t *image, uint32_t *min_address, uint32_t *max_address)
+static int parse_load_image_command_args(struct command_context_s *cmd_ctx,
+               char **args, int argc, image_t *image,
+               uint32_t *min_address, uint32_t *max_address)
 {
        if (argc < 1 || argc > 5)
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -2418,9 +2473,7 @@ static int parse_load_image_command_args(char **args, int argc,
        if (argc >= 2)
        {
                uint32_t addr;
-               int retval = parse_u32(args[1], &addr);
-               if (ERROR_OK != retval)
-                       return ERROR_COMMAND_SYNTAX_ERROR;
+               COMMAND_PARSE_NUMBER(u32, args[1], addr);
                image->base_address = addr;
                image->base_address_set = 1;
        }
@@ -2431,15 +2484,11 @@ static int parse_load_image_command_args(char **args, int argc,
 
        if (argc >= 4)
        {
-               int retval = parse_u32(args[3], min_address);
-               if (ERROR_OK != retval)
-                       return ERROR_COMMAND_SYNTAX_ERROR;
+               COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
        }
        if (argc == 5)
        {
-               int retval = parse_u32(args[4], max_address);
-               if (ERROR_OK != retval)
-                       return ERROR_COMMAND_SYNTAX_ERROR;
+               COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
                // use size (given) to find max (required)
                *max_address += *min_address;
        }
@@ -2465,7 +2514,7 @@ static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cm
        duration_t duration;
        char *duration_text;
 
-       int retval = parse_load_image_command_args(args, argc,
+       int retval = parse_load_image_command_args(cmd_ctx, args, argc,
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
@@ -2570,14 +2619,9 @@ static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cm
        }
 
        uint32_t address;
-       int retval = parse_u32(args[1], &address);
-       if (ERROR_OK != retval)
-               return retval;
-
+       COMMAND_PARSE_NUMBER(u32, args[1], address);
        uint32_t size;
-       retval = parse_u32(args[2], &size);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[2], size);
 
        if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
        {
@@ -2586,11 +2630,11 @@ static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cm
 
        duration_start_measure(&duration);
 
+       int retval = ERROR_OK;
        while (size > 0)
        {
                uint32_t size_written;
                uint32_t this_run_size = (size > 560) ? 560 : size;
-
                retval = target_read_buffer(target, address, this_run_size, buffer);
                if (retval != ERROR_OK)
                {
@@ -2656,9 +2700,7 @@ static int handle_verify_image_command_internal(struct command_context_s *cmd_ct
        if (argc >= 2)
        {
                uint32_t addr;
-               retval = parse_u32(args[1], &addr);
-               if (ERROR_OK != retval)
-                       return ERROR_COMMAND_SYNTAX_ERROR;
+               COMMAND_PARSE_NUMBER(u32, args[1], addr);
                image.base_address = addr;
                image.base_address_set = 1;
        }
@@ -2843,14 +2885,9 @@ static int handle_bp_command(struct command_context_s *cmd_ctx,
        }
 
        uint32_t addr;
-       int retval = parse_u32(args[0], &addr);
-       if (ERROR_OK != retval)
-               return retval;
-
+       COMMAND_PARSE_NUMBER(u32, args[0], addr);
        uint32_t length;
-       retval = parse_u32(args[1], &length);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[1], length);
 
        int hw = BKPT_SOFT;
        if (argc == 3)
@@ -2870,9 +2907,7 @@ static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
-       int retval = parse_u32(args[0], &addr);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[0], addr);
 
        target_t *target = get_current_target(cmd_ctx);
        breakpoint_remove(target, addr);
@@ -2907,19 +2942,14 @@ static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char
        uint32_t length = 0;
        uint32_t data_value = 0x0;
        uint32_t data_mask = 0xffffffff;
-       int retval;
 
        switch (argc)
        {
        case 5:
-               retval = parse_u32(args[4], &data_mask);
-               if (ERROR_OK != retval)
-                       return retval;
+               COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
                // fall through
        case 4:
-               retval = parse_u32(args[3], &data_value);
-               if (ERROR_OK != retval)
-                       return retval;
+               COMMAND_PARSE_NUMBER(u32, args[3], data_value);
                // fall through
        case 3:
                switch (args[2][0])
@@ -2939,20 +2969,17 @@ static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char
                }
                // fall through
        case 2:
-               retval = parse_u32(args[1], &length);
-               if (ERROR_OK != retval)
-                       return retval;
-               retval = parse_u32(args[0], &addr);
-               if (ERROR_OK != retval)
-                       return retval;
+               COMMAND_PARSE_NUMBER(u32, args[1], length);
+               COMMAND_PARSE_NUMBER(u32, args[0], addr);
                break;
 
        default:
-               command_print(cmd_ctx, "usage: wp <address> <length> [r/w/a] [value] [mask]");
+               command_print(cmd_ctx, "usage: wp [address length "
+                               "[(r|w|a) [value [mask]]]]");
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       retval = watchpoint_add(target, addr, length, type,
+       int retval = watchpoint_add(target, addr, length, type,
                        data_value, data_mask);
        if (ERROR_OK != retval)
                LOG_ERROR("Failure setting watchpoints");
@@ -2966,9 +2993,7 @@ static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
-       int retval = parse_u32(args[0], &addr);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[0], addr);
 
        target_t *target = get_current_target(cmd_ctx);
        watchpoint_remove(target, addr);
@@ -2990,13 +3015,11 @@ static int handle_virt2phys_command(command_context_t *cmd_ctx,
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t va;
-       int retval = parse_u32(args[0], &va);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(u32, args[0], va);
        uint32_t pa;
 
        target_t *target = get_current_target(cmd_ctx);
-       retval = target->type->virt2phys(target, va, &pa);
+       int retval = target->type->virt2phys(target, va, &pa);
        if (retval == ERROR_OK)
                command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
 
@@ -3131,9 +3154,7 @@ static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd,
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        unsigned offset;
-       int retval = parse_uint(args[0], &offset);
-       if (ERROR_OK != retval)
-               return retval;
+       COMMAND_PARSE_NUMBER(uint, args[0], offset);
 
        timeval_add_time(&timeout, offset, 0);
 
@@ -3150,6 +3171,7 @@ static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd,
 
        for (;;)
        {
+               int retval;
                target_poll(target);
                if (target->state == TARGET_HALTED)
                {
@@ -4653,7 +4675,7 @@ static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, cha
        duration_t duration;
        char *duration_text;
 
-       int retval = parse_load_image_command_args(args, argc,
+       int retval = parse_load_image_command_args(cmd_ctx, args, argc,
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
@@ -4826,19 +4848,19 @@ static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        if (e != JIM_OK) {
                return e;
        }
-       op2 = l;
+       CRn = l;
 
        e = Jim_GetLong(interp, argv[4], &l);
        if (e != JIM_OK) {
                return e;
        }
-       CRn = l;
+       CRm = l;
 
        e = Jim_GetLong(interp, argv[5], &l);
        if (e != JIM_OK) {
                return e;
        }
-       CRm = l;
+       op2 = l;
 
        value = 0;
 
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)