From: Johan Almquist Date: Thu, 24 Jan 2013 12:49:08 +0000 (+0100) Subject: stm32: add support for the STM32Lx 384kb dual bank flash X-Git-Tag: v0.7.0-rc1~80 X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=commitdiff_plain;h=bfe1a6c89272c1877308d1e60b5f2798318bb37b 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 Reviewed-on: http://openocd.zylin.com/1125 Tested-by: jenkins Reviewed-by: Spencer Oliver --- diff --git a/src/flash/nor/stm32lx.c b/src/flash/nor/stm32lx.c index f871a361cf..d90b5f6262 100644 --- a/src/flash/nor/stm32lx.c +++ b/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 0 0 @@ -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) { diff --git a/tcl/target/stm32lx_dual_bank.cfg b/tcl/target/stm32lx_dual_bank.cfg new file mode 100644 index 0000000000..eb1158d84e --- /dev/null +++ b/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 diff --git a/tcl/target/stm32lx_stlink.cfg b/tcl/target/stm32lx_stlink.cfg index 6bec2b58c6..0bd59b4abe 100644 --- a/tcl/target/stm32lx_stlink.cfg +++ b/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 0 0 set _FLASHNAME $_CHIPNAME.flash flash bank $_FLASHNAME stm32lx 0 0 0 0 $_TARGETNAME