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>

diff --git a/src/flash/nor/stm32lx.c b/src/flash/nor/stm32lx.c
index f871a361cf64b8e5653d5489f2e336cb8f8075c0..d90b5f6262d3dafc6ea1bb4c42b90e430397a585 100644 (file)
--- 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 <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) {

diff --git a/tcl/target/stm32lx_dual_bank.cfg b/tcl/target/stm32lx_dual_bank.cfg
new file mode 100644 (file)
index 0000000..eb1158d
--- /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 6bec2b58c6d5ef037e54cc261f887a1e1f25c48c..0bd59b4abe7b746d904c8c033857fb93ae1869e3 100644 (file)
--- 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 <base> <size> 0 0 <target#> <variant>
 set _FLASHNAME $_CHIPNAME.flash
 flash bank $_FLASHNAME stm32lx 0 0 0 0 $_TARGETNAME