X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=1f517ac068c0a17fd2bbc649b99e3e4f5f7e105c;hp=6d3a99decd8adc9031124c8506a9411601ad7e86;hb=c658229f92612a7c3862b2e9ba1a8d6496a8be8a;hpb=5c2c269336cc49aa3ea7714d0ffcc4b2edf3057e

diff --git a/src/target/target.c b/src/target/target.c
index 6d3a99decd..1f517ac068 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -36,7 +36,7 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -56,6 +56,9 @@
 #include "image.h"
 #include "rtos/rtos.h"
 
+/* default halt wait timeout (ms) */
+#define DEFAULT_HALT_TIMEOUT 5000
+
 static int target_read_buffer_default(struct target *target, uint32_t address,
 		uint32_t size, uint8_t *buffer);
 static int target_write_buffer_default(struct target *target, uint32_t address,
@@ -80,6 +83,7 @@ extern struct target_type dragonite_target;
 extern struct target_type xscale_target;
 extern struct target_type cortexm3_target;
 extern struct target_type cortexa8_target;
+extern struct target_type cortexr4_target;
 extern struct target_type arm11_target;
 extern struct target_type mips_m4k_target;
 extern struct target_type avr_target;
@@ -87,7 +91,10 @@ 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;
+extern struct target_type nds32_v2_target;
+extern struct target_type nds32_v3_target;
+extern struct target_type nds32_v3m_target;
 
 static struct target_type *target_types[] = {
 	&arm7tdmi_target,
@@ -103,6 +110,7 @@ static struct target_type *target_types[] = {
 	&xscale_target,
 	&cortexm3_target,
 	&cortexa8_target,
+	&cortexr4_target,
 	&arm11_target,
 	&mips_m4k_target,
 	&avr_target,
@@ -110,7 +118,10 @@ static struct target_type *target_types[] = {
 	&dsp5680xx_target,
 	&testee_target,
 	&avr32_ap7k_target,
-	&stm32_stlink_target,
+	&hla_target,
+	&nds32_v2_target,
+	&nds32_v3_target,
+	&nds32_v3m_target,
 	NULL,
 };
 
@@ -379,9 +390,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 +406,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;
 		}
 	}
@@ -448,7 +459,7 @@ int target_poll(struct target *target)
 			target->halt_issued = false;
 		else {
 			long long t = timeval_ms() - target->halt_issued_time;
-			if (t > 1000) {
+			if (t > DEFAULT_HALT_TIMEOUT) {
 				target->halt_issued = false;
 				LOG_INFO("Halt timed out, wake up GDB.");
 				target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
@@ -657,38 +668,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)
-{
-	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)
+static int target_soft_reset_halt(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);
 }
 
 /**
@@ -951,38 +942,54 @@ 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);
 }
 
-int target_bulk_write_memory(struct target *target,
+static int target_bulk_write_memory_default(struct target *target,
 		uint32_t address, uint32_t count, const uint8_t *buffer)
 {
-	return target->type->bulk_write_memory(target, address, count, buffer);
+	return target_write_memory(target, address, 4, count, buffer);
 }
 
 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);
@@ -992,7 +999,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);
@@ -1002,7 +1009,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);
@@ -1018,7 +1025,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);
@@ -1085,23 +1092,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.
 	 */
@@ -1140,6 +1130,9 @@ static int target_init_one(struct command_context *cmd_ctx,
 	if (target->type->write_buffer == NULL)
 		target->type->write_buffer = target_write_buffer_default;
 
+	if (target->type->bulk_write_memory == NULL)
+		target->type->bulk_write_memory = target_bulk_write_memory_default;
+
 	return ERROR_OK;
 }
 
@@ -2164,9 +2157,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)
 {
@@ -2222,13 +2212,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.
 	 */
@@ -2238,18 +2221,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.
@@ -2258,9 +2249,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;
 		}
 	}
 
@@ -2421,13 +2412,11 @@ COMMAND_HANDLER(handle_wait_halt_command)
 	if (CMD_ARGC > 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	unsigned ms = 5000;
+	unsigned ms = DEFAULT_HALT_TIMEOUT;
 	if (1 == CMD_ARGC) {
 		int retval = parse_uint(CMD_ARGV[0], &ms);
 		if (ERROR_OK != retval)
 			return ERROR_COMMAND_SYNTAX_ERROR;
-		/* convert seconds (given) to milliseconds (needed) */
-		ms *= 1000;
 	}
 
 	struct target *target = get_current_target(CMD_CTX);
@@ -2500,7 +2489,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;
 }
@@ -4909,6 +4898,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);
@@ -5025,7 +5023,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	}
 
 	/* now - create the new target name command */
-	const const struct command_registration target_subcommands[] = {
+	const struct command_registration target_subcommands[] = {
 		{
 			.chain = target_instance_command_handlers,
 		},
@@ -5034,7 +5032,7 @@ static int target_create(Jim_GetOptInfo *goi)
 		},
 		COMMAND_REGISTRATION_DONE
 	};
-	const const struct command_registration target_commands[] = {
+	const struct command_registration target_commands[] = {
 		{
 			.name = cp,
 			.mode = COMMAND_ANY,
@@ -5064,7 +5062,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;
 }
 
@@ -5538,7 +5536,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.handler = handle_wait_halt_command,
 		.mode = COMMAND_EXEC,
 		.help = "wait up to the specified number of milliseconds "
-			"(default 5) for a previously requested halt",
+			"(default 5000) for a previously requested halt",
 		.usage = "[milliseconds]",
 	},
 	{
@@ -5546,7 +5544,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.handler = handle_halt_command,
 		.mode = COMMAND_EXEC,
 		.help = "request target to halt, then wait up to the specified"
-			"number of milliseconds (default 5) for it to complete",
+			"number of milliseconds (default 5000) for it to complete",
 		.usage = "[milliseconds]",
 	},
 	{