X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fflash.c;h=e910e42f9bc5e45026589e674f77fb691a4bcdd5;hp=98e5ee0e31e871ad8fceb16c91c24a1598ed71a1;hb=6512e5e36b067ae458cb7f6a9fdfb08d38da3583;hpb=75a37eb5b37386768327e9670acfedc7811d529f

diff --git a/src/flash/flash.c b/src/flash/flash.c
index 98e5ee0e31..e910e42f9b 100644
--- a/src/flash/flash.c
+++ b/src/flash/flash.c
@@ -28,8 +28,9 @@
 #endif
 
 #include "flash.h"
+#include "common.h"
 #include "image.h"
-#include "time_support.h"
+#include <helper/time_support.h>
 
 static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock);
 
@@ -77,7 +78,6 @@ struct flash_driver *flash_drivers[] = {
 };
 
 struct flash_bank *flash_banks;
-static 	struct command *flash_cmd;
 
 /* wafer thin wrapper for invoking the flash driver */
 static int flash_driver_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
@@ -180,6 +180,25 @@ int flash_get_bank_count(void)
 	return i;
 }
 
+struct flash_bank *get_flash_bank_by_name(const char *name)
+{
+	unsigned requested = get_flash_name_index(name);
+	unsigned found = 0;
+
+	struct flash_bank *bank;
+	for (bank = flash_banks; NULL != bank; bank = bank->next)
+	{
+		if (strcmp(bank->name, name) == 0)
+			return bank;
+		if (!flash_driver_name_matches(bank->driver->name, name))
+			continue;
+		if (++found < requested)
+			continue;
+		return bank;
+	}
+	return NULL;
+}
+
 struct flash_bank *get_flash_bank_by_num(int num)
 {
 	struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
@@ -198,10 +217,14 @@ struct flash_bank *get_flash_bank_by_num(int num)
 	return p;
 }
 
-COMMAND_HELPER(flash_command_get_bank_by_num,
-	unsigned name_index, struct flash_bank **bank)
+COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
+		struct flash_bank **bank)
 {
 	const char *name = CMD_ARGV[name_index];
+	*bank = get_flash_bank_by_name(name);
+	if (*bank)
+		return ERROR_OK;
+
 	unsigned bank_num;
 	COMMAND_PARSE_NUMBER(uint, name, bank_num);
 
@@ -217,37 +240,45 @@ COMMAND_HELPER(flash_command_get_bank_by_num,
 
 COMMAND_HANDLER(handle_flash_bank_command)
 {
-	int retval;
-	int i;
-	int found = 0;
-	struct target *target;
-
-	if (CMD_ARGC < 6)
+	if (CMD_ARGC < 7)
 	{
+		LOG_ERROR("usage: flash bank <name> <driver> "
+				"<base> <size> <chip_width> <bus_width>");
 		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
+	// save bank name and advance arguments for compatibility
+	const char *bank_name = *CMD_ARGV++;
+	CMD_ARGC--;
 
+	struct target *target;
 	if ((target = get_target(CMD_ARGV[5])) == NULL)
 	{
 		LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
 		return ERROR_FAIL;
 	}
 
-	for (i = 0; flash_drivers[i]; i++)
+	const char *driver_name = CMD_ARGV[0];
+	for (unsigned i = 0; flash_drivers[i]; i++)
 	{
-		if (strcmp(CMD_ARGV[0], flash_drivers[i]->name) != 0)
+		if (strcmp(driver_name, flash_drivers[i]->name) != 0)
 			continue;
 
-		struct flash_bank *p, *c;
-
 		/* register flash specific commands */
-		if (flash_drivers[i]->register_commands(CMD_CTX) != ERROR_OK)
+		if (NULL != flash_drivers[i]->commands)
 		{
-			LOG_ERROR("couldn't register '%s' commands", CMD_ARGV[0]);
-			return ERROR_FAIL;
+			int retval = register_commands(CMD_CTX, NULL,
+					flash_drivers[i]->commands);
+			if (ERROR_OK != retval)
+			{
+				LOG_ERROR("couldn't register '%s' commands",
+						driver_name);
+				return ERROR_FAIL;
+			}
 		}
 
+		struct flash_bank *p, *c;
 		c = malloc(sizeof(struct flash_bank));
+		c->name = strdup(bank_name);
 		c->target = target;
 		c->driver = flash_drivers[i];
 		c->driver_priv = NULL;
@@ -259,10 +290,12 @@ COMMAND_HANDLER(handle_flash_bank_command)
 		c->sectors = NULL;
 		c->next = NULL;
 
+		int retval;
 		retval = CALL_COMMAND_HANDLER(flash_drivers[i]->flash_bank_command, c);
 		if (ERROR_OK != retval)
 		{
-			LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , CMD_ARGV[0], c->base);
+			LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32,
+					driver_name, c->base);
 			free(c);
 			return retval;
 		}
@@ -283,17 +316,12 @@ COMMAND_HANDLER(handle_flash_bank_command)
 			c->bank_number = 0;
 		}
 
-		found = 1;
+		return ERROR_OK;
 	}
 
 	/* no matching flash driver found */
-	if (!found)
-	{
-		LOG_ERROR("flash driver '%s' not found", CMD_ARGV[0]);
-		return ERROR_FAIL;
-	}
-
-	return ERROR_OK;
+	LOG_ERROR("flash driver '%s' not found", driver_name);
+	return ERROR_FAIL;
 }
 
 COMMAND_HANDLER(handle_flash_info_command)
@@ -403,7 +431,7 @@ COMMAND_HANDLER(handle_flash_erase_check_command)
 	}
 
 	struct flash_bank *p;
-	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank_by_num, 0, &p);
+	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 	if (ERROR_OK != retval)
 		return retval;
 
@@ -491,7 +519,7 @@ COMMAND_HANDLER(handle_flash_protect_check_command)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	struct flash_bank *p;
-	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank_by_num, 0, &p);
+	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 	if (ERROR_OK != retval)
 		return retval;
 
@@ -531,7 +559,7 @@ static int flash_check_sector_parameters(struct command_context *cmd_ctx,
 
 COMMAND_HANDLER(handle_flash_erase_command)
 {
-	if (CMD_ARGC != 2)
+	if (CMD_ARGC != 3)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	uint32_t bank_nr;
@@ -571,7 +599,7 @@ COMMAND_HANDLER(handle_flash_erase_command)
 
 COMMAND_HANDLER(handle_flash_protect_command)
 {
-	if (CMD_ARGC != 3)
+	if (CMD_ARGC != 4)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	uint32_t bank_nr;
@@ -704,24 +732,40 @@ COMMAND_HANDLER(handle_flash_fill_command)
 	uint32_t address;
 	uint32_t pattern;
 	uint32_t count;
-	uint8_t chunk[1024];
-	uint8_t readback[1024];
 	uint32_t wrote = 0;
 	uint32_t cur_size = 0;
 	uint32_t chunk_count;
 	struct target *target = get_current_target(CMD_CTX);
 	uint32_t i;
 	uint32_t wordsize;
+	int retval = ERROR_OK;
+
+	static size_t const chunksize = 1024;
+	uint8_t *chunk = malloc(chunksize);
+	if (chunk == NULL)
+		return ERROR_FAIL;
+
+	uint8_t *readback = malloc(chunksize);
+	if (readback == NULL)
+	{
+		free(chunk);
+		return ERROR_FAIL;
+	}
+
 
 	if (CMD_ARGC != 3)
-		return ERROR_COMMAND_SYNTAX_ERROR;
+	{
+		retval = ERROR_COMMAND_SYNTAX_ERROR;
+		goto done;
+	}
+
 
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern);
 	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
 
 	if (count == 0)
-		return ERROR_OK;
+		goto done;
 
 	switch (CMD_NAME[4])
 	{
@@ -735,10 +779,11 @@ COMMAND_HANDLER(handle_flash_fill_command)
 		wordsize = 1;
 		break;
 	default:
-		return ERROR_COMMAND_SYNTAX_ERROR;
+		retval = ERROR_COMMAND_SYNTAX_ERROR;
+		goto done;
 	}
 
-	chunk_count = MIN(count, (1024 / wordsize));
+	chunk_count = MIN(count, (chunksize / wordsize));
 	switch (wordsize)
 	{
 	case 4:
@@ -771,15 +816,22 @@ COMMAND_HANDLER(handle_flash_fill_command)
 		bank = get_flash_bank_by_addr(target, address);
 		if (bank == NULL)
 		{
-			return ERROR_FAIL;
+			retval = ERROR_FAIL;
+			goto done;
 		}
 		err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
 		if (err != ERROR_OK)
-			return err;
+		{
+			retval = err;
+			goto done;
+		}
 
 		err = target_read_buffer(target, address + wrote, cur_size, readback);
 		if (err != ERROR_OK)
-			return err;
+		{
+			retval = err;
+			goto done;
+		}
 
 		unsigned i;
 		for (i = 0; i < cur_size; i++)
@@ -788,7 +840,8 @@ COMMAND_HANDLER(handle_flash_fill_command)
 			{
 				LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
 						  address + wrote + i, readback[i], chunk[i]);
-				return ERROR_FAIL;
+				retval = ERROR_FAIL;
+				goto done;
 			}
 		}
 	}
@@ -799,7 +852,12 @@ COMMAND_HANDLER(handle_flash_fill_command)
 				" in %fs (%0.3f kb/s)", wrote, address,
 				duration_elapsed(&bench), duration_kbps(&bench, wrote));
 	}
-	return ERROR_OK;
+
+	done:
+	free(readback);
+	free(chunk);
+
+	return retval;
 }
 
 COMMAND_HANDLER(handle_flash_write_bank_command)
@@ -815,7 +873,7 @@ COMMAND_HANDLER(handle_flash_write_bank_command)
 	duration_start(&bench);
 
 	struct flash_bank *p;
-	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank_by_num, 0, &p);
+	int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
 	if (ERROR_OK != retval)
 		return retval;
 
@@ -1128,10 +1186,10 @@ int flash_write(struct target *target, struct image *image, uint32_t *written, i
 int default_flash_mem_blank_check(struct flash_bank *bank)
 {
 	struct target *target = bank->target;
-	uint8_t buffer[1024];
-	int buffer_size = sizeof(buffer);
+	const int buffer_size = 1024;
 	int i;
 	uint32_t nBytes;
+	int retval = ERROR_OK;
 
 	if (bank->target->state != TARGET_HALTED)
 	{
@@ -1139,6 +1197,8 @@ int default_flash_mem_blank_check(struct flash_bank *bank)
 		return ERROR_TARGET_NOT_HALTED;
 	}
 
+	uint8_t *buffer = malloc(buffer_size);
+
 	for (i = 0; i < bank->num_sectors; i++)
 	{
 		uint32_t j;
@@ -1147,7 +1207,6 @@ int default_flash_mem_blank_check(struct flash_bank *bank)
 		for (j = 0; j < bank->sectors[i].size; j += buffer_size)
 		{
 			uint32_t chunk;
-			int retval;
 			chunk = buffer_size;
 			if (chunk > (j - bank->sectors[i].size))
 			{
@@ -1156,7 +1215,9 @@ int default_flash_mem_blank_check(struct flash_bank *bank)
 
 			retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
 			if (retval != ERROR_OK)
-				return retval;
+			{
+				goto done;
+			}
 
 			for (nBytes = 0; nBytes < chunk; nBytes++)
 			{
@@ -1169,7 +1230,10 @@ int default_flash_mem_blank_check(struct flash_bank *bank)
 		}
 	}
 
-	return ERROR_OK;
+	done:
+	free(buffer);
+
+	return retval;
 }
 
 int default_flash_blank_check(struct flash_bank *bank)
@@ -1212,64 +1276,158 @@ int default_flash_blank_check(struct flash_bank *bank)
 	return ERROR_OK;
 }
 
+static const struct command_registration flash_exec_command_handlers[] = {
+	{
+		.name = "probe",
+		.handler = &handle_flash_probe_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank>",
+		.help = "identify flash bank",
+	},
+	{
+		.name = "info",
+		.handler = &handle_flash_info_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank>",
+		.help = "print bank information",
+	},
+	{
+		.name = "erase_check",
+		.handler = &handle_flash_erase_check_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank>",
+		.help = "check erase state of sectors",
+	},
+	{
+		.name = "protect_check",
+		.handler = &handle_flash_protect_check_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank>",
+		.help = "check protection state of sectors",
+	},
+	{
+		.name = "erase_sector",
+		.handler = &handle_flash_erase_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <first> <last>",
+		.help = "erase sectors",
+	},
+	{
+		.name = "erase_address",
+		.handler = &handle_flash_erase_address_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<address> <length>",
+		.help = "erase address range",
+
+	},
+	{
+		.name = "fillw",
+		.handler = &handle_flash_fill_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <address> <word_pattern> <count>",
+		.help = "fill with pattern (no autoerase)",
+	},
+	{
+		.name = "fillh",
+		.handler = &handle_flash_fill_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <address> <halfword_pattern> <count>",
+		.help = "fill with pattern",
+	},
+	{
+		.name = "fillb",
+		.handler = &handle_flash_fill_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <address> <byte_pattern> <count>",
+		.help = "fill with pattern",
+
+	},
+	{
+		.name = "write_bank",
+		.handler = &handle_flash_write_bank_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <file> <offset>",
+		.help = "write binary data",
+	},
+	{
+		.name = "write_image",
+		.handler = &handle_flash_write_image_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> [erase] [unlock] <file> [offset] [type]",
+		.help = "write an image to flash"
+	},
+	{
+		.name = "protect",
+		.handler = &handle_flash_protect_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<bank> <first> <last> <on | off>",
+		.help = "set protection of sectors",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 int flash_init_drivers(struct command_context *cmd_ctx)
 {
-	register_jim(cmd_ctx, "ocd_flash_banks",
-			jim_flash_banks, "return information about the flash banks");
-
 	if (!flash_banks)
 		return ERROR_OK;
 
-	register_command(cmd_ctx, flash_cmd, "info",
-			handle_flash_info_command, COMMAND_EXEC,
-			"print info about flash bank <num>");
-	register_command(cmd_ctx, flash_cmd, "probe",
-			handle_flash_probe_command, COMMAND_EXEC,
-			"identify flash bank <num>");
-	register_command(cmd_ctx, flash_cmd, "erase_check",
-			handle_flash_erase_check_command, COMMAND_EXEC,
-			"check erase state of sectors in flash bank <num>");
-	register_command(cmd_ctx, flash_cmd, "protect_check",
-			handle_flash_protect_check_command, COMMAND_EXEC,
-			"check protection state of sectors in flash bank <num>");
-	register_command(cmd_ctx, flash_cmd, "erase_sector",
-			handle_flash_erase_command, COMMAND_EXEC,
-			"erase sectors at <bank> <first> <last>");
-	register_command(cmd_ctx, flash_cmd, "erase_address",
-			handle_flash_erase_address_command, COMMAND_EXEC,
-			"erase address range <address> <length>");
-
-	register_command(cmd_ctx, flash_cmd, "fillw",
-			handle_flash_fill_command, COMMAND_EXEC,
-			"fill with pattern (no autoerase) <address> <word_pattern> <count>");
-	register_command(cmd_ctx, flash_cmd, "fillh",
-			handle_flash_fill_command, COMMAND_EXEC,
-			"fill with pattern <address> <halfword_pattern> <count>");
-	register_command(cmd_ctx, flash_cmd, "fillb",
-			handle_flash_fill_command, COMMAND_EXEC,
-			"fill with pattern <address> <byte_pattern> <count>");
-
-	register_command(cmd_ctx, flash_cmd, "write_bank",
-			handle_flash_write_bank_command, COMMAND_EXEC,
-			"write binary data to <bank> <file> <offset>");
-	register_command(cmd_ctx, flash_cmd, "write_image",
-			handle_flash_write_image_command, COMMAND_EXEC,
-			"write_image [erase] [unlock] <file> [offset] [type]");
-	register_command(cmd_ctx, flash_cmd, "protect",
-			handle_flash_protect_command, COMMAND_EXEC,
-			"set protection of sectors at <bank> <first> <last> <on | off>");
+	struct command *parent = command_find_in_context(cmd_ctx, "flash");
+	return register_commands(cmd_ctx, parent, flash_exec_command_handlers);
+}
 
-	return ERROR_OK;
+COMMAND_HANDLER(handle_flash_init_command)
+{
+	if (CMD_ARGC != 0)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	static bool flash_initialized = false;
+	if (flash_initialized)
+	{
+		LOG_INFO("'flash init' has already been called");
+		return ERROR_OK;
+	}
+	flash_initialized = true;
+
+	LOG_DEBUG("Initializing flash devices...");
+	return flash_init_drivers(CMD_CTX);
 }
 
+static const struct command_registration flash_config_command_handlers[] = {
+	{
+		.name = "bank",
+		.handler = &handle_flash_bank_command,
+		.mode = COMMAND_CONFIG,
+		.usage = "<name> <driver> <base> <size> "
+			"<chip_width> <bus_width> <target> "
+			"[driver_options ...]",
+		.help = "Define a new bank with the given name, "
+			"using the specified NOR flash driver.",
+	},
+	{
+		.name = "init",
+		.mode = COMMAND_CONFIG,
+		.handler = &handle_flash_init_command,
+		.help = "initialize flash devices",
+	},
+	{
+		.name = "banks",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_flash_banks,
+		.help = "return information about the flash banks",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+static const struct command_registration flash_command_handlers[] = {
+	{
+		.name = "flash",
+		.mode = COMMAND_ANY,
+		.help = "NOR flash command group",
+		.chain = flash_config_command_handlers,
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 int flash_register_commands(struct command_context *cmd_ctx)
 {
-	flash_cmd = register_command(cmd_ctx, NULL, "flash",
-			NULL, COMMAND_ANY, NULL);
-
-	register_command(cmd_ctx, flash_cmd, "bank",
-			handle_flash_bank_command, COMMAND_CONFIG,
-			"flash bank <driver> <base> <size> "
-			"<chip_width> <bus_width> <target> [driver_options ...]");
-	return ERROR_OK;
+	return register_commands(cmd_ctx, NULL, flash_command_handlers);
 }