stm32: add support for the STM32Lx 384kb dual bank flash

This update adds support for the STM32Lx 384kb dual bank flash. Previously there was a problem when writing an
image that was larger than 192Kb. That lead to openocd printing out two error messages like
"Error: access denied / write protected" and "Error: invalid program address". The reason was that the stm32lx
driver tried to write half pages which overlapped into the next flash bank.
A new configuration file stm32lx_dual_bank.cfg can be used for stm32lx chips with dual bank flash (256kb or 384kb devices).
A sanity check was added for probed flash size values to fix the issue seen on some ST samples that answered incorrectly.

Change-Id: I69e25131983d88613be8606b438f98870c5f1e52
Signed-off-by: Johan Almquist <johan.almquist@assaabloy.com>
Reviewed-on: http://openocd.zylin.com/1125
Tested-by: jenkins
Reviewed-by: Spencer Oliver <spen@spen-soft.co.uk>

src/flash/nor/stm32lx.c

@@ -121,6 +121,7 @@ static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank);
 
 struct stm32lx_flash_bank {
 	int probed;
+	bool has_dual_banks;
 };
 
 /* flash bank stm32lx <base> <size> 0 0 <target#>
@@ -143,6 +144,7 @@ FLASH_BANK_COMMAND_HANDLER(stm32lx_flash_bank_command)
 	bank->driver_priv = stm32lx_info;
 
 	stm32lx_info->probed = 0;
+	stm32lx_info->has_dual_banks = false;
 
 	return ERROR_OK;
 }
@@ -518,6 +520,9 @@ static int stm32lx_probe(struct flash_bank *bank)
 	uint16_t flash_size_in_kb;
 	uint16_t max_flash_size_in_kb;
 	uint32_t device_id;
+	uint32_t base_address = FLASH_BANK0_ADDRESS;
+	uint32_t second_bank_base;
+	uint32_t first_bank_size_in_kb;
 
 	stm32lx_info->probed = 0;
 
@@ -534,29 +539,63 @@ static int stm32lx_probe(struct flash_bank *bank)
 		max_flash_size_in_kb = 128;
 		break;
 	case 0x436:
+		/* According to ST, the devices with id 0x436 have dual bank flash and comes with
+		 * a total flash size of 384k or 256kb. However, the first bank is always 192kb,
+		 * and second one holds the rest. The reason is that the 256kb version is actually
+		 * the same physical flash but only the first 256kb are verified.
+		 */
 		max_flash_size_in_kb = 384;
+		first_bank_size_in_kb = 192;
+		stm32lx_info->has_dual_banks = true;
 		break;
 	default:
 		LOG_WARNING("Cannot identify target as a STM32L family.");
 		return ERROR_FAIL;
 	}
 
-	/* get flash size from target. */
+	/* Get the flash size from target. */
 	retval = target_read_u16(target, F_SIZE, &flash_size_in_kb);
 
-	/* failed reading flash size or flash size invalid (early silicon),
+	/* Failed reading flash size or flash size invalid (early silicon),
 	 * default to max target family */
 	if (retval != ERROR_OK || flash_size_in_kb == 0xffff || flash_size_in_kb == 0) {
-		LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
+		LOG_WARNING("STM32L flash size failed, probe inaccurate - assuming %dk flash",
 			max_flash_size_in_kb);
 		flash_size_in_kb = max_flash_size_in_kb;
+	} else if (flash_size_in_kb > max_flash_size_in_kb) {
+		LOG_WARNING("STM32L probed flash size assumed incorrect since FLASH_SIZE=%dk > %dk, - assuming %dk flash",
+			flash_size_in_kb, max_flash_size_in_kb, max_flash_size_in_kb);
+		flash_size_in_kb = max_flash_size_in_kb;
+	}
+
+	if (stm32lx_info->has_dual_banks) {
+		/* Use the configured base address to determine if this is the first or second flash bank.
+		 * Verify that the base address is reasonably correct and determine the flash bank size
+		 */
+		second_bank_base = base_address + first_bank_size_in_kb * 1024;
+		if (bank->base == second_bank_base) {
+			/* This is the second bank  */
+			base_address = second_bank_base;
+			flash_size_in_kb = flash_size_in_kb - first_bank_size_in_kb;
+		} else if (bank->base == 0 || bank->base == base_address) {
+			/* This is the first bank */
+			flash_size_in_kb = first_bank_size_in_kb;
+		} else {
+			LOG_WARNING("STM32L flash bank base address config is incorrect. 0x%x but should rather be 0x%x or 0x%x",
+						bank->base, base_address, second_bank_base);
+			return ERROR_FAIL;
+		}
+		LOG_INFO("STM32L flash has dual banks. Bank (%d) size is %dkb, base address is 0x%x",
+				bank->bank_number, flash_size_in_kb, base_address);
+	} else {
+		LOG_INFO("STM32L flash size is %dkb, base address is 0x%x", flash_size_in_kb, base_address);
 	}
 
 	/* if the user sets the size manually then ignore the probed value
 	 * this allows us to work around devices that have a invalid flash size register value */
 	if (bank->size) {
-		LOG_INFO("ignoring flash probed value, using configured bank size");
 		flash_size_in_kb = bank->size / 1024;
+		LOG_INFO("ignoring flash probed value, using configured bank size: %dkbytes", flash_size_in_kb);
 	}
 
 	/* STM32L - we have 32 sectors, 16 pages per sector -> 512 pages
@@ -564,15 +603,14 @@ static int stm32lx_probe(struct flash_bank *bank)
 
 	/* calculate numbers of sectors (4kB per sector) */
 	int num_sectors = (flash_size_in_kb * 1024) / FLASH_SECTOR_SIZE;
-	LOG_INFO("flash size = %dkbytes", flash_size_in_kb);
 
 	if (bank->sectors) {
 		free(bank->sectors);
 		bank->sectors = NULL;
 	}
 
-	bank->base = FLASH_BANK0_ADDRESS;
 	bank->size = flash_size_in_kb * 1024;
+	bank->base = base_address;
 	bank->num_sectors = num_sectors;
 	bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors);
 	if (bank->sectors == NULL) {

tcl/target/stm32lx_dual_bank.cfg

@@ -0,0 +1,9 @@
+# The stm32lx 384kb have a dual bank flash.
+# Let's add a definition for the second bank here.
+
+# script for stm32lx family
+source [find target/stm32l1x_stlink.cfg]
+
+# Add the second flash bank.
+set _FLASHNAME $_CHIPNAME.flash1
+flash bank $_FLASHNAME stm32lx 0x8030000 0 0 0 $_TARGETNAME

tcl/target/stm32lx_stlink.cfg

@@ -16,6 +16,18 @@ if { [info exists WORKAREASIZE] == 0 } {
 
 source [find target/stm32_stlink.cfg]
 
+# Flash base address is known by driver. Flash size will be probed.
+#
+# Please note that the larger stm32lx targets (256Kb and 384Kb) uses dual
+# bank flash. For such targets use target/stm32lx_dual_bank.cfg.
+#
+# Some samples of ST's stm32lx chips are known to have incorrect flash size
+# values programmed in their FLASH_SIZE register. The driver will warn
+# for strange values. It is possible to override the flash size probe by
+# defining the correct size here. Notice though that it is the size of
+# the flash bank
+#
+# flash bank stm32lx <base> <size> 0 0 <target#> <variant>
 set _FLASHNAME $_CHIPNAME.flash
 flash bank $_FLASHNAME stm32lx 0 0 0 0 $_TARGETNAME