target: are we running algorithm code?

[openocd] / src / target / target.c

diff --git a/src/target/target.c b/src/target/target.c
index 91fe78741a712c60c2c8eb7917e4fc30b1d005b1..286933f45458e7e19a6fe842fa578641d729f72a 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -478,9 +478,14 @@ 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;
 }
 
@@ -629,16 +634,48 @@ static int target_soft_reset_halt_imp(struct target *target)
        return target->type->soft_reset_halt_imp(target);
 }
 
-static int target_run_algorithm_imp(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info)
+/**
+ * Downloads a target-specific native code algorithm to the target,
+ * and executes it.  * Note that some targets may need to set up, enable,
+ * and tear down a breakpoint (hard or * soft) to detect algorithm
+ * termination, while others may support  lower overhead schemes where
+ * soft breakpoints embedded in the algorithm automatically terminate the
+ * algorithm.
+ *
+ * @param target used to run the algorithm
+ * @param arch_info target-specific description of the algorithm.
+ */
+int target_run_algorithm(struct target *target,
+               int num_mem_params, struct mem_param *mem_params,
+               int num_reg_params, struct reg_param *reg_param,
+               uint32_t entry_point, uint32_t exit_point,
+               int timeout_ms, void *arch_info)
 {
+       int retval = ERROR_FAIL;
+
        if (!target_was_examined(target))
        {
                LOG_ERROR("Target not examined yet");
-               return ERROR_FAIL;
+               goto done;
+       }
+       if (target->type->run_algorithm) {
+               LOG_ERROR("Target type '%s' does not support %s",
+                               target_type_name(target), __func__);
+               goto done;
        }
-       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);
+
+       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;
 }
 
+
 int target_read_memory(struct target *target,
                uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
@@ -711,17 +748,6 @@ int target_step(struct target *target,
 }
 
 
-int target_run_algorithm(struct target *target,
-               int num_mem_params, struct mem_param *mem_params,
-               int num_reg_params, struct reg_param *reg_param,
-               uint32_t entry_point, uint32_t 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);
-}
-
 /**
  * Reset the @c examined flag for the given target.
  * Pure paranoia -- targets are zeroed on allocation.
@@ -785,9 +811,6 @@ static int target_init_one(struct command_context *cmd_ctx,
        type->soft_reset_halt_imp = target->type->soft_reset_halt;
        type->soft_reset_halt = target_soft_reset_halt_imp;
 
-       type->run_algorithm_imp = target->type->run_algorithm;
-       type->run_algorithm = target_run_algorithm_imp;
-
        /* Sanity-check MMU support ... stub in what we must, to help
         * implement it in stages, but warn if we need to do so.
         */
@@ -1784,6 +1807,12 @@ static int handle_target(void *priv)
        Jim_Interp *interp = (Jim_Interp *)priv;
        int retval = ERROR_OK;
 
+       if (!is_jtag_poll_safe())
+       {
+               /* polling is disabled currently */
+               return ERROR_OK;
+       }
+
        /* we do not want to recurse here... */
        static int recursive = 0;
        if (! recursive)
@@ -2355,6 +2384,8 @@ static int target_fill_mem(struct target *target,
                {
                        break;
                }
+               /* avoid GDB timeouts */
+               keep_alive();
        }
        free(target_buf);