TARGET/MIPS_EJTAG: review scope of functions

[openocd] / src / target / target.c

diff --git a/src/target/target.c b/src/target/target.c
index 75c41d381f700e7a83e67d9d628d87edfc7d443d..73594fb0b9e478b0073cbb53bac78b770af47307 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -50,6 +50,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
                int argc, Jim_Obj *const *argv);
 static int target_mem2array(Jim_Interp *interp, struct target *target,
                int argc, Jim_Obj *const *argv);
+static int target_register_user_commands(struct command_context *cmd_ctx);
 
 /* targets */
 extern struct target_type arm7tdmi_target;
@@ -70,7 +71,7 @@ extern struct target_type avr_target;
 extern struct target_type dsp563xx_target;
 extern struct target_type testee_target;
 
-struct target_type *target_types[] =
+static struct target_type *target_types[] =
 {
        &arm7tdmi_target,
        &arm9tdmi_target,
@@ -93,8 +94,8 @@ struct target_type *target_types[] =
 };
 
 struct target *all_targets = NULL;
-struct target_event_callback *target_event_callbacks = NULL;
-struct target_timer_callback *target_timer_callbacks = NULL;
+static struct target_event_callback *target_event_callbacks = NULL;
+static struct target_timer_callback *target_timer_callbacks = NULL;
 
 static const Jim_Nvp nvp_assert[] = {
        { .name = "assert", NVP_ASSERT },
@@ -121,7 +122,7 @@ static const Jim_Nvp nvp_error_target[] = {
        { .value = -1, .name = NULL }
 };
 
-const char *target_strerror_safe(int err)
+static const char *target_strerror_safe(int err)
 {
        const Jim_Nvp *n;
 
@@ -282,7 +283,7 @@ uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
 }
 
 /* read a uint8_t from a buffer in target memory endianness */
-uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer)
+static uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer)
 {
        return *buffer & 0x0ff;
 }
@@ -306,7 +307,7 @@ void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t valu
 }
 
 /* write a uint8_t to a buffer in target memory endianness */
-void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
+static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value)
 {
        *buffer = value;
 }
@@ -478,13 +479,18 @@ int target_resume(struct target *target, int current, uint32_t address, int hand
         * themselves.  We want flash drivers and infrastructure to
         * be able to rely on (non-invalidated) cached state.
         *
+        * For now we require that algorithms provided by OpenOCD are
+        * used only by code which properly maintains that  cached state.
+        * state
+        *
         * REVISIT do the same for NAND ; maybe other flash flavors too...
         */
-       nor_resume(target);
+               if (!target->running_alg)
+               nor_resume(target);
        return retval;
 }
 
-int target_process_reset(struct command_context *cmd_ctx, enum target_reset_mode reset_mode)
+static int target_process_reset(struct command_context *cmd_ctx, enum target_reset_mode reset_mode)
 {
        char buf[100];
        int retval;
@@ -653,16 +659,18 @@ int target_run_algorithm(struct target *target,
                LOG_ERROR("Target not examined yet");
                goto done;
        }
-       if (target->type->run_algorithm) {
+       if (!target->type->run_algorithm) {
                LOG_ERROR("Target type '%s' does not support %s",
                                target_type_name(target), __func__);
                goto done;
        }
 
+       target->running_alg = true;
        retval = target->type->run_algorithm(target,
                        num_mem_params, mem_params,
                        num_reg_params, reg_param,
                        entry_point, exit_point, timeout_ms, arch_info);
+       target->running_alg = false;
 
 done:
        return retval;
@@ -675,7 +683,7 @@ int target_read_memory(struct target *target,
        return target->type->read_memory(target, address, size, count, buffer);
 }
 
-int target_read_phys_memory(struct target *target,
+static int target_read_phys_memory(struct target *target,
                uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
        return target->type->read_phys_memory(target, address, size, count, buffer);
@@ -687,7 +695,7 @@ int target_write_memory(struct target *target,
        return target->type->write_memory(target, address, size, count, buffer);
 }
 
-int target_write_phys_memory(struct target *target,
+static int target_write_phys_memory(struct target *target,
                uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
        return target->type->write_phys_memory(target, address, size, count, buffer);
@@ -847,7 +855,7 @@ static int target_init_one(struct command_context *cmd_ctx,
        return ERROR_OK;
 }
 
-int target_init(struct command_context *cmd_ctx)
+static int target_init(struct command_context *cmd_ctx)
 {
        struct target *target;
        int retval;
@@ -980,7 +988,7 @@ int target_unregister_event_callback(int (*callback)(struct target *target, enum
        return ERROR_OK;
 }
 
-int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
+static int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 {
        struct target_timer_callback **p = &target_timer_callbacks;
        struct target_timer_callback *c = target_timer_callbacks;
@@ -1223,7 +1231,7 @@ int target_alloc_working_area(struct target *target, uint32_t size, struct worki
        return ERROR_OK;
 }
 
-int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
+static int target_free_working_area_restore(struct target *target, struct working_area *area, int restore)
 {
        if (area->free)
                return ERROR_OK;
@@ -1252,7 +1260,7 @@ int target_free_working_area(struct target *target, struct working_area *area)
 /* free resources and restore memory, if restoring memory fails,
  * free up resources anyway
  */
-void target_free_all_working_areas_restore(struct target *target, int restore)
+static void target_free_all_working_areas_restore(struct target *target, int restore)
 {
        struct working_area *c = target->working_areas;
 
@@ -3572,22 +3580,6 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
        return JIM_OK;
 }
 
-void target_all_handle_event(enum target_event e)
-{
-       struct target *target;
-
-       LOG_DEBUG("**all*targets: event: %d, %s",
-                          (int)e,
-                          Jim_Nvp_value2name_simple(nvp_target_event, e)->name);
-
-       target = all_targets;
-       while (target) {
-               target_handle_event(target, e);
-               target = target->next;
-       }
-}
-
-
 /* FIX? should we propagate errors here rather than printing them
  * and continuing?
  */
@@ -5255,7 +5247,7 @@ static const struct command_registration target_exec_command_handlers[] = {
        },
        COMMAND_REGISTRATION_DONE
 };
-int target_register_user_commands(struct command_context *cmd_ctx)
+static int target_register_user_commands(struct command_context *cmd_ctx)
 {
        int retval = ERROR_OK;
        if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)