adi_v5: Remove unused features of the DAP and SWD interfaces

[openocd.git] / src / target / target.c

diff --git a/src/target/target.c b/src/target/target.c
index 43c897d9ffa06ea27d2f63f19cde6c55556520b1..87b3d1cbc981222ca39c7b7c329851627040318a 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -853,7 +853,7 @@ done:
  */
 
 int target_run_flash_async_algorithm(struct target *target,
-               uint8_t *buffer, uint32_t count, int block_size,
+               const uint8_t *buffer, uint32_t count, int block_size,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
                uint32_t buffer_start, uint32_t buffer_size,
@@ -1274,6 +1274,10 @@ COMMAND_HANDLER(handle_target_init_command)
        if (ERROR_OK != retval)
                return retval;
 
+       retval = command_run_line(CMD_CTX, "init_target_events");
+       if (ERROR_OK != retval)
+               return retval;
+
        retval = command_run_line(CMD_CTX, "init_board");
        if (ERROR_OK != retval)
                return retval;
@@ -2414,8 +2418,12 @@ static int handle_target(void *priv)
                                return retval;
                        }
                        /* Since we succeeded, we reset backoff count */
-                       if (target->backoff.times > 0)
-                               LOG_USER("Polling target %s succeeded again", target_name(target));
+                       if (target->backoff.times > 0) {
+                               LOG_USER("Polling target %s succeeded again, trying to reexamine", target_name(target));
+                               target_reset_examined(target);
+                               target_examine_one(target);
+                       }
+
                        target->backoff.times = 0;
                }
        }
@@ -3186,7 +3194,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
                                if (diffs == 0)
                                        LOG_ERROR("checksum mismatch - attempting binary compare");
 
-                               data = (uint8_t *)malloc(buf_cnt);
+                               data = malloc(buf_cnt);
 
                                /* Can we use 32bit word accesses? */
                                int size = 1;
@@ -3618,29 +3626,30 @@ COMMAND_HANDLER(handle_profile_command)
 
        const uint32_t MAX_PROFILE_SAMPLE_NUM = 10000;
        uint32_t offset;
-       uint32_t num_of_sampels;
+       uint32_t num_of_samples;
        int retval = ERROR_OK;
+
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], offset);
+
        uint32_t *samples = malloc(sizeof(uint32_t) * MAX_PROFILE_SAMPLE_NUM);
        if (samples == NULL) {
                LOG_ERROR("No memory to store samples.");
                return ERROR_FAIL;
        }
 
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], offset);
-
        /**
         * Some cores let us sample the PC without the
         * annoying halt/resume step; for example, ARMv7 PCSR.
         * Provide a way to use that more efficient mechanism.
         */
        retval = target_profiling(target, samples, MAX_PROFILE_SAMPLE_NUM,
-                               &num_of_sampels, offset);
+                               &num_of_samples, offset);
        if (retval != ERROR_OK) {
                free(samples);
                return retval;
        }
 
-       assert(num_of_sampels <= MAX_PROFILE_SAMPLE_NUM);
+       assert(num_of_samples <= MAX_PROFILE_SAMPLE_NUM);
 
        retval = target_poll(target);
        if (retval != ERROR_OK) {
@@ -3670,7 +3679,7 @@ COMMAND_HANDLER(handle_profile_command)
                COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], end_address);
        }
 
-       write_gmon(samples, num_of_sampels, CMD_ARGV[1],
+       write_gmon(samples, num_of_samples, CMD_ARGV[1],
                        with_range, start_address, end_address);
        command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
 
@@ -5095,9 +5104,10 @@ static int target_create(Jim_GetOptInfo *goi)
        target = calloc(1, sizeof(struct target));
        /* set target number */
        target->target_number = new_target_number();
+       cmd_ctx->current_target = target->target_number;
 
        /* allocate memory for each unique target type */
-       target->type = (struct target_type *)calloc(1, sizeof(struct target_type));
+       target->type = calloc(1, sizeof(struct target_type));
 
        memcpy(target->type, target_types[x], sizeof(struct target_type));
 
@@ -5483,7 +5493,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
        image_size = 0x0;
        retval = ERROR_OK;
        fastload_num = image.num_sections;
-       fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
+       fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
        if (fastload == NULL) {
                command_print(CMD_CTX, "out of memory");
                image_close(&image);
@@ -5707,7 +5717,7 @@ COMMAND_HANDLER(handle_test_mem_access_command)
                                        read_buf[i] = read_ref[i];
                                }
                                command_print_sameline(CMD_CTX,
-                                               "Test read %d x %d @ %d to %saligned buffer: ", count,
+                                               "Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
                                                size, offset, host_offset ? "un" : "");
 
                                struct duration bench;
@@ -5779,7 +5789,7 @@ out:
                                for (size_t i = 0; i < host_bufsiz; i++)
                                        write_buf[i] = rand();
                                command_print_sameline(CMD_CTX,
-                                               "Test write %d x %d @ %d from %saligned buffer: ", count,
+                                               "Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
                                                size, offset, host_offset ? "un" : "");
 
                                retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);