X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=db676b970537a032f353cd083083dfe0a14feae2;hp=80e2c4cf21d06b0ce0d1b84929d162f32f46ceb0;hb=9b6de72c2ba149ac6f3e11d6d0dd3030bf7b19f9;hpb=9ce207a52affec0270678808ce760450905c3f7d

diff --git a/src/target/target.c b/src/target/target.c
index 80e2c4cf21..db676b9705 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -87,7 +87,7 @@ extern struct target_type dsp563xx_target;
 extern struct target_type dsp5680xx_target;
 extern struct target_type testee_target;
 extern struct target_type avr32_ap7k_target;
-extern struct target_type stm32_stlink_target;
+extern struct target_type hla_target;
 
 static struct target_type *target_types[] = {
 	&arm7tdmi_target,
@@ -110,7 +110,7 @@ static struct target_type *target_types[] = {
 	&dsp5680xx_target,
 	&testee_target,
 	&avr32_ap7k_target,
-	&stm32_stlink_target,
+	&hla_target,
 	NULL,
 };
 
@@ -379,9 +379,9 @@ struct target *get_target(const char *id)
 
 	/* try as tcltarget name */
 	for (target = all_targets; target; target = target->next) {
-		if (target->cmd_name == NULL)
+		if (target_name(target) == NULL)
 			continue;
-		if (strcmp(id, target->cmd_name) == 0)
+		if (strcmp(id, target_name(target)) == 0)
 			return target;
 	}
 
@@ -395,7 +395,7 @@ struct target *get_target(const char *id)
 	for (target = all_targets; target; target = target->next) {
 		if (target->target_number == (int)num) {
 			LOG_WARNING("use '%s' as target identifier, not '%u'",
-					target->cmd_name, num);
+					target_name(target), num);
 			return target;
 		}
 	}
@@ -657,38 +657,18 @@ const char *target_type_name(struct target *target)
 	return target->type->name;
 }
 
-static int target_write_memory_imp(struct target *target, uint32_t address,
-		uint32_t size, uint32_t count, const uint8_t *buffer)
-{
-	if (!target_was_examined(target)) {
-		LOG_ERROR("Target not examined yet");
-		return ERROR_FAIL;
-	}
-	return target->type->write_memory_imp(target, address, size, count, buffer);
-}
-
-static int target_read_memory_imp(struct target *target, uint32_t address,
-		uint32_t size, uint32_t count, uint8_t *buffer)
+static int target_soft_reset_halt(struct target *target)
 {
 	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
-	return target->type->read_memory_imp(target, address, size, count, buffer);
-}
-
-static int target_soft_reset_halt_imp(struct target *target)
-{
-	if (!target_was_examined(target)) {
-		LOG_ERROR("Target not examined yet");
-		return ERROR_FAIL;
-	}
-	if (!target->type->soft_reset_halt_imp) {
+	if (!target->type->soft_reset_halt) {
 		LOG_ERROR("Target %s does not support soft_reset_halt",
 				target_name(target));
 		return ERROR_FAIL;
 	}
-	return target->type->soft_reset_halt_imp(target);
+	return target->type->soft_reset_halt(target);
 }
 
 /**
@@ -822,6 +802,7 @@ int target_run_flash_async_algorithm(struct target *target,
 		uint32_t entry_point, uint32_t exit_point, void *arch_info)
 {
 	int retval;
+	int timeout = 0;
 
 	/* Set up working area. First word is write pointer, second word is read pointer,
 	 * rest is fifo data area. */
@@ -893,9 +874,19 @@ int target_run_flash_async_algorithm(struct target *target,
 			 * less than buffer size / flash speed. This is very unlikely to
 			 * run when using high latency connections such as USB. */
 			alive_sleep(10);
+
+			/* to stop an infinite loop on some targets check and increment a timeout
+			 * this issue was observed on a stellaris using the new ICDI interface */
+			if (timeout++ >= 500) {
+				LOG_ERROR("timeout waiting for algorithm, a target reset is recommended");
+				return ERROR_FLASH_OPERATION_FAILED;
+			}
 			continue;
 		}
 
+		/* reset our timeout */
+		timeout = 0;
+
 		/* Limit to the amount of data we actually want to write */
 		if (thisrun_bytes > count * block_size)
 			thisrun_bytes = count * block_size;
@@ -940,24 +931,40 @@ int target_run_flash_async_algorithm(struct target *target,
 int target_read_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->read_memory(target, address, size, count, buffer);
 }
 
-static int target_read_phys_memory(struct target *target,
+int target_read_phys_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->read_phys_memory(target, address, size, count, buffer);
 }
 
 int target_write_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->write_memory(target, address, size, count, buffer);
 }
 
-static int target_write_phys_memory(struct target *target,
+int target_write_phys_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->write_phys_memory(target, address, size, count, buffer);
 }
 
@@ -971,7 +978,7 @@ int target_add_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if ((target->state != TARGET_HALTED) && (breakpoint->type != BKPT_HARD)) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_breakpoint(target, breakpoint);
@@ -981,7 +988,7 @@ int target_add_context_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if (target->state != TARGET_HALTED) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_context_breakpoint(target, breakpoint);
@@ -991,7 +998,7 @@ int target_add_hybrid_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if (target->state != TARGET_HALTED) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_hybrid_breakpoint(target, breakpoint);
@@ -1007,7 +1014,7 @@ int target_add_watchpoint(struct target *target,
 		struct watchpoint *watchpoint)
 {
 	if (target->state != TARGET_HALTED) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_watchpoint(target, watchpoint);
@@ -1074,23 +1081,6 @@ static int target_init_one(struct command_context *cmd_ctx,
 		return retval;
 	}
 
-	/**
-	 * @todo get rid of those *memory_imp() methods, now that all
-	 * callers are using target_*_memory() accessors ... and make
-	 * sure the "physical" paths handle the same issues.
-	 */
-	/* a non-invasive way(in terms of patches) to add some code that
-	 * runs before the type->write/read_memory implementation
-	 */
-	type->write_memory_imp = target->type->write_memory;
-	type->write_memory = target_write_memory_imp;
-
-	type->read_memory_imp = target->type->read_memory;
-	type->read_memory = target_read_memory_imp;
-
-	type->soft_reset_halt_imp = target->type->soft_reset_halt;
-	type->soft_reset_halt = target_soft_reset_halt_imp;
-
 	/* Sanity-check MMU support ... stub in what we must, to help
 	 * implement it in stages, but warn if we need to do so.
 	 */
@@ -2153,9 +2143,6 @@ static int sense_handler(void)
 	return ERROR_OK;
 }
 
-static int backoff_times;
-static int backoff_count;
-
 /* process target state changes */
 static int handle_target(void *priv)
 {
@@ -2211,13 +2198,6 @@ static int handle_target(void *priv)
 		recursive = 0;
 	}
 
-	if (backoff_times > backoff_count) {
-		/* do not poll this time as we failed previously */
-		backoff_count++;
-		return ERROR_OK;
-	}
-	backoff_count = 0;
-
 	/* Poll targets for state changes unless that's globally disabled.
 	 * Skip targets that are currently disabled.
 	 */
@@ -2227,18 +2207,26 @@ static int handle_target(void *priv)
 		if (!target->tap->enabled)
 			continue;
 
+		if (target->backoff.times > target->backoff.count) {
+			/* do not poll this time as we failed previously */
+			target->backoff.count++;
+			continue;
+		}
+		target->backoff.count = 0;
+
 		/* only poll target if we've got power and srst isn't asserted */
 		if (!powerDropout && !srstAsserted) {
 			/* polling may fail silently until the target has been examined */
 			retval = target_poll(target);
 			if (retval != ERROR_OK) {
 				/* 100ms polling interval. Increase interval between polling up to 5000ms */
-				if (backoff_times * polling_interval < 5000) {
-					backoff_times *= 2;
-					backoff_times++;
+				if (target->backoff.times * polling_interval < 5000) {
+					target->backoff.times *= 2;
+					target->backoff.times++;
 				}
-				LOG_USER("Polling target failed, GDB will be halted. Polling again in %dms",
-						backoff_times * polling_interval);
+				LOG_USER("Polling target %s failed, GDB will be halted. Polling again in %dms",
+						target_name(target),
+						target->backoff.times * polling_interval);
 
 				/* Tell GDB to halt the debugger. This allows the user to
 				 * run monitor commands to handle the situation.
@@ -2247,9 +2235,9 @@ static int handle_target(void *priv)
 				return retval;
 			}
 			/* Since we succeeded, we reset backoff count */
-			if (backoff_times > 0)
-				LOG_USER("Polling succeeded again");
-			backoff_times = 0;
+			if (target->backoff.times > 0)
+				LOG_USER("Polling target %s succeeded again", target_name(target));
+			target->backoff.times = 0;
 		}
 	}
 
@@ -2489,7 +2477,7 @@ COMMAND_HANDLER(handle_soft_reset_halt_command)
 
 	LOG_USER("requesting target halt and executing a soft reset");
 
-	target->type->soft_reset_halt(target);
+	target_soft_reset_halt(target);
 
 	return ERROR_OK;
 }
@@ -4898,6 +4886,15 @@ static int target_create(Jim_GetOptInfo *goi)
 			/* found */
 			break;
 		}
+
+		/* check for deprecated name */
+		if (target_types[x]->deprecated_name) {
+			if (0 == strcmp(cp, target_types[x]->deprecated_name)) {
+				/* found */
+				LOG_WARNING("target name is deprecated use: \'%s\'", target_types[x]->name);
+				break;
+			}
+		}
 	}
 	if (target_types[x] == NULL) {
 		Jim_SetResultFormatted(goi->interp, "Unknown target type %s, try one of ", cp);
@@ -5053,7 +5050,7 @@ static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 	struct command_context *cmd_ctx = current_command_context(interp);
 	assert(cmd_ctx != NULL);
 
-	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
+	Jim_SetResultString(interp, target_name(get_current_target(cmd_ctx)), -1);
 	return JIM_OK;
 }
 
@@ -5131,8 +5128,10 @@ static int jim_target_smp(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		target->head = head;
 		curr = curr->next;
 	}
-	if (target->rtos)
+
+	if (target && target->rtos)
 		retval = rtos_smp_init(head->target);
+
 	return retval;
 }