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
)
483 while (target_alloc_working_area_try(target
, buffer_size
, &source
) !=
486 if (buffer_size
<= 256) {
487 /* we already allocated the writing code, but failed to get a
488 * buffer, free the algorithm */
489 target_free_working_area(target
, write_algorithm
);
491 LOG_WARNING("no large enough working area available, can't do block memory writes");
492 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
496 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
497 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
499 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* buffer start, status (out) */
500 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* buffer end */
501 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* target address */
502 init_reg_param(®_params
[3], "r3", 32, PARAM_OUT
); /* count (double word-64bit) */
503 init_reg_param(®_params
[4], "r4", 32, PARAM_OUT
); /* flash base */
505 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
506 buf_set_u32(reg_params
[1].value
, 0, 32, source
->address
+ source
->size
);
507 buf_set_u32(reg_params
[2].value
, 0, 32, address
);
508 buf_set_u32(reg_params
[3].value
, 0, 32, count
/ 4);
509 buf_set_u32(reg_params
[4].value
, 0, 32, STM32_FLASH_BASE
);
511 retval
= target_run_flash_async_algorithm(target
, buffer
, count
, 2,
514 source
->address
, source
->size
,
515 write_algorithm
->address
, 0,
518 if (retval
== ERROR_FLASH_OPERATION_FAILED
) {
519 LOG_ERROR("error executing stm32l4 flash write algorithm");
521 uint32_t error
= buf_get_u32(reg_params
[0].value
, 0, 32) & FLASH_ERROR
;
523 if (error
& FLASH_WRPERR
)
524 LOG_ERROR("flash memory write protected");
527 LOG_ERROR("flash write failed = %08" PRIx32
, error
);
528 /* Clear but report errors */
529 target_write_u32(target
, STM32_FLASH_SR
, error
);
534 target_free_working_area(target
, source
);
535 target_free_working_area(target
, write_algorithm
);
537 destroy_reg_param(®_params
[0]);
538 destroy_reg_param(®_params
[1]);
539 destroy_reg_param(®_params
[2]);
540 destroy_reg_param(®_params
[3]);
541 destroy_reg_param(®_params
[4]);
546 static int stm32l4_write(struct flash_bank
*bank
, const uint8_t *buffer
,
547 uint32_t offset
, uint32_t count
)
549 struct target
*target
= bank
->target
;
552 if (bank
->target
->state
!= TARGET_HALTED
) {
553 LOG_ERROR("Target not halted");
554 return ERROR_TARGET_NOT_HALTED
;
558 LOG_WARNING("offset 0x%" PRIx32
" breaks required 8-byte alignment",
560 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
564 LOG_WARNING("Padding %d bytes to keep 8-byte write size",
566 count
= (count
+ 7) & ~7;
567 /* This pads the write chunk with random bytes by overrunning the
568 * write buffer. Padding with the erased pattern 0xff is purely
569 * cosmetical, as 8-byte flash words are ECC secured and the first
570 * write will program the ECC bits. A second write would need
571 * to reprogramm these ECC bits.
572 * But this can only be done after erase!
576 retval
= stm32l4_unlock_reg(target
);
577 if (retval
!= ERROR_OK
)
580 /* Only full double words (8-byte) can be programmed*/
581 retval
= stm32l4_write_block(bank
, buffer
, offset
, count
/ 2);
582 if (retval
!= ERROR_OK
) {
583 LOG_WARNING("block write failed");
587 LOG_WARNING("block write succeeded");
588 return target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
591 static int stm32l4_probe(struct flash_bank
*bank
)
593 struct target
*target
= bank
->target
;
594 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
596 uint16_t flash_size_in_kb
= 0xffff;
597 uint16_t max_flash_size_in_kb
;
600 uint32_t base_address
= 0x08000000;
602 stm32l4_info
->probed
= 0;
604 /* read stm32 device id register */
605 int retval
= target_read_u32(target
, DBGMCU_IDCODE
, &device_id
);
606 if (retval
!= ERROR_OK
)
608 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
610 /* set max flash size depending on family */
611 switch (device_id
& 0xfff) {
614 max_flash_size_in_kb
= 1024;
617 max_flash_size_in_kb
= 512;
620 max_flash_size_in_kb
= 256;
623 LOG_WARNING("Cannot identify target as a STM32L4 family.");
627 /* get flash size from target. */
628 retval
= target_read_u16(target
, FLASH_SIZE_REG
, &flash_size_in_kb
);
630 /* failed reading flash size or flash size invalid (early silicon),
631 * default to max target family */
632 if (retval
!= ERROR_OK
|| flash_size_in_kb
== 0xffff || flash_size_in_kb
== 0) {
633 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
634 max_flash_size_in_kb
);
635 flash_size_in_kb
= max_flash_size_in_kb
;
638 LOG_INFO("flash size = %dkbytes", flash_size_in_kb
);
640 /* did we assign flash size? */
641 assert(flash_size_in_kb
!= 0xffff);
643 /* get options to for DUAL BANK. */
644 retval
= target_read_u32(target
, STM32_FLASH_OPTR
, &options
);
646 if (retval
!= ERROR_OK
)
649 /* only devices with < 1024 kiB may be set to single bank dual banks */
650 if ((flash_size_in_kb
== 1024) || !(options
& OPT_DUALBANK
))
651 stm32l4_info
->option_bytes
.bank_b_start
= 256;
653 stm32l4_info
->option_bytes
.bank_b_start
= flash_size_in_kb
<< 9;
655 /* did we assign flash size? */
656 assert((flash_size_in_kb
!= 0xffff) && flash_size_in_kb
);
658 /* calculate numbers of pages */
659 int num_pages
= flash_size_in_kb
/ 2;
661 /* check that calculation result makes sense */
662 assert(num_pages
> 0);
666 bank
->sectors
= NULL
;
669 bank
->base
= base_address
;
670 bank
->size
= num_pages
* (1 << 11);
671 bank
->num_sectors
= num_pages
;
672 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
674 return ERROR_FAIL
; /* Checkme: What better error to use?*/
676 for (i
= 0; i
< num_pages
; i
++) {
677 bank
->sectors
[i
].offset
= i
<< 11;
678 bank
->sectors
[i
].size
= 1 << 11;
679 bank
->sectors
[i
].is_erased
= -1;
680 bank
->sectors
[i
].is_protected
= 1;
683 stm32l4_info
->probed
= 1;
688 static int stm32l4_auto_probe(struct flash_bank
*bank
)
690 struct stm32l4_flash_bank
*stm32l4_info
= bank
->driver_priv
;
691 if (stm32l4_info
->probed
)
693 return stm32l4_probe(bank
);
696 static int get_stm32l4_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
698 struct target
*target
= bank
->target
;
699 uint32_t dbgmcu_idcode
;
701 /* read stm32 device id register */
702 int retval
= target_read_u32(target
, DBGMCU_IDCODE
, &dbgmcu_idcode
);
703 if (retval
!= ERROR_OK
)
706 uint16_t device_id
= dbgmcu_idcode
& 0xfff;
707 uint8_t rev_id
= dbgmcu_idcode
>> 28;
708 uint8_t rev_minor
= 0;
711 for (i
= 16; i
< 28; i
++) {
712 if (dbgmcu_idcode
& (1 << i
))
718 const char *device_str
;
722 device_str
= "STM32L496/4A6";
726 device_str
= "STM32L475/476/486";
730 device_str
= "STM32L45x/46x";
734 device_str
= "STM32L43x/44x";
738 snprintf(buf
, buf_size
, "Cannot identify target as a STM32L4\n");
742 snprintf(buf
, buf_size
, "%s - Rev: %1d.%02d",
743 device_str
, rev_id
, rev_minor
);
748 COMMAND_HANDLER(stm32l4_handle_lock_command
)
750 struct target
*target
= NULL
;
751 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
754 return ERROR_COMMAND_SYNTAX_ERROR
;
756 struct flash_bank
*bank
;
757 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
758 if (ERROR_OK
!= retval
)
761 stm32l4_info
= bank
->driver_priv
;
762 target
= bank
->target
;
764 if (target
->state
!= TARGET_HALTED
) {
765 LOG_ERROR("Target not halted");
766 return ERROR_TARGET_NOT_HALTED
;
769 if (stm32l4_read_options(bank
) != ERROR_OK
) {
770 command_print(CMD_CTX
, "%s failed to read options",
775 /* set readout protection */
776 stm32l4_info
->option_bytes
.RDP
= 0;
778 if (stm32l4_write_options(bank
) != ERROR_OK
) {
779 command_print(CMD_CTX
, "%s failed to lock device", bank
->driver
->name
);
783 command_print(CMD_CTX
, "%s locked", bank
->driver
->name
);
788 COMMAND_HANDLER(stm32l4_handle_unlock_command
)
790 struct target
*target
= NULL
;
791 struct stm32l4_flash_bank
*stm32l4_info
= NULL
;
794 return ERROR_COMMAND_SYNTAX_ERROR
;
796 struct flash_bank
*bank
;
797 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
798 if (ERROR_OK
!= retval
)
801 stm32l4_info
= bank
->driver_priv
;
802 target
= bank
->target
;
804 if (target
->state
!= TARGET_HALTED
) {
805 LOG_ERROR("Target not halted");
806 return ERROR_TARGET_NOT_HALTED
;
809 if (stm32l4_read_options(bank
) != ERROR_OK
) {
810 command_print(CMD_CTX
, "%s failed to read options", bank
->driver
->name
);
814 /* clear readout protection and complementary option bytes
815 * this will also force a device unlock if set */
816 stm32l4_info
->option_bytes
.RDP
= 0xAA;
818 if (stm32l4_write_options(bank
) != ERROR_OK
) {
819 command_print(CMD_CTX
, "%s failed to unlock device",
824 command_print(CMD_CTX
, "%s unlocked.\n"
825 "INFO: a reset or power cycle is required "
826 "for the new settings to take effect.", bank
->driver
->name
);
831 static int stm32l4_mass_erase(struct flash_bank
*bank
, uint32_t action
)
834 struct target
*target
= bank
->target
;
836 if (target
->state
!= TARGET_HALTED
) {
837 LOG_ERROR("Target not halted");
838 return ERROR_TARGET_NOT_HALTED
;
841 retval
= stm32l4_unlock_reg(target
);
842 if (retval
!= ERROR_OK
)
845 /* mass erase flash memory */
846 retval
= target_write_u32(
847 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), action
);
848 if (retval
!= ERROR_OK
)
850 retval
= target_write_u32(
851 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
),
852 action
| FLASH_STRT
);
853 if (retval
!= ERROR_OK
)
856 retval
= stm32l4_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
857 if (retval
!= ERROR_OK
)
860 retval
= target_write_u32(
861 target
, stm32l4_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
862 if (retval
!= ERROR_OK
)
868 COMMAND_HANDLER(stm32l4_handle_mass_erase_command
)
874 command_print(CMD_CTX
, "stm32x mass_erase <STM32L4 bank>");
875 return ERROR_COMMAND_SYNTAX_ERROR
;
878 struct flash_bank
*bank
;
879 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
880 if (ERROR_OK
!= retval
)
883 action
= FLASH_MER1
| FLASH_MER2
;
884 retval
= stm32l4_mass_erase(bank
, action
);
885 if (retval
== ERROR_OK
) {
886 /* set all sectors as erased */
887 for (i
= 0; i
< bank
->num_sectors
; i
++)
888 bank
->sectors
[i
].is_erased
= 1;
890 command_print(CMD_CTX
, "stm32x mass erase complete");
892 command_print(CMD_CTX
, "stm32x mass erase failed");
898 static const struct command_registration stm32l4_exec_command_handlers
[] = {
901 .handler
= stm32l4_handle_lock_command
,
902 .mode
= COMMAND_EXEC
,
904 .help
= "Lock entire flash device.",
908 .handler
= stm32l4_handle_unlock_command
,
909 .mode
= COMMAND_EXEC
,
911 .help
= "Unlock entire protected flash device.",
914 .name
= "mass_erase",
915 .handler
= stm32l4_handle_mass_erase_command
,
916 .mode
= COMMAND_EXEC
,
918 .help
= "Erase entire flash device.",
920 COMMAND_REGISTRATION_DONE
923 static const struct command_registration stm32l4_command_handlers
[] = {
927 .help
= "stm32l4x flash command group",
929 .chain
= stm32l4_exec_command_handlers
,
931 COMMAND_REGISTRATION_DONE
934 struct flash_driver stm32l4x_flash
= {
936 .commands
= stm32l4_command_handlers
,
937 .flash_bank_command
= stm32l4_flash_bank_command
,
938 .erase
= stm32l4_erase
,
939 .protect
= stm32l4_protect
,
940 .write
= stm32l4_write
,
941 .read
= default_flash_read
,
942 .probe
= stm32l4_probe
,
943 .auto_probe
= stm32l4_auto_probe
,
944 .erase_check
= default_flash_blank_check
,
945 .protect_check
= stm32l4_protect_check
,
946 .info
= get_stm32l4_info
,
947 .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)