1 /***************************************************************************
2 * Copyright (C) 2015 by Uwe Bonnes *
3 * bon@elektron.ikp.physik.tu-darmstadt.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
24 #include <helper/binarybuffer.h>
25 #include <target/algorithm.h>
26 #include <target/armv7m.h>
28 /* STM32L4xxx series for reference.
30 * RM0351 (STM32L4x5/STM32L4x6)
31 * http://www.st.com/resource/en/reference_manual/dm00083560.pdf
33 * RM0394 (STM32L43x/44x/45x/46x)
34 * http://www.st.com/resource/en/reference_manual/dm00151940.pdf
36 * STM32L476RG Datasheet (for erase timing)
37 * http://www.st.com/resource/en/datasheet/stm32l476rg.pdf
39 * The RM0351 devices have normally two banks, but on 512 and 256 kiB devices
40 * an option byte is available to map all sectors to the first bank.
41 * Both STM32 banks are treated as one OpenOCD bank, as other STM32 devices
44 * RM0394 devices have a single bank only.
48 /* Erase time can be as high as 25ms, 10x this and assume it's toast... */
50 #define FLASH_ERASE_TIMEOUT 250
52 #define STM32_FLASH_BASE 0x40022000
53 #define STM32_FLASH_ACR 0x40022000
54 #define STM32_FLASH_KEYR 0x40022008
55 #define STM32_FLASH_OPTKEYR 0x4002200c
56 #define STM32_FLASH_SR 0x40022010
57 #define STM32_FLASH_CR 0x40022014
58 #define STM32_FLASH_OPTR 0x40022020
59 #define STM32_FLASH_WRP1AR 0x4002202c
60 #define STM32_FLASH_WRP2AR 0x40022030
61 #define STM32_FLASH_WRP1BR 0x4002204c
62 #define STM32_FLASH_WRP2BR 0x40022050
64 /* FLASH_CR register bits */
66 #define FLASH_PG (1 << 0)
67 #define FLASH_PER (1 << 1)
68 #define FLASH_MER1 (1 << 2)
69 #define FLASH_PAGE_SHIFT 3
70 #define FLASH_CR_BKER (1 << 11)
71 #define FLASH_MER2 (1 << 15)
72 #define FLASH_STRT (1 << 16)
73 #define FLASH_EOPIE (1 << 24)
74 #define FLASH_ERRIE (1 << 25)
75 #define FLASH_OPTLOCK (1 << 30)
76 #define FLASH_LOCK (1 << 31)
78 /* FLASH_SR register bits */
80 #define FLASH_BSY (1 << 16)
81 /* Fast programming not used => related errors not used*/
82 #define FLASH_PGSERR (1 << 7) /* Programming sequence error */
83 #define FLASH_SIZERR (1 << 6) /* Size error */
84 #define FLASH_PGAERR (1 << 5) /* Programming alignment error */
85 #define FLASH_WRPERR (1 << 4) /* Write protection error */
86 #define FLASH_PROGERR (1 << 3) /* Programming error */
87 #define FLASH_OPERR (1 << 1) /* Operation error */
88 #define FLASH_EOP (1 << 0) /* End of operation */
90 #define FLASH_ERROR (FLASH_PGSERR | FLASH_PGSERR | FLASH_PGAERR | FLASH_WRPERR | FLASH_OPERR)
92 /* STM32_FLASH_OBR bit definitions (reading) */
94 #define OPT_DUALBANK 21 /* dual flash bank only */
96 /* register unlock keys */
98 #define KEY1 0x45670123
99 #define KEY2 0xCDEF89AB
101 /* option register unlock key */
102 #define OPTKEY1 0x08192A3B
103 #define OPTKEY2 0x4C5D6E7F
106 /* other registers */
107 #define DBGMCU_IDCODE 0xE0042000
108 #define FLASH_SIZE_REG 0x1FFF75E0
110 struct stm32l4_options
{
112 uint16_t bank_b_start
;
113 uint8_t user_options
;
122 /* Fixme: Handle PCROP */
125 struct stm32l4_flash_bank
{
126 struct stm32l4_options option_bytes
;
130 /* flash bank stm32l4x <base> <size> 0 0 <target#>
132 FLASH_BANK_COMMAND_HANDLER(stm32l4_flash_bank_command
)
134 struct stm32l4_flash_bank
*stm32l4_info
;
137 return ERROR_COMMAND_SYNTAX_ERROR
;
139 stm32l4_info
= malloc(sizeof(struct stm32l4_flash_bank
));
141 return ERROR_FAIL
; /* Checkme: What better error to use?*/
142 bank
->driver_priv
= stm32l4_info
;
144 stm32l4_info
->probed
= 0;
149 static inline int stm32l4_get_flash_reg(struct flash_bank
*bank
, uint32_t reg
)
154 static inline int stm32l4_get_flash_status(struct flash_bank
*bank
, uint32_t *status
)
156 struct target
*target
= bank
->target
;
157 return target_read_u32(
158 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_SR
), status
);
161 static int stm32l4_wait_status_busy(struct flash_bank
*bank
, int timeout
)
163 struct target
*target
= bank
->target
;
165 int retval
= ERROR_OK
;
167 /* wait for busy to clear */
169 retval
= stm32l4_get_flash_status(bank
, &status
);
170 if (retval
!= ERROR_OK
)
172 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
173 if ((status
& FLASH_BSY
) == 0)
175 if (timeout
-- <= 0) {
176 LOG_ERROR("timed out waiting for flash");
183 if (status
& FLASH_WRPERR
) {
184 LOG_ERROR("stm32x device protected");
188 /* Clear but report errors */
189 if (status
& FLASH_ERROR
) {
190 if (retval
== ERROR_OK
)
192 /* If this operation fails, we ignore it and report the original
195 target_write_u32(target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_SR
),
196 status
& FLASH_ERROR
);
201 static int stm32l4_unlock_reg(struct target
*target
)
205 /* first check if not already unlocked
206 * otherwise writing on STM32_FLASH_KEYR will fail
208 int retval
= target_read_u32(target
, STM32_FLASH_CR
, &ctrl
);
209 if (retval
!= ERROR_OK
)
212 if ((ctrl
& FLASH_LOCK
) == 0)
215 /* unlock flash registers */
216 retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
217 if (retval
!= ERROR_OK
)
220 retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
221 if (retval
!= ERROR_OK
)
224 retval
= target_read_u32(target
, STM32_FLASH_CR
, &ctrl
);
225 if (retval
!= ERROR_OK
)
228 if (ctrl
& FLASH_LOCK
) {
229 LOG_ERROR("flash not unlocked STM32_FLASH_CR: %" PRIx32
, ctrl
);
230 return ERROR_TARGET_FAILURE
;
236 static int stm32l4_unlock_option_reg(struct target
*target
)
240 int retval
= target_read_u32(target
, STM32_FLASH_CR
, &ctrl
);
241 if (retval
!= ERROR_OK
)
244 if ((ctrl
& FLASH_OPTLOCK
) == 0)
247 /* unlock option registers */
248 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, OPTKEY1
);
249 if (retval
!= ERROR_OK
)
252 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, OPTKEY2
);
253 if (retval
!= ERROR_OK
)
256 retval
= target_read_u32(target
, STM32_FLASH_CR
, &ctrl
);
257 if (retval
!= ERROR_OK
)
260 if (ctrl
& FLASH_OPTLOCK
) {
261 LOG_ERROR("options not unlocked STM32_FLASH_CR: %" PRIx32
, ctrl
);
262 return ERROR_TARGET_FAILURE
;
268 static int stm32l4_read_options(struct flash_bank
*bank
)
271 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
272 struct target
*target
= bank
->target
;
274 stm32l4_info
= bank
->driver_priv
;
276 /* read current option bytes */
277 int retval
= target_read_u32(target
, STM32_FLASH_OPTR
, &optiondata
);
278 if (retval
!= ERROR_OK
)
281 stm32l4_info
->option_bytes
.user_options
= (optiondata
>> 8) & 0x3ffff;
282 stm32l4_info
->option_bytes
.RDP
= optiondata
& 0xff;
284 retval
= target_read_u32(target
, STM32_FLASH_WRP1AR
, &optiondata
);
285 if (retval
!= ERROR_OK
)
287 stm32l4_info
->option_bytes
.wpr1a_start
= optiondata
& 0xff;
288 stm32l4_info
->option_bytes
.wpr1a_end
= (optiondata
>> 16) & 0xff;
290 retval
= target_read_u32(target
, STM32_FLASH_WRP2AR
, &optiondata
);
291 if (retval
!= ERROR_OK
)
293 stm32l4_info
->option_bytes
.wpr2a_start
= optiondata
& 0xff;
294 stm32l4_info
->option_bytes
.wpr2a_end
= (optiondata
>> 16) & 0xff;
296 retval
= target_read_u32(target
, STM32_FLASH_WRP1BR
, &optiondata
);
297 if (retval
!= ERROR_OK
)
299 stm32l4_info
->option_bytes
.wpr1b_start
= optiondata
& 0xff;
300 stm32l4_info
->option_bytes
.wpr1b_end
= (optiondata
>> 16) & 0xff;
302 retval
= target_read_u32(target
, STM32_FLASH_WRP2BR
, &optiondata
);
303 if (retval
!= ERROR_OK
)
305 stm32l4_info
->option_bytes
.wpr2b_start
= optiondata
& 0xff;
306 stm32l4_info
->option_bytes
.wpr2b_end
= (optiondata
>> 16) & 0xff;
308 if (stm32l4_info
->option_bytes
.RDP
!= 0xAA)
309 LOG_INFO("Device Security Bit Set");
314 static int stm32l4_write_options(struct flash_bank
*bank
)
316 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
317 struct target
*target
= bank
->target
;
320 stm32l4_info
= bank
->driver_priv
;
325 int retval
= stm32l4_unlock_option_reg(target
);
326 if (retval
!= ERROR_OK
)
328 /* FIXME: Implement Option writing!*/
332 static int stm32l4_protect_check(struct flash_bank
*bank
)
334 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
336 /* read write protection settings */
337 int retval
= stm32l4_read_options(bank
);
338 if (retval
!= ERROR_OK
) {
339 LOG_DEBUG("unable to read option bytes");
343 for (int i
= 0; i
< bank
->num_sectors
; i
++) {
344 if (i
< stm32l4_info
->option_bytes
.bank_b_start
) {
345 if (((i
>= stm32l4_info
->option_bytes
.wpr1a_start
) &&
346 (i
<= stm32l4_info
->option_bytes
.wpr1a_end
)) ||
347 ((i
>= stm32l4_info
->option_bytes
.wpr2a_start
) &&
348 (i
<= stm32l4_info
->option_bytes
.wpr2a_end
)))
349 bank
->sectors
[i
].is_protected
= 1;
351 bank
->sectors
[i
].is_protected
= 0;
354 snb
= i
- stm32l4_info
->option_bytes
.bank_b_start
+ 256;
355 if (((snb
>= stm32l4_info
->option_bytes
.wpr1b_start
) &&
356 (snb
<= stm32l4_info
->option_bytes
.wpr1b_end
)) ||
357 ((snb
>= stm32l4_info
->option_bytes
.wpr2b_start
) &&
358 (snb
<= stm32l4_info
->option_bytes
.wpr2b_end
)))
359 bank
->sectors
[i
].is_protected
= 1;
361 bank
->sectors
[i
].is_protected
= 0;
367 static int stm32l4_erase(struct flash_bank
*bank
, int first
, int last
)
369 struct target
*target
= bank
->target
;
372 assert(first
< bank
->num_sectors
);
373 assert(last
< bank
->num_sectors
);
375 if (bank
->target
->state
!= TARGET_HALTED
) {
376 LOG_ERROR("Target not halted");
377 return ERROR_TARGET_NOT_HALTED
;
381 retval
= stm32l4_unlock_reg(target
);
382 if (retval
!= ERROR_OK
)
387 To erase a sector, follow the procedure below:
388 1. Check that no Flash memory operation is ongoing by
389 checking the BSY bit in the FLASH_SR register
390 2. Set the PER bit and select the page and bank
391 you wish to erase in the FLASH_CR register
392 3. Set the STRT bit in the FLASH_CR register
393 4. Wait for the BSY bit to be cleared
395 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
397 for (i
= first
; i
<= last
; i
++) {
398 uint32_t erase_flags
;
399 erase_flags
= FLASH_PER
| FLASH_STRT
;
401 if (i
>= stm32l4_info
->option_bytes
.bank_b_start
) {
403 snb
= (i
- stm32l4_info
->option_bytes
.bank_b_start
) + 256;
404 erase_flags
|= snb
<< FLASH_PAGE_SHIFT
| FLASH_CR_BKER
;
406 erase_flags
|= i
<< FLASH_PAGE_SHIFT
;
407 retval
= target_write_u32(target
,
408 stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), erase_flags
);
409 if (retval
!= ERROR_OK
)
412 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
413 if (retval
!= ERROR_OK
)
416 bank
->sectors
[i
].is_erased
= 1;
419 retval
= target_write_u32(
420 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
421 if (retval
!= ERROR_OK
)
427 static int stm32l4_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
429 struct target
*target
= bank
->target
;
430 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
432 if (target
->state
!= TARGET_HALTED
) {
433 LOG_ERROR("Target not halted");
434 return ERROR_TARGET_NOT_HALTED
;
437 /* read protection settings */
438 int retval
= stm32l4_read_options(bank
);
439 if (retval
!= ERROR_OK
) {
440 LOG_DEBUG("unable to read option bytes");
445 /* FIXME: Write First and last in a valid WRPxx_start/end combo*/
446 retval
= stm32l4_write_options(bank
);
447 if (retval
!= ERROR_OK
)
453 /* Count is in halfwords */
454 static int stm32l4_write_block(struct flash_bank
*bank
, const uint8_t *buffer
,
455 uint32_t offset
, uint32_t count
)
457 struct target
*target
= bank
->target
;
458 uint32_t buffer_size
= 16384;
459 struct working_area
*write_algorithm
;
460 struct working_area
*source
;
461 uint32_t address
= bank
->base
+ offset
;
462 struct reg_param reg_params
[5];
463 struct armv7m_algorithm armv7m_info
;
464 int retval
= ERROR_OK
;
466 static const uint8_t stm32l4_flash_write_code
[] = {
467 #include "../../../contrib/loaders/flash/stm32/stm32l4x.inc"
470 if (target_alloc_working_area(target
, sizeof(stm32l4_flash_write_code
),
471 &write_algorithm
) != ERROR_OK
) {
472 LOG_WARNING("no working area available, can't do block memory writes");
473 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
476 retval
= target_write_buffer(target
, write_algorithm
->address
,
477 sizeof(stm32l4_flash_write_code
),
478 stm32l4_flash_write_code
);
479 if (retval
!= ERROR_OK
) {
480 target_free_working_area(target
, write_algorithm
);
485 while (target_alloc_working_area_try(target
, buffer_size
, &source
) !=
488 if (buffer_size
<= 256) {
489 /* we already allocated the writing code, but failed to get a
490 * buffer, free the algorithm */
491 target_free_working_area(target
, write_algorithm
);
493 LOG_WARNING("no large enough working area available, can't do block memory writes");
494 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
498 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
499 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
501 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* buffer start, status (out) */
502 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* buffer end */
503 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* target address */
504 init_reg_param(®_params
[3], "r3", 32, PARAM_OUT
); /* count (double word-64bit) */
505 init_reg_param(®_params
[4], "r4", 32, PARAM_OUT
); /* flash base */
507 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
508 buf_set_u32(reg_params
[1].value
, 0, 32, source
->address
+ source
->size
);
509 buf_set_u32(reg_params
[2].value
, 0, 32, address
);
510 buf_set_u32(reg_params
[3].value
, 0, 32, count
/ 4);
511 buf_set_u32(reg_params
[4].value
, 0, 32, STM32_FLASH_BASE
);
513 retval
= target_run_flash_async_algorithm(target
, buffer
, count
, 2,
516 source
->address
, source
->size
,
517 write_algorithm
->address
, 0,
520 if (retval
== ERROR_FLASH_OPERATION_FAILED
) {
521 LOG_ERROR("error executing stm32l4 flash write algorithm");
523 uint32_t error
= buf_get_u32(reg_params
[0].value
, 0, 32) & FLASH_ERROR
;
525 if (error
& FLASH_WRPERR
)
526 LOG_ERROR("flash memory write protected");
529 LOG_ERROR("flash write failed = %08" PRIx32
, error
);
530 /* Clear but report errors */
531 target_write_u32(target
, STM32_FLASH_SR
, error
);
536 target_free_working_area(target
, source
);
537 target_free_working_area(target
, write_algorithm
);
539 destroy_reg_param(®_params
[0]);
540 destroy_reg_param(®_params
[1]);
541 destroy_reg_param(®_params
[2]);
542 destroy_reg_param(®_params
[3]);
543 destroy_reg_param(®_params
[4]);
548 static int stm32l4_write(struct flash_bank
*bank
, const uint8_t *buffer
,
549 uint32_t offset
, uint32_t count
)
551 struct target
*target
= bank
->target
;
554 if (bank
->target
->state
!= TARGET_HALTED
) {
555 LOG_ERROR("Target not halted");
556 return ERROR_TARGET_NOT_HALTED
;
560 LOG_WARNING("offset 0x%" PRIx32
" breaks required 8-byte alignment",
562 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
566 LOG_WARNING("Padding %d bytes to keep 8-byte write size",
568 count
= (count
+ 7) & ~7;
569 /* This pads the write chunk with random bytes by overrunning the
570 * write buffer. Padding with the erased pattern 0xff is purely
571 * cosmetical, as 8-byte flash words are ECC secured and the first
572 * write will program the ECC bits. A second write would need
573 * to reprogramm these ECC bits.
574 * But this can only be done after erase!
578 retval
= stm32l4_unlock_reg(target
);
579 if (retval
!= ERROR_OK
)
582 /* Only full double words (8-byte) can be programmed*/
583 retval
= stm32l4_write_block(bank
, buffer
, offset
, count
/ 2);
584 if (retval
!= ERROR_OK
) {
585 LOG_WARNING("block write failed");
589 LOG_WARNING("block write succeeded");
590 return target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
593 static int stm32l4_probe(struct flash_bank
*bank
)
595 struct target
*target
= bank
->target
;
596 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
598 uint16_t flash_size_in_kb
= 0xffff;
599 uint16_t max_flash_size_in_kb
;
602 uint32_t base_address
= 0x08000000;
604 stm32l4_info
->probed
= 0;
606 /* read stm32 device id register */
607 int retval
= target_read_u32(target
, DBGMCU_IDCODE
, &device_id
);
608 if (retval
!= ERROR_OK
)
610 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
612 /* set max flash size depending on family */
613 switch (device_id
& 0xfff) {
616 max_flash_size_in_kb
= 1024;
619 max_flash_size_in_kb
= 512;
622 max_flash_size_in_kb
= 256;
625 LOG_WARNING("Cannot identify target as a STM32L4 family.");
629 /* get flash size from target. */
630 retval
= target_read_u16(target
, FLASH_SIZE_REG
, &flash_size_in_kb
);
632 /* failed reading flash size or flash size invalid (early silicon),
633 * default to max target family */
634 if (retval
!= ERROR_OK
|| flash_size_in_kb
== 0xffff || flash_size_in_kb
== 0) {
635 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
636 max_flash_size_in_kb
);
637 flash_size_in_kb
= max_flash_size_in_kb
;
640 LOG_INFO("flash size = %dkbytes", flash_size_in_kb
);
642 /* did we assign flash size? */
643 assert(flash_size_in_kb
!= 0xffff);
645 /* get options to for DUAL BANK. */
646 retval
= target_read_u32(target
, STM32_FLASH_OPTR
, &options
);
648 if (retval
!= ERROR_OK
)
651 /* only devices with < 1024 kiB may be set to single bank dual banks */
652 if ((flash_size_in_kb
== 1024) || !(options
& OPT_DUALBANK
))
653 stm32l4_info
->option_bytes
.bank_b_start
= 256;
655 stm32l4_info
->option_bytes
.bank_b_start
= flash_size_in_kb
<< 9;
657 /* did we assign flash size? */
658 assert((flash_size_in_kb
!= 0xffff) && flash_size_in_kb
);
660 /* calculate numbers of pages */
661 int num_pages
= flash_size_in_kb
/ 2;
663 /* check that calculation result makes sense */
664 assert(num_pages
> 0);
668 bank
->sectors
= NULL
;
671 bank
->base
= base_address
;
672 bank
->size
= num_pages
* (1 << 11);
673 bank
->num_sectors
= num_pages
;
674 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
676 return ERROR_FAIL
; /* Checkme: What better error to use?*/
678 for (i
= 0; i
< num_pages
; i
++) {
679 bank
->sectors
[i
].offset
= i
<< 11;
680 bank
->sectors
[i
].size
= 1 << 11;
681 bank
->sectors
[i
].is_erased
= -1;
682 bank
->sectors
[i
].is_protected
= 1;
685 stm32l4_info
->probed
= 1;
690 static int stm32l4_auto_probe(struct flash_bank
*bank
)
692 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
693 if (stm32l4_info
->probed
)
695 return stm32l4_probe(bank
);
698 static int get_stm32l4_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
700 struct target
*target
= bank
->target
;
701 uint32_t dbgmcu_idcode
;
703 /* read stm32 device id register */
704 int retval
= target_read_u32(target
, DBGMCU_IDCODE
, &dbgmcu_idcode
);
705 if (retval
!= ERROR_OK
)
708 uint16_t device_id
= dbgmcu_idcode
& 0xfff;
709 uint8_t rev_id
= dbgmcu_idcode
>> 28;
710 uint8_t rev_minor
= 0;
713 for (i
= 16; i
< 28; i
++) {
714 if (dbgmcu_idcode
& (1 << i
))
720 const char *device_str
;
724 device_str
= "STM32L496/4A6";
728 device_str
= "STM32L475/476/486";
732 device_str
= "STM32L45x/46x";
736 device_str
= "STM32L43x/44x";
740 snprintf(buf
, buf_size
, "Cannot identify target as a STM32L4\n");
744 snprintf(buf
, buf_size
, "%s - Rev: %1d.%02d",
745 device_str
, rev_id
, rev_minor
);
750 COMMAND_HANDLER(stm32l4_handle_lock_command
)
752 struct target
*target
= NULL
;
753 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
756 return ERROR_COMMAND_SYNTAX_ERROR
;
758 struct flash_bank
*bank
;
759 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
760 if (ERROR_OK
!= retval
)
763 stm32l4_info
= bank
->driver_priv
;
764 target
= bank
->target
;
766 if (target
->state
!= TARGET_HALTED
) {
767 LOG_ERROR("Target not halted");
768 return ERROR_TARGET_NOT_HALTED
;
771 if (stm32l4_read_options(bank
) != ERROR_OK
) {
772 command_print(CMD_CTX
, "%s failed to read options",
777 /* set readout protection */
778 stm32l4_info
->option_bytes
.RDP
= 0;
780 if (stm32l4_write_options(bank
) != ERROR_OK
) {
781 command_print(CMD_CTX
, "%s failed to lock device", bank
->driver
->name
);
785 command_print(CMD_CTX
, "%s locked", bank
->driver
->name
);
790 COMMAND_HANDLER(stm32l4_handle_unlock_command
)
792 struct target
*target
= NULL
;
793 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
796 return ERROR_COMMAND_SYNTAX_ERROR
;
798 struct flash_bank
*bank
;
799 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
800 if (ERROR_OK
!= retval
)
803 stm32l4_info
= bank
->driver_priv
;
804 target
= bank
->target
;
806 if (target
->state
!= TARGET_HALTED
) {
807 LOG_ERROR("Target not halted");
808 return ERROR_TARGET_NOT_HALTED
;
811 if (stm32l4_read_options(bank
) != ERROR_OK
) {
812 command_print(CMD_CTX
, "%s failed to read options", bank
->driver
->name
);
816 /* clear readout protection and complementary option bytes
817 * this will also force a device unlock if set */
818 stm32l4_info
->option_bytes
.RDP
= 0xAA;
820 if (stm32l4_write_options(bank
) != ERROR_OK
) {
821 command_print(CMD_CTX
, "%s failed to unlock device",
826 command_print(CMD_CTX
, "%s unlocked.\n"
827 "INFO: a reset or power cycle is required "
828 "for the new settings to take effect.", bank
->driver
->name
);
833 static int stm32l4_mass_erase(struct flash_bank
*bank
, uint32_t action
)
836 struct target
*target
= bank
->target
;
838 if (target
->state
!= TARGET_HALTED
) {
839 LOG_ERROR("Target not halted");
840 return ERROR_TARGET_NOT_HALTED
;
843 retval
= stm32l4_unlock_reg(target
);
844 if (retval
!= ERROR_OK
)
847 /* mass erase flash memory */
848 retval
= target_write_u32(
849 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), action
);
850 if (retval
!= ERROR_OK
)
852 retval
= target_write_u32(
853 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
),
854 action
| FLASH_STRT
);
855 if (retval
!= ERROR_OK
)
858 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
859 if (retval
!= ERROR_OK
)
862 retval
= target_write_u32(
863 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
864 if (retval
!= ERROR_OK
)
870 COMMAND_HANDLER(stm32l4_handle_mass_erase_command
)
876 command_print(CMD_CTX
, "stm32x mass_erase <STM32L4 bank>");
877 return ERROR_COMMAND_SYNTAX_ERROR
;
880 struct flash_bank
*bank
;
881 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
882 if (ERROR_OK
!= retval
)
885 action
= FLASH_MER1
| FLASH_MER2
;
886 retval
= stm32l4_mass_erase(bank
, action
);
887 if (retval
== ERROR_OK
) {
888 /* set all sectors as erased */
889 for (i
= 0; i
< bank
->num_sectors
; i
++)
890 bank
->sectors
[i
].is_erased
= 1;
892 command_print(CMD_CTX
, "stm32x mass erase complete");
894 command_print(CMD_CTX
, "stm32x mass erase failed");
900 static const struct command_registration stm32l4_exec_command_handlers
[] = {
903 .handler
= stm32l4_handle_lock_command
,
904 .mode
= COMMAND_EXEC
,
906 .help
= "Lock entire flash device.",
910 .handler
= stm32l4_handle_unlock_command
,
911 .mode
= COMMAND_EXEC
,
913 .help
= "Unlock entire protected flash device.",
916 .name
= "mass_erase",
917 .handler
= stm32l4_handle_mass_erase_command
,
918 .mode
= COMMAND_EXEC
,
920 .help
= "Erase entire flash device.",
922 COMMAND_REGISTRATION_DONE
925 static const struct command_registration stm32l4_command_handlers
[] = {
929 .help
= "stm32l4x flash command group",
931 .chain
= stm32l4_exec_command_handlers
,
933 COMMAND_REGISTRATION_DONE
936 struct flash_driver stm32l4x_flash
= {
938 .commands
= stm32l4_command_handlers
,
939 .flash_bank_command
= stm32l4_flash_bank_command
,
940 .erase
= stm32l4_erase
,
941 .protect
= stm32l4_protect
,
942 .write
= stm32l4_write
,
943 .read
= default_flash_read
,
944 .probe
= stm32l4_probe
,
945 .auto_probe
= stm32l4_auto_probe
,
946 .erase_check
= default_flash_blank_check
,
947 .protect_check
= stm32l4_protect_check
,
948 .info
= get_stm32l4_info
,
949 .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)