+ goto done;
+ }
+ 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;
+}
+
+/**
+ * Downloads a target-specific native code algorithm to the target,
+ * executes and leaves it running.
+ *
+ * @param target used to run the algorithm
+ * @param arch_info target-specific description of the algorithm.
+ */
+int target_start_algorithm(struct target *target,
+ int num_mem_params, struct mem_param *mem_params,
+ int num_reg_params, struct reg_param *reg_params,
+ uint32_t entry_point, uint32_t exit_point,
+ void *arch_info)
+{
+ int retval = ERROR_FAIL;
+
+ if (!target_was_examined(target)) {
+ LOG_ERROR("Target not examined yet");
+ goto done;
+ }
+ if (!target->type->start_algorithm) {
+ LOG_ERROR("Target type '%s' does not support %s",
+ target_type_name(target), __func__);
+ goto done;
+ }
+ if (target->running_alg) {
+ LOG_ERROR("Target is already running an algorithm");
+ goto done;
+ }
+
+ target->running_alg = true;
+ retval = target->type->start_algorithm(target,
+ num_mem_params, mem_params,
+ num_reg_params, reg_params,
+ entry_point, exit_point, arch_info);
+
+done:
+ return retval;
+}
+
+/**
+ * Waits for an algorithm started with target_start_algorithm() to complete.
+ *
+ * @param target used to run the algorithm
+ * @param arch_info target-specific description of the algorithm.
+ */
+int target_wait_algorithm(struct target *target,
+ int num_mem_params, struct mem_param *mem_params,
+ int num_reg_params, struct reg_param *reg_params,
+ uint32_t exit_point, int timeout_ms,
+ void *arch_info)
+{
+ int retval = ERROR_FAIL;
+
+ if (!target->type->wait_algorithm) {
+ LOG_ERROR("Target type '%s' does not support %s",
+ target_type_name(target), __func__);
+ goto done;
+ }
+ if (!target->running_alg) {
+ LOG_ERROR("Target is not running an algorithm");
+ goto done;
+ }
+
+ retval = target->type->wait_algorithm(target,
+ num_mem_params, mem_params,
+ num_reg_params, reg_params,
+ exit_point, timeout_ms, arch_info);
+ if (retval != ERROR_TARGET_TIMEOUT)
+ target->running_alg = false;
+
+done:
+ return retval;
+}
+
+/**
+ * Executes a target-specific native code algorithm in the target.
+ * It differs from target_run_algorithm in that the algorithm is asynchronous.
+ * Because of this it requires an compliant algorithm:
+ * see contrib/loaders/flash/stm32f1x.S for example.
+ *
+ * @param target used to run the algorithm
+ */
+
+int target_run_flash_async_algorithm(struct target *target,
+ 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,
+ uint32_t entry_point, uint32_t exit_point, void *arch_info)
+{
+ int retval;
+
+ /* Set up working area. First word is write pointer, second word is read pointer,
+ * rest is fifo data area. */
+ uint32_t wp_addr = buffer_start;
+ uint32_t rp_addr = buffer_start + 4;
+ uint32_t fifo_start_addr = buffer_start + 8;
+ uint32_t fifo_end_addr = buffer_start + buffer_size;
+
+ uint32_t wp = fifo_start_addr;
+ uint32_t rp = fifo_start_addr;
+
+ /* validate block_size is 2^n */
+ assert(!block_size || !(block_size & (block_size - 1)));
+
+ retval = target_write_u32(target, wp_addr, wp);
+ if (retval != ERROR_OK)
+ return retval;
+ retval = target_write_u32(target, rp_addr, rp);
+ if (retval != ERROR_OK)
+ return retval;
+
+ /* Start up algorithm on target and let it idle while writing the first chunk */
+ retval = target_start_algorithm(target, num_mem_params, mem_params,
+ num_reg_params, reg_params,
+ entry_point,
+ exit_point,
+ arch_info);
+
+ if (retval != ERROR_OK) {
+ LOG_ERROR("error starting target flash write algorithm");
+ return retval;