1 /***************************************************************************
2 * Copyright (C) 2015 by Uwe Bonnes *
3 * bon@elektron.ikp.physik.tu-darmstadt.de *
5 * Copyright (C) 2019 by Tarek Bochkati for STMicroelectronics *
6 * tarek.bouchkati@gmail.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
20 ***************************************************************************/
27 #include <helper/binarybuffer.h>
28 #include <target/algorithm.h>
29 #include <target/armv7m.h>
32 /* STM32L4xxx series for reference.
34 * RM0351 (STM32L4x5/STM32L4x6)
35 * http://www.st.com/resource/en/reference_manual/dm00083560.pdf
37 * RM0394 (STM32L43x/44x/45x/46x)
38 * http://www.st.com/resource/en/reference_manual/dm00151940.pdf
40 * RM0432 (STM32L4R/4Sxx)
41 * http://www.st.com/resource/en/reference_manual/dm00310109.pdf
43 * STM32L476RG Datasheet (for erase timing)
44 * http://www.st.com/resource/en/datasheet/stm32l476rg.pdf
46 * The RM0351 devices have normally two banks, but on 512 and 256 kiB devices
47 * an option byte is available to map all sectors to the first bank.
48 * Both STM32 banks are treated as one OpenOCD bank, as other STM32 devices
51 * RM0394 devices have a single bank only.
53 * RM0432 devices have single and dual bank operating modes.
54 * - for STM32L4R/Sxx the FLASH size is 2Mbyte or 1Mbyte.
55 * - for STM32L4P/Q5x the FLASH size is 1Mbyte or 512Kbyte.
56 * Bank page (sector) size is 4Kbyte (dual mode) or 8Kbyte (single mode).
58 * Bank mode is controlled by two different bits in option bytes register.
60 * In 2M FLASH devices bit 22 (DBANK) controls Dual Bank mode.
61 * In 1M FLASH devices bit 21 (DB1M) controls Dual Bank mode.
63 * In 1M FLASH devices bit 22 (DBANK) controls Dual Bank mode.
64 * In 512K FLASH devices bit 21 (DB512K) controls Dual Bank mode.
68 /* Erase time can be as high as 25ms, 10x this and assume it's toast... */
70 #define FLASH_ERASE_TIMEOUT 250
72 /* Flash registers offsets */
73 #define STM32_FLASH_ACR 0x00
74 #define STM32_FLASH_KEYR 0x08
75 #define STM32_FLASH_OPTKEYR 0x0c
76 #define STM32_FLASH_SR 0x10
77 #define STM32_FLASH_CR 0x14
78 #define STM32_FLASH_OPTR 0x20
79 #define STM32_FLASH_WRP1AR 0x2c
80 #define STM32_FLASH_WRP1BR 0x30
81 #define STM32_FLASH_WRP2AR 0x4c
82 #define STM32_FLASH_WRP2BR 0x50
84 /* FLASH_CR register bits */
85 #define FLASH_PG (1 << 0)
86 #define FLASH_PER (1 << 1)
87 #define FLASH_MER1 (1 << 2)
88 #define FLASH_PAGE_SHIFT 3
89 #define FLASH_CR_BKER (1 << 11)
90 #define FLASH_MER2 (1 << 15)
91 #define FLASH_STRT (1 << 16)
92 #define FLASH_OPTSTRT (1 << 17)
93 #define FLASH_EOPIE (1 << 24)
94 #define FLASH_ERRIE (1 << 25)
95 #define FLASH_OBLLAUNCH (1 << 27)
96 #define FLASH_OPTLOCK (1 << 30)
97 #define FLASH_LOCK (1 << 31)
99 /* FLASH_SR register bits */
100 #define FLASH_BSY (1 << 16)
101 /* Fast programming not used => related errors not used*/
102 #define FLASH_PGSERR (1 << 7) /* Programming sequence error */
103 #define FLASH_SIZERR (1 << 6) /* Size error */
104 #define FLASH_PGAERR (1 << 5) /* Programming alignment error */
105 #define FLASH_WRPERR (1 << 4) /* Write protection error */
106 #define FLASH_PROGERR (1 << 3) /* Programming error */
107 #define FLASH_OPERR (1 << 1) /* Operation error */
108 #define FLASH_EOP (1 << 0) /* End of operation */
109 #define FLASH_ERROR (FLASH_PGSERR | FLASH_SIZERR | FLASH_PGAERR | FLASH_WRPERR | FLASH_PROGERR | FLASH_OPERR)
111 /* register unlock keys */
112 #define KEY1 0x45670123
113 #define KEY2 0xCDEF89AB
115 /* option register unlock key */
116 #define OPTKEY1 0x08192A3B
117 #define OPTKEY2 0x4C5D6E7F
119 #define RDP_LEVEL_0 0xAA
120 #define RDP_LEVEL_1 0xBB
121 #define RDP_LEVEL_2 0xCC
124 /* other registers */
125 #define DBGMCU_IDCODE 0xE0042000
133 struct stm32l4_part_info
{
135 const char *device_str
;
136 const struct stm32l4_rev
*revs
;
137 const size_t num_revs
;
138 const uint16_t max_flash_size_kb
;
139 const bool has_dual_bank
;
140 const uint32_t flash_regs_base
;
141 const uint32_t fsize_addr
;
144 struct stm32l4_flash_bank
{
150 const struct stm32l4_part_info
*part_info
;
153 static const struct stm32l4_rev stm32_415_revs
[] = {
154 { 0x1000, "1" }, { 0x1001, "2" }, { 0x1003, "3" }, { 0x1007, "4" }
157 static const struct stm32l4_rev stm32_435_revs
[] = {
158 { 0x1000, "A" }, { 0x1001, "Z" }, { 0x2001, "Y" },
161 static const struct stm32l4_rev stm32_461_revs
[] = {
162 { 0x1000, "A" }, { 0x2000, "B" },
165 static const struct stm32l4_rev stm32_462_revs
[] = {
166 { 0x1000, "A" }, { 0x1001, "Z" }, { 0x2001, "Y" },
169 static const struct stm32l4_rev stm32_464_revs
[] = {
173 static const struct stm32l4_rev stm32_470_revs
[] = {
174 { 0x1000, "A" }, { 0x1001, "Z" }, { 0x1003, "Y" }, { 0x100F, "W" },
177 static const struct stm32l4_rev stm32_471_revs
[] = {
181 static const struct stm32l4_rev stm32_495_revs
[] = {
185 static const struct stm32l4_part_info stm32l4_parts
[] = {
188 .revs
= stm32_415_revs
,
189 .num_revs
= ARRAY_SIZE(stm32_415_revs
),
190 .device_str
= "STM32L47/L48xx",
191 .max_flash_size_kb
= 1024,
192 .has_dual_bank
= true,
193 .flash_regs_base
= 0x40022000,
194 .fsize_addr
= 0x1FFF75E0,
198 .revs
= stm32_435_revs
,
199 .num_revs
= ARRAY_SIZE(stm32_435_revs
),
200 .device_str
= "STM32L43/L44xx",
201 .max_flash_size_kb
= 256,
202 .has_dual_bank
= false,
203 .flash_regs_base
= 0x40022000,
204 .fsize_addr
= 0x1FFF75E0,
208 .revs
= stm32_461_revs
,
209 .num_revs
= ARRAY_SIZE(stm32_461_revs
),
210 .device_str
= "STM32L49/L4Axx",
211 .max_flash_size_kb
= 1024,
212 .has_dual_bank
= true,
213 .flash_regs_base
= 0x40022000,
214 .fsize_addr
= 0x1FFF75E0,
218 .revs
= stm32_462_revs
,
219 .num_revs
= ARRAY_SIZE(stm32_462_revs
),
220 .device_str
= "STM32L45/L46xx",
221 .max_flash_size_kb
= 512,
222 .has_dual_bank
= false,
223 .flash_regs_base
= 0x40022000,
224 .fsize_addr
= 0x1FFF75E0,
228 .revs
= stm32_464_revs
,
229 .num_revs
= ARRAY_SIZE(stm32_464_revs
),
230 .device_str
= "STM32L41/L42xx",
231 .max_flash_size_kb
= 128,
232 .has_dual_bank
= false,
233 .flash_regs_base
= 0x40022000,
234 .fsize_addr
= 0x1FFF75E0,
238 .revs
= stm32_470_revs
,
239 .num_revs
= ARRAY_SIZE(stm32_470_revs
),
240 .device_str
= "STM32L4R/L4Sxx",
241 .max_flash_size_kb
= 2048,
242 .has_dual_bank
= true,
243 .flash_regs_base
= 0x40022000,
244 .fsize_addr
= 0x1FFF75E0,
248 .revs
= stm32_471_revs
,
249 .num_revs
= ARRAY_SIZE(stm32_471_revs
),
250 .device_str
= "STM32L4P5/L4Q5x",
251 .max_flash_size_kb
= 1024,
252 .has_dual_bank
= true,
253 .flash_regs_base
= 0x40022000,
254 .fsize_addr
= 0x1FFF75E0,
258 .revs
= stm32_495_revs
,
259 .num_revs
= ARRAY_SIZE(stm32_495_revs
),
260 .device_str
= "STM32WB5x",
261 .max_flash_size_kb
= 1024,
262 .has_dual_bank
= false,
263 .flash_regs_base
= 0x58004000,
264 .fsize_addr
= 0x1FFF75E0,
268 /* flash bank stm32l4x <base> <size> 0 0 <target#> */
269 FLASH_BANK_COMMAND_HANDLER(stm32l4_flash_bank_command
)
271 struct stm32l4_flash_bank
*stm32l4_info
;
274 return ERROR_COMMAND_SYNTAX_ERROR
;
276 stm32l4_info
= malloc(sizeof(struct stm32l4_flash_bank
));
278 return ERROR_FAIL
; /* Checkme: What better error to use?*/
279 bank
->driver_priv
= stm32l4_info
;
281 /* The flash write must be aligned to a double word (8-bytes) boundary.
282 * Ask the flash infrastructure to ensure required alignment */
283 bank
->write_start_alignment
= bank
->write_end_alignment
= 8;
285 stm32l4_info
->probed
= false;
290 static inline uint32_t stm32l4_get_flash_reg(struct flash_bank
*bank
, uint32_t reg_offset
)
292 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
293 return stm32l4_info
->part_info
->flash_regs_base
+ reg_offset
;
296 static inline int stm32l4_read_flash_reg(struct flash_bank
*bank
, uint32_t reg_offset
, uint32_t *value
)
298 return target_read_u32(bank
->target
, stm32l4_get_flash_reg(bank
, reg_offset
), value
);
301 static inline int stm32l4_write_flash_reg(struct flash_bank
*bank
, uint32_t reg_offset
, uint32_t value
)
303 return target_write_u32(bank
->target
, stm32l4_get_flash_reg(bank
, reg_offset
), value
);
306 static int stm32l4_wait_status_busy(struct flash_bank
*bank
, int timeout
)
309 int retval
= ERROR_OK
;
311 /* wait for busy to clear */
313 retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_SR
, &status
);
314 if (retval
!= ERROR_OK
)
316 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
317 if ((status
& FLASH_BSY
) == 0)
319 if (timeout
-- <= 0) {
320 LOG_ERROR("timed out waiting for flash");
327 if (status
& FLASH_WRPERR
) {
328 LOG_ERROR("stm32x device protected");
332 /* Clear but report errors */
333 if (status
& FLASH_ERROR
) {
334 if (retval
== ERROR_OK
)
336 /* If this operation fails, we ignore it and report the original
339 stm32l4_write_flash_reg(bank
, STM32_FLASH_SR
, status
& FLASH_ERROR
);
345 static int stm32l4_unlock_reg(struct flash_bank
*bank
)
349 /* first check if not already unlocked
350 * otherwise writing on STM32_FLASH_KEYR will fail
352 int retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_CR
, &ctrl
);
353 if (retval
!= ERROR_OK
)
356 if ((ctrl
& FLASH_LOCK
) == 0)
359 /* unlock flash registers */
360 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_KEYR
, KEY1
);
361 if (retval
!= ERROR_OK
)
364 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_KEYR
, KEY2
);
365 if (retval
!= ERROR_OK
)
368 retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_CR
, &ctrl
);
369 if (retval
!= ERROR_OK
)
372 if (ctrl
& FLASH_LOCK
) {
373 LOG_ERROR("flash not unlocked STM32_FLASH_CR: %" PRIx32
, ctrl
);
374 return ERROR_TARGET_FAILURE
;
380 static int stm32l4_unlock_option_reg(struct flash_bank
*bank
)
384 int retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_CR
, &ctrl
);
385 if (retval
!= ERROR_OK
)
388 if ((ctrl
& FLASH_OPTLOCK
) == 0)
391 /* unlock option registers */
392 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_OPTKEYR
, OPTKEY1
);
393 if (retval
!= ERROR_OK
)
396 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_OPTKEYR
, OPTKEY2
);
397 if (retval
!= ERROR_OK
)
400 retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_CR
, &ctrl
);
401 if (retval
!= ERROR_OK
)
404 if (ctrl
& FLASH_OPTLOCK
) {
405 LOG_ERROR("options not unlocked STM32_FLASH_CR: %" PRIx32
, ctrl
);
406 return ERROR_TARGET_FAILURE
;
412 static int stm32l4_write_option(struct flash_bank
*bank
, uint32_t reg_offset
, uint32_t value
, uint32_t mask
)
417 retval
= stm32l4_read_flash_reg(bank
, reg_offset
, &optiondata
);
418 if (retval
!= ERROR_OK
)
421 retval
= stm32l4_unlock_reg(bank
);
422 if (retval
!= ERROR_OK
)
425 retval
= stm32l4_unlock_option_reg(bank
);
426 if (retval
!= ERROR_OK
)
429 optiondata
= (optiondata
& ~mask
) | (value
& mask
);
431 retval
= stm32l4_write_flash_reg(bank
, reg_offset
, optiondata
);
432 if (retval
!= ERROR_OK
)
435 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_OPTSTRT
);
436 if (retval
!= ERROR_OK
)
439 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
442 retval2
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_LOCK
| FLASH_OPTLOCK
);
444 if (retval
!= ERROR_OK
)
450 static int stm32l4_protect_check(struct flash_bank
*bank
)
452 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
454 uint32_t wrp1ar
, wrp1br
, wrp2ar
, wrp2br
;
455 stm32l4_read_flash_reg(bank
, STM32_FLASH_WRP1AR
, &wrp1ar
);
456 stm32l4_read_flash_reg(bank
, STM32_FLASH_WRP1BR
, &wrp1br
);
457 stm32l4_read_flash_reg(bank
, STM32_FLASH_WRP2AR
, &wrp2ar
);
458 stm32l4_read_flash_reg(bank
, STM32_FLASH_WRP2BR
, &wrp2br
);
460 const uint8_t wrp1a_start
= wrp1ar
& 0xFF;
461 const uint8_t wrp1a_end
= (wrp1ar
>> 16) & 0xFF;
462 const uint8_t wrp1b_start
= wrp1br
& 0xFF;
463 const uint8_t wrp1b_end
= (wrp1br
>> 16) & 0xFF;
464 const uint8_t wrp2a_start
= wrp2ar
& 0xFF;
465 const uint8_t wrp2a_end
= (wrp2ar
>> 16) & 0xFF;
466 const uint8_t wrp2b_start
= wrp2br
& 0xFF;
467 const uint8_t wrp2b_end
= (wrp2br
>> 16) & 0xFF;
469 for (int i
= 0; i
< bank
->num_sectors
; i
++) {
470 if (i
< stm32l4_info
->bank1_sectors
) {
471 if (((i
>= wrp1a_start
) &&
473 ((i
>= wrp1b_start
) &&
475 bank
->sectors
[i
].is_protected
= 1;
477 bank
->sectors
[i
].is_protected
= 0;
480 snb
= i
- stm32l4_info
->bank1_sectors
;
481 if (((snb
>= wrp2a_start
) &&
482 (snb
<= wrp2a_end
)) ||
483 ((snb
>= wrp2b_start
) &&
485 bank
->sectors
[i
].is_protected
= 1;
487 bank
->sectors
[i
].is_protected
= 0;
493 static int stm32l4_erase(struct flash_bank
*bank
, int first
, int last
)
495 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
499 assert(first
< bank
->num_sectors
);
500 assert(last
< bank
->num_sectors
);
502 if (bank
->target
->state
!= TARGET_HALTED
) {
503 LOG_ERROR("Target not halted");
504 return ERROR_TARGET_NOT_HALTED
;
507 retval
= stm32l4_unlock_reg(bank
);
508 if (retval
!= ERROR_OK
)
513 To erase a sector, follow the procedure below:
514 1. Check that no Flash memory operation is ongoing by
515 checking the BSY bit in the FLASH_SR register
516 2. Set the PER bit and select the page and bank
517 you wish to erase in the FLASH_CR register
518 3. Set the STRT bit in the FLASH_CR register
519 4. Wait for the BSY bit to be cleared
522 for (i
= first
; i
<= last
; i
++) {
523 uint32_t erase_flags
;
524 erase_flags
= FLASH_PER
| FLASH_STRT
;
526 if (i
>= stm32l4_info
->bank1_sectors
) {
528 snb
= i
- stm32l4_info
->bank1_sectors
;
529 erase_flags
|= snb
<< FLASH_PAGE_SHIFT
| FLASH_CR_BKER
;
531 erase_flags
|= i
<< FLASH_PAGE_SHIFT
;
532 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, erase_flags
);
533 if (retval
!= ERROR_OK
)
536 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
537 if (retval
!= ERROR_OK
)
540 bank
->sectors
[i
].is_erased
= 1;
544 retval2
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_LOCK
);
546 if (retval
!= ERROR_OK
)
552 static int stm32l4_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
554 struct target
*target
= bank
->target
;
555 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
557 if (target
->state
!= TARGET_HALTED
) {
558 LOG_ERROR("Target not halted");
559 return ERROR_TARGET_NOT_HALTED
;
564 uint32_t reg_value
= 0xFF; /* Default to bank un-protected */
565 if (last
>= stm32l4_info
->bank1_sectors
) {
567 uint8_t begin
= first
> stm32l4_info
->bank1_sectors
? first
: 0x00;
568 reg_value
= ((last
& 0xFF) << 16) | begin
;
571 ret
= stm32l4_write_option(bank
, STM32_FLASH_WRP2AR
, reg_value
, 0xffffffff);
574 reg_value
= 0xFF; /* Default to bank un-protected */
575 if (first
< stm32l4_info
->bank1_sectors
) {
577 uint8_t end
= last
>= stm32l4_info
->bank1_sectors
? 0xFF : last
;
578 reg_value
= (end
<< 16) | (first
& 0xFF);
581 ret
= stm32l4_write_option(bank
, STM32_FLASH_WRP1AR
, reg_value
, 0xffffffff);
587 /* Count is in double-words */
588 static int stm32l4_write_block(struct flash_bank
*bank
, const uint8_t *buffer
,
589 uint32_t offset
, uint32_t count
)
591 struct target
*target
= bank
->target
;
592 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
593 uint32_t buffer_size
= 16384;
594 struct working_area
*write_algorithm
;
595 struct working_area
*source
;
596 uint32_t address
= bank
->base
+ offset
;
597 struct reg_param reg_params
[5];
598 struct armv7m_algorithm armv7m_info
;
599 int retval
= ERROR_OK
;
601 static const uint8_t stm32l4_flash_write_code
[] = {
602 #include "../../../contrib/loaders/flash/stm32/stm32l4x.inc"
605 if (target_alloc_working_area(target
, sizeof(stm32l4_flash_write_code
),
606 &write_algorithm
) != ERROR_OK
) {
607 LOG_WARNING("no working area available, can't do block memory writes");
608 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
611 retval
= target_write_buffer(target
, write_algorithm
->address
,
612 sizeof(stm32l4_flash_write_code
),
613 stm32l4_flash_write_code
);
614 if (retval
!= ERROR_OK
) {
615 target_free_working_area(target
, write_algorithm
);
620 while (target_alloc_working_area_try(target
, buffer_size
, &source
) !=
623 if (buffer_size
<= 256) {
624 /* we already allocated the writing code, but failed to get a
625 * buffer, free the algorithm */
626 target_free_working_area(target
, write_algorithm
);
628 LOG_WARNING("large enough working area not available, can't do block memory writes");
629 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
633 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
634 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
636 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* buffer start, status (out) */
637 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* buffer end */
638 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* target address */
639 init_reg_param(®_params
[3], "r3", 32, PARAM_OUT
); /* count (double word-64bit) */
640 init_reg_param(®_params
[4], "r4", 32, PARAM_OUT
); /* flash regs base */
642 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
643 buf_set_u32(reg_params
[1].value
, 0, 32, source
->address
+ source
->size
);
644 buf_set_u32(reg_params
[2].value
, 0, 32, address
);
645 buf_set_u32(reg_params
[3].value
, 0, 32, count
);
646 buf_set_u32(reg_params
[4].value
, 0, 32, stm32l4_info
->part_info
->flash_regs_base
);
648 retval
= target_run_flash_async_algorithm(target
, buffer
, count
, 8,
651 source
->address
, source
->size
,
652 write_algorithm
->address
, 0,
655 if (retval
== ERROR_FLASH_OPERATION_FAILED
) {
656 LOG_ERROR("error executing stm32l4 flash write algorithm");
658 uint32_t error
= buf_get_u32(reg_params
[0].value
, 0, 32) & FLASH_ERROR
;
660 if (error
& FLASH_WRPERR
)
661 LOG_ERROR("flash memory write protected");
664 LOG_ERROR("flash write failed = %08" PRIx32
, error
);
665 /* Clear but report errors */
666 stm32l4_write_flash_reg(bank
, STM32_FLASH_SR
, error
);
671 target_free_working_area(target
, source
);
672 target_free_working_area(target
, write_algorithm
);
674 destroy_reg_param(®_params
[0]);
675 destroy_reg_param(®_params
[1]);
676 destroy_reg_param(®_params
[2]);
677 destroy_reg_param(®_params
[3]);
678 destroy_reg_param(®_params
[4]);
683 static int stm32l4_write(struct flash_bank
*bank
, const uint8_t *buffer
,
684 uint32_t offset
, uint32_t count
)
688 if (bank
->target
->state
!= TARGET_HALTED
) {
689 LOG_ERROR("Target not halted");
690 return ERROR_TARGET_NOT_HALTED
;
693 /* The flash write must be aligned to a double word (8-bytes) boundary.
694 * The flash infrastructure ensures it, do just a security check */
695 assert(offset
% 8 == 0);
696 assert(count
% 8 == 0);
698 retval
= stm32l4_unlock_reg(bank
);
699 if (retval
!= ERROR_OK
)
702 retval
= stm32l4_write_block(bank
, buffer
, offset
, count
/ 8);
705 retval2
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_LOCK
);
707 if (retval
!= ERROR_OK
) {
708 LOG_ERROR("block write failed");
714 static int stm32l4_read_idcode(struct flash_bank
*bank
, uint32_t *id
)
716 int retval
= target_read_u32(bank
->target
, DBGMCU_IDCODE
, id
);
717 if (retval
!= ERROR_OK
)
723 static int stm32l4_probe(struct flash_bank
*bank
)
725 struct target
*target
= bank
->target
;
726 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
727 const struct stm32l4_part_info
*part_info
;
728 uint16_t flash_size_in_kb
= 0xffff;
732 stm32l4_info
->probed
= false;
734 /* read stm32 device id register */
735 int retval
= stm32l4_read_idcode(bank
, &stm32l4_info
->idcode
);
736 if (retval
!= ERROR_OK
)
739 device_id
= stm32l4_info
->idcode
& 0xFFF;
741 for (unsigned int n
= 0; n
< ARRAY_SIZE(stm32l4_parts
); n
++) {
742 if (device_id
== stm32l4_parts
[n
].id
)
743 stm32l4_info
->part_info
= &stm32l4_parts
[n
];
746 if (!stm32l4_info
->part_info
) {
747 LOG_WARNING("Cannot identify target as an STM32 L4 or WB family device.");
751 part_info
= stm32l4_info
->part_info
;
753 char device_info
[1024];
754 retval
= bank
->driver
->info(bank
, device_info
, sizeof(device_info
));
755 if (retval
!= ERROR_OK
)
758 LOG_INFO("device idcode = 0x%08" PRIx32
" (%s)", stm32l4_info
->idcode
, device_info
);
760 /* get flash size from target. */
761 retval
= target_read_u16(target
, part_info
->fsize_addr
, &flash_size_in_kb
);
763 /* failed reading flash size or flash size invalid (early silicon),
764 * default to max target family */
765 if (retval
!= ERROR_OK
|| flash_size_in_kb
== 0xffff || flash_size_in_kb
== 0
766 || flash_size_in_kb
> part_info
->max_flash_size_kb
) {
767 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
768 part_info
->max_flash_size_kb
);
769 flash_size_in_kb
= part_info
->max_flash_size_kb
;
772 LOG_INFO("flash size = %dkbytes", flash_size_in_kb
);
774 /* did we assign a flash size? */
775 assert((flash_size_in_kb
!= 0xffff) && flash_size_in_kb
);
777 /* read flash option register */
778 retval
= stm32l4_read_flash_reg(bank
, STM32_FLASH_OPTR
, &options
);
779 if (retval
!= ERROR_OK
)
782 stm32l4_info
->bank1_sectors
= 0;
783 stm32l4_info
->hole_sectors
= 0;
788 stm32l4_info
->dual_bank_mode
= false;
793 /* if flash size is max (1M) the device is always dual bank
794 * 0x415: has variants with 512K
795 * 0x461: has variants with 512 and 256
796 * for these variants:
797 * if DUAL_BANK = 0 -> single bank
798 * else -> dual bank without gap
799 * note: the page size is invariant
802 num_pages
= flash_size_in_kb
/ 2;
803 stm32l4_info
->bank1_sectors
= num_pages
;
805 /* check DUAL_BANK bit[21] if the flash is less than 1M */
806 if (flash_size_in_kb
== 1024 || (options
& BIT(21))) {
807 stm32l4_info
->dual_bank_mode
= true;
808 stm32l4_info
->bank1_sectors
= num_pages
/ 2;
814 /* single bank flash */
816 num_pages
= flash_size_in_kb
/ 2;
817 stm32l4_info
->bank1_sectors
= num_pages
;
821 /* STM32L4R/S can be single/dual bank:
822 * if size = 2M check DBANK bit(22)
823 * if size = 1M check DB1M bit(21)
824 * STM32L4P/Q can be single/dual bank
825 * if size = 1M check DBANK bit(22)
826 * if size = 512K check DB512K bit(21)
827 * in single bank configuration the page size is 8K
828 * else (dual bank) the page size is 4K without gap between banks
831 num_pages
= flash_size_in_kb
/ 8;
832 stm32l4_info
->bank1_sectors
= num_pages
;
833 const bool use_dbank_bit
= flash_size_in_kb
== part_info
->max_flash_size_kb
;
834 if ((use_dbank_bit
&& (options
& BIT(22))) ||
835 (!use_dbank_bit
&& (options
& BIT(21)))) {
836 stm32l4_info
->dual_bank_mode
= true;
838 num_pages
= flash_size_in_kb
/ 4;
839 stm32l4_info
->bank1_sectors
= num_pages
/ 2;
843 /* single bank flash */
845 num_pages
= flash_size_in_kb
/ 4;
846 stm32l4_info
->bank1_sectors
= num_pages
;
849 LOG_ERROR("unsupported device");
853 LOG_INFO("flash mode : %s-bank", stm32l4_info
->dual_bank_mode
? "dual" : "single");
855 const int gap_size
= stm32l4_info
->hole_sectors
* page_size
;
857 if (stm32l4_info
->dual_bank_mode
& gap_size
) {
858 LOG_INFO("gap detected starting from %0x08" PRIx32
" to %0x08" PRIx32
,
859 0x8000000 + stm32l4_info
->bank1_sectors
* page_size
,
860 0x8000000 + stm32l4_info
->bank1_sectors
* page_size
+ gap_size
);
865 bank
->sectors
= NULL
;
868 bank
->size
= flash_size_in_kb
* 1024 + gap_size
;
869 bank
->base
= 0x08000000;
870 bank
->num_sectors
= num_pages
;
871 bank
->sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
872 if (bank
->sectors
== NULL
) {
873 LOG_ERROR("failed to allocate bank sectors");
877 for (int i
= 0; i
< bank
->num_sectors
; i
++) {
878 bank
->sectors
[i
].offset
= i
* page_size
;
879 /* in dual bank configuration, if there is a gap between banks
880 * we fix up the sector offset to consider this gap */
881 if (i
>= stm32l4_info
->bank1_sectors
&& stm32l4_info
->hole_sectors
)
882 bank
->sectors
[i
].offset
+= gap_size
;
883 bank
->sectors
[i
].size
= page_size
;
884 bank
->sectors
[i
].is_erased
= -1;
885 bank
->sectors
[i
].is_protected
= 1;
888 stm32l4_info
->probed
= true;
892 static int stm32l4_auto_probe(struct flash_bank
*bank
)
894 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
895 if (stm32l4_info
->probed
)
898 return stm32l4_probe(bank
);
901 static int get_stm32l4_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
903 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
904 const struct stm32l4_part_info
*part_info
= stm32l4_info
->part_info
;
907 const char *rev_str
= NULL
;
908 uint16_t rev_id
= stm32l4_info
->idcode
>> 16;
909 for (unsigned int i
= 0; i
< part_info
->num_revs
; i
++) {
910 if (rev_id
== part_info
->revs
[i
].rev
) {
911 rev_str
= part_info
->revs
[i
].str
;
913 if (rev_str
!= NULL
) {
914 snprintf(buf
, buf_size
, "%s - Rev: %s",
915 part_info
->device_str
, rev_str
);
921 snprintf(buf
, buf_size
, "%s - Rev: unknown (0x%04x)",
922 part_info
->device_str
, rev_id
);
925 snprintf(buf
, buf_size
, "Cannot identify target as an STM32 L4 or WB device");
932 static int stm32l4_mass_erase(struct flash_bank
*bank
)
935 struct target
*target
= bank
->target
;
936 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
938 uint32_t action
= FLASH_MER1
;
940 if (stm32l4_info
->part_info
->has_dual_bank
)
941 action
|= FLASH_MER2
;
943 if (target
->state
!= TARGET_HALTED
) {
944 LOG_ERROR("Target not halted");
945 return ERROR_TARGET_NOT_HALTED
;
948 retval
= stm32l4_unlock_reg(bank
);
949 if (retval
!= ERROR_OK
)
952 /* mass erase flash memory */
953 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
/ 10);
954 if (retval
!= ERROR_OK
)
957 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, action
);
958 if (retval
!= ERROR_OK
)
961 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, action
| FLASH_STRT
);
962 if (retval
!= ERROR_OK
)
965 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
968 retval2
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_LOCK
);
970 if (retval
!= ERROR_OK
)
976 COMMAND_HANDLER(stm32l4_handle_mass_erase_command
)
979 command_print(CMD
, "stm32l4x mass_erase <STM32L4 bank>");
980 return ERROR_COMMAND_SYNTAX_ERROR
;
983 struct flash_bank
*bank
;
984 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
985 if (ERROR_OK
!= retval
)
988 retval
= stm32l4_mass_erase(bank
);
989 if (retval
== ERROR_OK
) {
990 /* set all sectors as erased */
991 for (int i
= 0; i
< bank
->num_sectors
; i
++)
992 bank
->sectors
[i
].is_erased
= 1;
994 command_print(CMD
, "stm32l4x mass erase complete");
996 command_print(CMD
, "stm32l4x mass erase failed");
1002 COMMAND_HANDLER(stm32l4_handle_option_read_command
)
1005 command_print(CMD
, "stm32l4x option_read <STM32L4 bank> <option_reg offset>");
1006 return ERROR_COMMAND_SYNTAX_ERROR
;
1009 struct flash_bank
*bank
;
1010 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1011 if (ERROR_OK
!= retval
)
1014 uint32_t reg_offset
, reg_addr
;
1017 reg_offset
= strtoul(CMD_ARGV
[1], NULL
, 16);
1018 reg_addr
= stm32l4_get_flash_reg(bank
, reg_offset
);
1020 retval
= stm32l4_read_flash_reg(bank
, reg_offset
, &value
);
1021 if (ERROR_OK
!= retval
)
1024 command_print(CMD
, "Option Register: <0x%" PRIx32
"> = 0x%" PRIx32
"", reg_addr
, value
);
1029 COMMAND_HANDLER(stm32l4_handle_option_write_command
)
1032 command_print(CMD
, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]");
1033 return ERROR_COMMAND_SYNTAX_ERROR
;
1036 struct flash_bank
*bank
;
1037 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1038 if (ERROR_OK
!= retval
)
1041 uint32_t reg_offset
;
1043 uint32_t mask
= 0xFFFFFFFF;
1045 reg_offset
= strtoul(CMD_ARGV
[1], NULL
, 16);
1046 value
= strtoul(CMD_ARGV
[2], NULL
, 16);
1048 mask
= strtoul(CMD_ARGV
[3], NULL
, 16);
1050 command_print(CMD
, "%s Option written.\n"
1051 "INFO: a reset or power cycle is required "
1052 "for the new settings to take effect.", bank
->driver
->name
);
1054 retval
= stm32l4_write_option(bank
, reg_offset
, value
, mask
);
1058 COMMAND_HANDLER(stm32l4_handle_option_load_command
)
1061 return ERROR_COMMAND_SYNTAX_ERROR
;
1063 struct flash_bank
*bank
;
1064 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1065 if (ERROR_OK
!= retval
)
1068 retval
= stm32l4_unlock_reg(bank
);
1069 if (ERROR_OK
!= retval
)
1072 retval
= stm32l4_unlock_option_reg(bank
);
1073 if (ERROR_OK
!= retval
)
1076 /* Write the OBLLAUNCH bit in CR -> Cause device "POR" and option bytes reload */
1077 retval
= stm32l4_write_flash_reg(bank
, STM32_FLASH_CR
, FLASH_OBLLAUNCH
);
1079 command_print(CMD
, "stm32l4x option load (POR) completed.");
1083 COMMAND_HANDLER(stm32l4_handle_lock_command
)
1085 struct target
*target
= NULL
;
1088 return ERROR_COMMAND_SYNTAX_ERROR
;
1090 struct flash_bank
*bank
;
1091 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1092 if (ERROR_OK
!= retval
)
1095 target
= bank
->target
;
1097 if (target
->state
!= TARGET_HALTED
) {
1098 LOG_ERROR("Target not halted");
1099 return ERROR_TARGET_NOT_HALTED
;
1102 /* set readout protection level 1 by erasing the RDP option byte */
1103 if (stm32l4_write_option(bank
, STM32_FLASH_OPTR
, 0, 0x000000FF) != ERROR_OK
) {
1104 command_print(CMD
, "%s failed to lock device", bank
->driver
->name
);
1111 COMMAND_HANDLER(stm32l4_handle_unlock_command
)
1113 struct target
*target
= NULL
;
1116 return ERROR_COMMAND_SYNTAX_ERROR
;
1118 struct flash_bank
*bank
;
1119 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1120 if (ERROR_OK
!= retval
)
1123 target
= bank
->target
;
1125 if (target
->state
!= TARGET_HALTED
) {
1126 LOG_ERROR("Target not halted");
1127 return ERROR_TARGET_NOT_HALTED
;
1130 if (stm32l4_write_option(bank
, STM32_FLASH_OPTR
, RDP_LEVEL_0
, 0x000000FF) != ERROR_OK
) {
1131 command_print(CMD
, "%s failed to unlock device", bank
->driver
->name
);
1138 static const struct command_registration stm32l4_exec_command_handlers
[] = {
1141 .handler
= stm32l4_handle_lock_command
,
1142 .mode
= COMMAND_EXEC
,
1144 .help
= "Lock entire flash device.",
1148 .handler
= stm32l4_handle_unlock_command
,
1149 .mode
= COMMAND_EXEC
,
1151 .help
= "Unlock entire protected flash device.",
1154 .name
= "mass_erase",
1155 .handler
= stm32l4_handle_mass_erase_command
,
1156 .mode
= COMMAND_EXEC
,
1158 .help
= "Erase entire flash device.",
1161 .name
= "option_read",
1162 .handler
= stm32l4_handle_option_read_command
,
1163 .mode
= COMMAND_EXEC
,
1164 .usage
= "bank_id reg_offset",
1165 .help
= "Read & Display device option bytes.",
1168 .name
= "option_write",
1169 .handler
= stm32l4_handle_option_write_command
,
1170 .mode
= COMMAND_EXEC
,
1171 .usage
= "bank_id reg_offset value mask",
1172 .help
= "Write device option bit fields with provided value.",
1175 .name
= "option_load",
1176 .handler
= stm32l4_handle_option_load_command
,
1177 .mode
= COMMAND_EXEC
,
1179 .help
= "Force re-load of device options (will cause device reset).",
1181 COMMAND_REGISTRATION_DONE
1184 static const struct command_registration stm32l4_command_handlers
[] = {
1187 .mode
= COMMAND_ANY
,
1188 .help
= "stm32l4x flash command group",
1190 .chain
= stm32l4_exec_command_handlers
,
1192 COMMAND_REGISTRATION_DONE
1195 const struct flash_driver stm32l4x_flash
= {
1197 .commands
= stm32l4_command_handlers
,
1198 .flash_bank_command
= stm32l4_flash_bank_command
,
1199 .erase
= stm32l4_erase
,
1200 .protect
= stm32l4_protect
,
1201 .write
= stm32l4_write
,
1202 .read
= default_flash_read
,
1203 .probe
= stm32l4_probe
,
1204 .auto_probe
= stm32l4_auto_probe
,
1205 .erase_check
= default_flash_blank_check
,
1206 .protect_check
= stm32l4_protect_check
,
1207 .info
= get_stm32l4_info
,
1208 .free_driver_priv
= default_flash_free_driver_priv
,
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)