1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath *
5 * Dominic.Rath@gmx.de *
7 * Copyright (C) 2008 by Spencer Oliver *
8 * spen@spen-soft.co.uk *
10 * Copyright (C) 2011 by Andreas Fritiofson *
11 * andreas.fritiofson@gmail.com *
12 ***************************************************************************/
21 #include <helper/binarybuffer.h>
22 #include <target/algorithm.h>
23 #include <target/cortex_m.h>
25 /* stm32x register locations */
27 #define FLASH_REG_BASE_B0 0x40022000
28 #define FLASH_REG_BASE_B1 0x40022040
30 #define STM32_FLASH_ACR 0x00
31 #define STM32_FLASH_KEYR 0x04
32 #define STM32_FLASH_OPTKEYR 0x08
33 #define STM32_FLASH_SR 0x0C
34 #define STM32_FLASH_CR 0x10
35 #define STM32_FLASH_AR 0x14
36 #define STM32_FLASH_OBR 0x1C
37 #define STM32_FLASH_WRPR 0x20
39 /* TODO: Check if code using these really should be hard coded to bank 0.
40 * There are valid cases, on dual flash devices the protection of the
41 * second bank is done on the bank0 reg's. */
42 #define STM32_FLASH_ACR_B0 0x40022000
43 #define STM32_FLASH_KEYR_B0 0x40022004
44 #define STM32_FLASH_OPTKEYR_B0 0x40022008
45 #define STM32_FLASH_SR_B0 0x4002200C
46 #define STM32_FLASH_CR_B0 0x40022010
47 #define STM32_FLASH_AR_B0 0x40022014
48 #define STM32_FLASH_OBR_B0 0x4002201C
49 #define STM32_FLASH_WRPR_B0 0x40022020
51 /* option byte location */
53 #define STM32_OB_RDP 0x1FFFF800
54 #define STM32_OB_USER 0x1FFFF802
55 #define STM32_OB_DATA0 0x1FFFF804
56 #define STM32_OB_DATA1 0x1FFFF806
57 #define STM32_OB_WRP0 0x1FFFF808
58 #define STM32_OB_WRP1 0x1FFFF80A
59 #define STM32_OB_WRP2 0x1FFFF80C
60 #define STM32_OB_WRP3 0x1FFFF80E
62 /* FLASH_CR register bits */
64 #define FLASH_PG (1 << 0)
65 #define FLASH_PER (1 << 1)
66 #define FLASH_MER (1 << 2)
67 #define FLASH_OPTPG (1 << 4)
68 #define FLASH_OPTER (1 << 5)
69 #define FLASH_STRT (1 << 6)
70 #define FLASH_LOCK (1 << 7)
71 #define FLASH_OPTWRE (1 << 9)
72 #define FLASH_OBL_LAUNCH (1 << 13) /* except stm32f1x series */
74 /* FLASH_SR register bits */
76 #define FLASH_BSY (1 << 0)
77 #define FLASH_PGERR (1 << 2)
78 #define FLASH_WRPRTERR (1 << 4)
79 #define FLASH_EOP (1 << 5)
81 /* STM32_FLASH_OBR bit definitions (reading) */
86 #define OPT_RDRSTSTOP 3
87 #define OPT_RDRSTSTDBY 4
88 #define OPT_BFB2 5 /* dual flash bank only */
90 /* register unlock keys */
92 #define KEY1 0x45670123
93 #define KEY2 0xCDEF89AB
97 #define FLASH_WRITE_TIMEOUT 10
98 #define FLASH_ERASE_TIMEOUT 100
100 struct stm32x_options
{
107 struct stm32x_flash_bank
{
108 struct stm32x_options option_bytes
;
113 /* used to access dual flash bank stm32xl */
114 bool can_load_options
;
115 uint32_t register_base
;
117 int user_data_offset
;
119 uint32_t user_bank_size
;
122 static int stm32x_mass_erase(struct flash_bank
*bank
);
123 static int stm32x_write_block(struct flash_bank
*bank
, const uint8_t *buffer
,
124 uint32_t address
, uint32_t hwords_count
);
126 /* flash bank stm32x <base> <size> 0 0 <target#>
128 FLASH_BANK_COMMAND_HANDLER(stm32x_flash_bank_command
)
130 struct stm32x_flash_bank
*stm32x_info
;
133 return ERROR_COMMAND_SYNTAX_ERROR
;
135 stm32x_info
= malloc(sizeof(struct stm32x_flash_bank
));
137 bank
->driver_priv
= stm32x_info
;
138 stm32x_info
->probed
= false;
139 stm32x_info
->has_dual_banks
= false;
140 stm32x_info
->can_load_options
= false;
141 stm32x_info
->register_base
= FLASH_REG_BASE_B0
;
142 stm32x_info
->user_bank_size
= bank
->size
;
144 /* The flash write must be aligned to a halfword boundary */
145 bank
->write_start_alignment
= bank
->write_end_alignment
= 2;
150 static inline int stm32x_get_flash_reg(struct flash_bank
*bank
, uint32_t reg
)
152 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
153 return reg
+ stm32x_info
->register_base
;
156 static inline int stm32x_get_flash_status(struct flash_bank
*bank
, uint32_t *status
)
158 struct target
*target
= bank
->target
;
159 return target_read_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
), status
);
162 static int stm32x_wait_status_busy(struct flash_bank
*bank
, int timeout
)
164 struct target
*target
= bank
->target
;
166 int retval
= ERROR_OK
;
168 /* wait for busy to clear */
170 retval
= stm32x_get_flash_status(bank
, &status
);
171 if (retval
!= ERROR_OK
)
173 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
174 if ((status
& FLASH_BSY
) == 0)
176 if (timeout
-- <= 0) {
177 LOG_ERROR("timed out waiting for flash");
178 return ERROR_FLASH_BUSY
;
183 if (status
& FLASH_WRPRTERR
) {
184 LOG_ERROR("stm32x device protected");
185 retval
= ERROR_FLASH_PROTECTED
;
188 if (status
& FLASH_PGERR
) {
189 LOG_ERROR("stm32x device programming failed / flash not erased");
190 retval
= ERROR_FLASH_OPERATION_FAILED
;
193 /* Clear but report errors */
194 if (status
& (FLASH_WRPRTERR
| FLASH_PGERR
)) {
195 /* If this operation fails, we ignore it and report the original
198 target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
),
199 FLASH_WRPRTERR
| FLASH_PGERR
);
204 static int stm32x_check_operation_supported(struct flash_bank
*bank
)
206 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
208 /* if we have a dual flash bank device then
209 * we need to perform option byte stuff on bank0 only */
210 if (stm32x_info
->register_base
!= FLASH_REG_BASE_B0
) {
211 LOG_ERROR("Option byte operations must use bank 0");
212 return ERROR_FLASH_OPERATION_FAILED
;
218 static int stm32x_read_options(struct flash_bank
*bank
)
220 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
221 struct target
*target
= bank
->target
;
222 uint32_t option_bytes
;
225 /* read user and read protection option bytes, user data option bytes */
226 retval
= target_read_u32(target
, STM32_FLASH_OBR_B0
, &option_bytes
);
227 if (retval
!= ERROR_OK
)
230 stm32x_info
->option_bytes
.rdp
= (option_bytes
& (1 << OPT_READOUT
)) ? 0 : stm32x_info
->default_rdp
;
231 stm32x_info
->option_bytes
.user
= (option_bytes
>> stm32x_info
->option_offset
>> 2) & 0xff;
232 stm32x_info
->option_bytes
.data
= (option_bytes
>> stm32x_info
->user_data_offset
) & 0xffff;
234 /* read write protection option bytes */
235 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &stm32x_info
->option_bytes
.protection
);
236 if (retval
!= ERROR_OK
)
242 static int stm32x_erase_options(struct flash_bank
*bank
)
244 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
245 struct target
*target
= bank
->target
;
247 /* read current options */
248 stm32x_read_options(bank
);
250 /* unlock flash registers */
251 int retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY1
);
252 if (retval
!= ERROR_OK
)
254 retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY2
);
255 if (retval
!= ERROR_OK
)
258 /* unlock option flash registers */
259 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY1
);
260 if (retval
!= ERROR_OK
)
262 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY2
);
263 if (retval
!= ERROR_OK
)
266 /* erase option bytes */
267 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTER
| FLASH_OPTWRE
);
268 if (retval
!= ERROR_OK
)
270 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTER
| FLASH_STRT
| FLASH_OPTWRE
);
271 if (retval
!= ERROR_OK
)
274 retval
= stm32x_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
275 if (retval
!= ERROR_OK
)
278 /* clear read protection option byte
279 * this will also force a device unlock if set */
280 stm32x_info
->option_bytes
.rdp
= stm32x_info
->default_rdp
;
285 target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_LOCK
);
289 static int stm32x_write_options(struct flash_bank
*bank
)
291 struct stm32x_flash_bank
*stm32x_info
= NULL
;
292 struct target
*target
= bank
->target
;
294 stm32x_info
= bank
->driver_priv
;
296 /* unlock flash registers */
297 int retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY1
);
298 if (retval
!= ERROR_OK
)
300 retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY2
);
301 if (retval
!= ERROR_OK
)
304 /* unlock option flash registers */
305 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY1
);
306 if (retval
!= ERROR_OK
)
308 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY2
);
309 if (retval
!= ERROR_OK
)
312 /* program option bytes */
313 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTPG
| FLASH_OPTWRE
);
314 if (retval
!= ERROR_OK
)
317 uint8_t opt_bytes
[16];
319 target_buffer_set_u16(target
, opt_bytes
, stm32x_info
->option_bytes
.rdp
);
320 target_buffer_set_u16(target
, opt_bytes
+ 2, stm32x_info
->option_bytes
.user
);
321 target_buffer_set_u16(target
, opt_bytes
+ 4, stm32x_info
->option_bytes
.data
& 0xff);
322 target_buffer_set_u16(target
, opt_bytes
+ 6, (stm32x_info
->option_bytes
.data
>> 8) & 0xff);
323 target_buffer_set_u16(target
, opt_bytes
+ 8, stm32x_info
->option_bytes
.protection
& 0xff);
324 target_buffer_set_u16(target
, opt_bytes
+ 10, (stm32x_info
->option_bytes
.protection
>> 8) & 0xff);
325 target_buffer_set_u16(target
, opt_bytes
+ 12, (stm32x_info
->option_bytes
.protection
>> 16) & 0xff);
326 target_buffer_set_u16(target
, opt_bytes
+ 14, (stm32x_info
->option_bytes
.protection
>> 24) & 0xff);
328 /* Block write is preferred in favour of operation with ancient ST-Link
329 * firmwares without 16-bit memory access. See
330 * 480: flash: stm32f1x: write option bytes using the loader
331 * https://review.openocd.org/c/openocd/+/480
333 retval
= stm32x_write_block(bank
, opt_bytes
, STM32_OB_RDP
, sizeof(opt_bytes
) / 2);
337 int retval2
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_LOCK
);
338 if (retval
== ERROR_OK
)
344 static int stm32x_protect_check(struct flash_bank
*bank
)
346 struct target
*target
= bank
->target
;
349 int retval
= stm32x_check_operation_supported(bank
);
350 if (retval
!= ERROR_OK
)
353 /* medium density - each bit refers to a 4 sector protection block
354 * high density - each bit refers to a 2 sector protection block
355 * bit 31 refers to all remaining sectors in a bank */
356 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &protection
);
357 if (retval
!= ERROR_OK
)
360 for (unsigned int i
= 0; i
< bank
->num_prot_blocks
; i
++)
361 bank
->prot_blocks
[i
].is_protected
= (protection
& (1 << i
)) ? 0 : 1;
366 static int stm32x_erase(struct flash_bank
*bank
, unsigned int first
,
369 struct target
*target
= bank
->target
;
371 if (bank
->target
->state
!= TARGET_HALTED
) {
372 LOG_ERROR("Target not halted");
373 return ERROR_TARGET_NOT_HALTED
;
376 if ((first
== 0) && (last
== (bank
->num_sectors
- 1)))
377 return stm32x_mass_erase(bank
);
379 /* unlock flash registers */
380 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
381 if (retval
!= ERROR_OK
)
383 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
384 if (retval
!= ERROR_OK
)
387 for (unsigned int i
= first
; i
<= last
; i
++) {
388 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
);
389 if (retval
!= ERROR_OK
)
391 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_AR
),
392 bank
->base
+ bank
->sectors
[i
].offset
);
393 if (retval
!= ERROR_OK
)
395 retval
= target_write_u32(target
,
396 stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
| FLASH_STRT
);
397 if (retval
!= ERROR_OK
)
400 retval
= stm32x_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
401 if (retval
!= ERROR_OK
)
407 int retval2
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
408 if (retval
== ERROR_OK
)
414 static int stm32x_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
417 struct target
*target
= bank
->target
;
418 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
420 if (target
->state
!= TARGET_HALTED
) {
421 LOG_ERROR("Target not halted");
422 return ERROR_TARGET_NOT_HALTED
;
425 int retval
= stm32x_check_operation_supported(bank
);
426 if (retval
!= ERROR_OK
)
429 retval
= stm32x_erase_options(bank
);
430 if (retval
!= ERROR_OK
) {
431 LOG_ERROR("stm32x failed to erase options");
435 for (unsigned int i
= first
; i
<= last
; i
++) {
437 stm32x_info
->option_bytes
.protection
&= ~(1 << i
);
439 stm32x_info
->option_bytes
.protection
|= (1 << i
);
442 return stm32x_write_options(bank
);
445 static int stm32x_write_block_async(struct flash_bank
*bank
, const uint8_t *buffer
,
446 uint32_t address
, uint32_t hwords_count
)
448 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
449 struct target
*target
= bank
->target
;
450 uint32_t buffer_size
;
451 struct working_area
*write_algorithm
;
452 struct working_area
*source
;
453 struct armv7m_algorithm armv7m_info
;
456 static const uint8_t stm32x_flash_write_code
[] = {
457 #include "../../../contrib/loaders/flash/stm32/stm32f1x.inc"
460 /* flash write code */
461 if (target_alloc_working_area(target
, sizeof(stm32x_flash_write_code
),
462 &write_algorithm
) != ERROR_OK
) {
463 LOG_WARNING("no working area available, can't do block memory writes");
464 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
467 retval
= target_write_buffer(target
, write_algorithm
->address
,
468 sizeof(stm32x_flash_write_code
), stm32x_flash_write_code
);
469 if (retval
!= ERROR_OK
) {
470 target_free_working_area(target
, write_algorithm
);
475 buffer_size
= target_get_working_area_avail(target
);
476 buffer_size
= MIN(hwords_count
* 2, MAX(buffer_size
, 256));
477 /* Normally we allocate all available working area.
478 * MIN shrinks buffer_size if the size of the written block is smaller.
479 * MAX prevents using async algo if the available working area is smaller
480 * than 256, the following allocation fails with
481 * ERROR_TARGET_RESOURCE_NOT_AVAILABLE and slow flashing takes place.
484 retval
= target_alloc_working_area(target
, buffer_size
, &source
);
485 /* Allocated size is always 32-bit word aligned */
486 if (retval
!= ERROR_OK
) {
487 target_free_working_area(target
, write_algorithm
);
488 LOG_WARNING("no large enough working area available, can't do block memory writes");
489 /* target_alloc_working_area() may return ERROR_FAIL if area backup fails:
490 * convert any error to ERROR_TARGET_RESOURCE_NOT_AVAILABLE
492 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
495 struct reg_param reg_params
[5];
497 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* flash base (in), status (out) */
498 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* count (halfword-16bit) */
499 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* buffer start */
500 init_reg_param(®_params
[3], "r3", 32, PARAM_OUT
); /* buffer end */
501 init_reg_param(®_params
[4], "r4", 32, PARAM_IN_OUT
); /* target address */
503 buf_set_u32(reg_params
[0].value
, 0, 32, stm32x_info
->register_base
);
504 buf_set_u32(reg_params
[1].value
, 0, 32, hwords_count
);
505 buf_set_u32(reg_params
[2].value
, 0, 32, source
->address
);
506 buf_set_u32(reg_params
[3].value
, 0, 32, source
->address
+ source
->size
);
507 buf_set_u32(reg_params
[4].value
, 0, 32, address
);
509 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
510 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
512 retval
= target_run_flash_async_algorithm(target
, buffer
, hwords_count
, 2,
514 ARRAY_SIZE(reg_params
), reg_params
,
515 source
->address
, source
->size
,
516 write_algorithm
->address
, 0,
519 if (retval
== ERROR_FLASH_OPERATION_FAILED
) {
520 /* Actually we just need to check for programming errors
521 * stm32x_wait_status_busy also reports error and clears status bits.
523 * Target algo returns flash status in r0 only if properly finished.
524 * It is safer to re-read status register.
526 int retval2
= stm32x_wait_status_busy(bank
, 5);
527 if (retval2
!= ERROR_OK
)
530 LOG_ERROR("flash write failed just before address 0x%"PRIx32
,
531 buf_get_u32(reg_params
[4].value
, 0, 32));
534 for (unsigned int i
= 0; i
< ARRAY_SIZE(reg_params
); i
++)
535 destroy_reg_param(®_params
[i
]);
537 target_free_working_area(target
, source
);
538 target_free_working_area(target
, write_algorithm
);
543 static int stm32x_write_block_riscv(struct flash_bank
*bank
, const uint8_t *buffer
,
544 uint32_t address
, uint32_t hwords_count
)
546 struct target
*target
= bank
->target
;
547 uint32_t buffer_size
;
548 struct working_area
*write_algorithm
;
549 struct working_area
*source
;
550 static const uint8_t gd32vf103_flash_write_code
[] = {
551 #include "../../../contrib/loaders/flash/gd32vf103/gd32vf103.inc"
554 /* flash write code */
555 if (target_alloc_working_area(target
, sizeof(gd32vf103_flash_write_code
),
556 &write_algorithm
) != ERROR_OK
) {
557 LOG_WARNING("no working area available, can't do block memory writes");
558 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
561 int retval
= target_write_buffer(target
, write_algorithm
->address
,
562 sizeof(gd32vf103_flash_write_code
), gd32vf103_flash_write_code
);
563 if (retval
!= ERROR_OK
) {
564 target_free_working_area(target
, write_algorithm
);
569 buffer_size
= target_get_working_area_avail(target
);
570 buffer_size
= MIN(hwords_count
* 2, MAX(buffer_size
, 256));
572 retval
= target_alloc_working_area(target
, buffer_size
, &source
);
573 /* Allocated size is always word aligned */
574 if (retval
!= ERROR_OK
) {
575 target_free_working_area(target
, write_algorithm
);
576 LOG_WARNING("no large enough working area available, can't do block memory writes");
577 /* target_alloc_working_area() may return ERROR_FAIL if area backup fails:
578 * convert any error to ERROR_TARGET_RESOURCE_NOT_AVAILABLE
580 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
583 struct reg_param reg_params
[4];
585 init_reg_param(®_params
[0], "a0", 32, PARAM_OUT
); /* poiner to FLASH_SR */
586 init_reg_param(®_params
[1], "a1", 32, PARAM_OUT
); /* count (halfword-16bit) */
587 init_reg_param(®_params
[2], "a2", 32, PARAM_OUT
); /* buffer start */
588 init_reg_param(®_params
[3], "a3", 32, PARAM_IN_OUT
); /* target address */
590 while (hwords_count
> 0) {
591 uint32_t thisrun_hwords
= source
->size
/ 2;
593 /* Limit to the amount of data we actually want to write */
594 if (thisrun_hwords
> hwords_count
)
595 thisrun_hwords
= hwords_count
;
597 /* Write data to buffer */
598 retval
= target_write_buffer(target
, source
->address
,
599 thisrun_hwords
* 2, buffer
);
600 if (retval
!= ERROR_OK
)
603 buf_set_u32(reg_params
[0].value
, 0, 32, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
));
604 buf_set_u32(reg_params
[1].value
, 0, 32, thisrun_hwords
);
605 buf_set_u32(reg_params
[2].value
, 0, 32, source
->address
);
606 buf_set_u32(reg_params
[3].value
, 0, 32, address
);
608 retval
= target_run_algorithm(target
,
610 ARRAY_SIZE(reg_params
), reg_params
,
611 write_algorithm
->address
,
612 write_algorithm
->address
+ sizeof(gd32vf103_flash_write_code
) - 4,
615 if (retval
!= ERROR_OK
) {
616 LOG_ERROR("Failed to execute algorithm at 0x%" TARGET_PRIxADDR
": %d",
617 write_algorithm
->address
, retval
);
621 /* Actually we just need to check for programming errors
622 * stm32x_wait_status_busy also reports error and clears status bits
624 retval
= stm32x_wait_status_busy(bank
, 5);
625 if (retval
!= ERROR_OK
) {
626 LOG_ERROR("flash write failed at address 0x%"PRIx32
,
627 buf_get_u32(reg_params
[3].value
, 0, 32));
631 /* Update counters */
632 buffer
+= thisrun_hwords
* 2;
633 address
+= thisrun_hwords
* 2;
634 hwords_count
-= thisrun_hwords
;
637 for (unsigned int i
= 0; i
< ARRAY_SIZE(reg_params
); i
++)
638 destroy_reg_param(®_params
[i
]);
640 target_free_working_area(target
, source
);
641 target_free_working_area(target
, write_algorithm
);
646 /** Writes a block to flash either using target algorithm
647 * or use fallback, host controlled halfword-by-halfword access.
648 * Flash controller must be unlocked before this call.
650 static int stm32x_write_block(struct flash_bank
*bank
,
651 const uint8_t *buffer
, uint32_t address
, uint32_t hwords_count
)
653 struct target
*target
= bank
->target
;
655 /* The flash write must be aligned to a halfword boundary.
656 * The flash infrastructure ensures it, do just a security check
658 assert(address
% 2 == 0);
661 struct arm
*arm
= target_to_arm(target
);
663 /* try using a block write - on ARM architecture or... */
664 retval
= stm32x_write_block_async(bank
, buffer
, address
, hwords_count
);
666 /* ... RISC-V architecture */
667 retval
= stm32x_write_block_riscv(bank
, buffer
, address
, hwords_count
);
670 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
) {
671 /* if block write failed (no sufficient working area),
672 * we use normal (slow) single halfword accesses */
673 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
675 while (hwords_count
> 0) {
676 retval
= target_write_memory(target
, address
, 2, 1, buffer
);
677 if (retval
!= ERROR_OK
)
680 retval
= stm32x_wait_status_busy(bank
, 5);
681 if (retval
!= ERROR_OK
)
692 static int stm32x_write(struct flash_bank
*bank
, const uint8_t *buffer
,
693 uint32_t offset
, uint32_t count
)
695 struct target
*target
= bank
->target
;
697 if (bank
->target
->state
!= TARGET_HALTED
) {
698 LOG_ERROR("Target not halted");
699 return ERROR_TARGET_NOT_HALTED
;
702 /* The flash write must be aligned to a halfword boundary.
703 * The flash infrastructure ensures it, do just a security check
705 assert(offset
% 2 == 0);
706 assert(count
% 2 == 0);
710 /* unlock flash registers */
711 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
712 if (retval
!= ERROR_OK
)
714 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
715 if (retval
!= ERROR_OK
)
716 goto reset_pg_and_lock
;
718 /* enable flash programming */
719 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PG
);
720 if (retval
!= ERROR_OK
)
721 goto reset_pg_and_lock
;
724 retval
= stm32x_write_block(bank
, buffer
, bank
->base
+ offset
, count
/ 2);
727 retval2
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
728 if (retval
== ERROR_OK
)
734 struct stm32x_property_addr
{
739 static int stm32x_get_property_addr(struct target
*target
, struct stm32x_property_addr
*addr
)
741 if (!target_was_examined(target
)) {
742 LOG_ERROR("Target not examined yet");
743 return ERROR_TARGET_NOT_EXAMINED
;
746 switch (cortex_m_get_partno_safe(target
)) {
747 case CORTEX_M0_PARTNO
: /* STM32F0x devices */
748 addr
->device_id
= 0x40015800;
749 addr
->flash_size
= 0x1FFFF7CC;
751 case CORTEX_M3_PARTNO
: /* STM32F1x devices */
752 addr
->device_id
= 0xE0042000;
753 addr
->flash_size
= 0x1FFFF7E0;
755 case CORTEX_M4_PARTNO
: /* STM32F3x devices */
756 addr
->device_id
= 0xE0042000;
757 addr
->flash_size
= 0x1FFFF7CC;
759 case CORTEX_M23_PARTNO
: /* GD32E23x devices */
760 addr
->device_id
= 0x40015800;
761 addr
->flash_size
= 0x1FFFF7E0;
763 case CORTEX_M_PARTNO_INVALID
:
764 /* Check for GD32VF103 with RISC-V CPU */
765 if (strcmp(target_type_name(target
), "riscv") == 0
766 && target_address_bits(target
) == 32) {
767 /* There is nothing like arm common_magic in riscv_info_t
768 * check text name of target and if target is 32-bit
770 addr
->device_id
= 0xE0042000;
771 addr
->flash_size
= 0x1FFFF7E0;
776 LOG_ERROR("Cannot identify target as a stm32x");
781 static int stm32x_get_device_id(struct flash_bank
*bank
, uint32_t *device_id
)
783 struct target
*target
= bank
->target
;
784 struct stm32x_property_addr addr
;
786 int retval
= stm32x_get_property_addr(target
, &addr
);
787 if (retval
!= ERROR_OK
)
790 return target_read_u32(target
, addr
.device_id
, device_id
);
793 static int stm32x_get_flash_size(struct flash_bank
*bank
, uint16_t *flash_size_in_kb
)
795 struct target
*target
= bank
->target
;
796 struct stm32x_property_addr addr
;
798 int retval
= stm32x_get_property_addr(target
, &addr
);
799 if (retval
!= ERROR_OK
)
802 return target_read_u16(target
, addr
.flash_size
, flash_size_in_kb
);
805 static int stm32x_probe(struct flash_bank
*bank
)
807 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
808 uint16_t flash_size_in_kb
;
809 uint16_t max_flash_size_in_kb
;
810 uint32_t dbgmcu_idcode
;
812 uint32_t base_address
= 0x08000000;
814 stm32x_info
->probed
= false;
815 stm32x_info
->register_base
= FLASH_REG_BASE_B0
;
816 stm32x_info
->user_data_offset
= 10;
817 stm32x_info
->option_offset
= 0;
819 /* default factory read protection level 0 */
820 stm32x_info
->default_rdp
= 0xA5;
822 /* read stm32 device id register */
823 int retval
= stm32x_get_device_id(bank
, &dbgmcu_idcode
);
824 if (retval
!= ERROR_OK
)
827 LOG_INFO("device id = 0x%08" PRIx32
"", dbgmcu_idcode
);
829 uint16_t device_id
= dbgmcu_idcode
& 0xfff;
830 uint16_t rev_id
= dbgmcu_idcode
>> 16;
832 /* set page size, protection granularity and max flash size depending on family */
834 case 0x440: /* stm32f05x */
836 stm32x_info
->ppage_size
= 4;
837 max_flash_size_in_kb
= 64;
838 stm32x_info
->user_data_offset
= 16;
839 stm32x_info
->option_offset
= 6;
840 stm32x_info
->default_rdp
= 0xAA;
841 stm32x_info
->can_load_options
= true;
843 case 0x444: /* stm32f03x */
844 case 0x445: /* stm32f04x */
846 stm32x_info
->ppage_size
= 4;
847 max_flash_size_in_kb
= 32;
848 stm32x_info
->user_data_offset
= 16;
849 stm32x_info
->option_offset
= 6;
850 stm32x_info
->default_rdp
= 0xAA;
851 stm32x_info
->can_load_options
= true;
853 case 0x448: /* stm32f07x */
855 stm32x_info
->ppage_size
= 4;
856 max_flash_size_in_kb
= 128;
857 stm32x_info
->user_data_offset
= 16;
858 stm32x_info
->option_offset
= 6;
859 stm32x_info
->default_rdp
= 0xAA;
860 stm32x_info
->can_load_options
= true;
862 case 0x442: /* stm32f09x */
864 stm32x_info
->ppage_size
= 4;
865 max_flash_size_in_kb
= 256;
866 stm32x_info
->user_data_offset
= 16;
867 stm32x_info
->option_offset
= 6;
868 stm32x_info
->default_rdp
= 0xAA;
869 stm32x_info
->can_load_options
= true;
871 case 0x410: /* stm32f1x medium-density */
873 stm32x_info
->ppage_size
= 4;
874 max_flash_size_in_kb
= 128;
875 /* GigaDevice GD32F1x0 & GD32F3x0 & GD32E23x series devices
876 share DEV_ID with STM32F101/2/3 medium-density line,
877 however they use a REV_ID different from any STM32 device.
878 The main difference is another offset of user option bits
879 (like WDG_SW, nRST_STOP, nRST_STDBY) in option byte register
880 (FLASH_OBR/FMC_OBSTAT 0x4002201C).
881 This caused problems e.g. during flash block programming
882 because of unexpected active hardware watchog. */
884 case 0x1303: /* gd32f1x0 */
885 stm32x_info
->user_data_offset
= 16;
886 stm32x_info
->option_offset
= 6;
887 max_flash_size_in_kb
= 64;
888 stm32x_info
->can_load_options
= true;
890 case 0x1704: /* gd32f3x0 */
891 stm32x_info
->user_data_offset
= 16;
892 stm32x_info
->option_offset
= 6;
893 stm32x_info
->can_load_options
= true;
895 case 0x1906: /* gd32vf103 */
897 case 0x1909: /* gd32e23x */
898 stm32x_info
->user_data_offset
= 16;
899 stm32x_info
->option_offset
= 6;
900 max_flash_size_in_kb
= 64;
901 stm32x_info
->can_load_options
= true;
905 case 0x412: /* stm32f1x low-density */
907 stm32x_info
->ppage_size
= 4;
908 max_flash_size_in_kb
= 32;
910 case 0x414: /* stm32f1x high-density */
912 stm32x_info
->ppage_size
= 2;
913 max_flash_size_in_kb
= 512;
915 case 0x418: /* stm32f1x connectivity */
917 stm32x_info
->ppage_size
= 2;
918 max_flash_size_in_kb
= 256;
920 case 0x430: /* stm32f1 XL-density (dual flash banks) */
922 stm32x_info
->ppage_size
= 2;
923 max_flash_size_in_kb
= 1024;
924 stm32x_info
->has_dual_banks
= true;
926 case 0x420: /* stm32f100xx low- and medium-density value line */
928 stm32x_info
->ppage_size
= 4;
929 max_flash_size_in_kb
= 128;
931 case 0x428: /* stm32f100xx high-density value line */
933 stm32x_info
->ppage_size
= 4;
934 max_flash_size_in_kb
= 512;
936 case 0x422: /* stm32f302/3xb/c */
938 stm32x_info
->ppage_size
= 2;
939 max_flash_size_in_kb
= 256;
940 stm32x_info
->user_data_offset
= 16;
941 stm32x_info
->option_offset
= 6;
942 stm32x_info
->default_rdp
= 0xAA;
943 stm32x_info
->can_load_options
= true;
945 case 0x446: /* stm32f303xD/E */
947 stm32x_info
->ppage_size
= 2;
948 max_flash_size_in_kb
= 512;
949 stm32x_info
->user_data_offset
= 16;
950 stm32x_info
->option_offset
= 6;
951 stm32x_info
->default_rdp
= 0xAA;
952 stm32x_info
->can_load_options
= true;
954 case 0x432: /* stm32f37x */
956 stm32x_info
->ppage_size
= 2;
957 max_flash_size_in_kb
= 256;
958 stm32x_info
->user_data_offset
= 16;
959 stm32x_info
->option_offset
= 6;
960 stm32x_info
->default_rdp
= 0xAA;
961 stm32x_info
->can_load_options
= true;
963 case 0x438: /* stm32f33x */
964 case 0x439: /* stm32f302x6/8 */
966 stm32x_info
->ppage_size
= 2;
967 max_flash_size_in_kb
= 64;
968 stm32x_info
->user_data_offset
= 16;
969 stm32x_info
->option_offset
= 6;
970 stm32x_info
->default_rdp
= 0xAA;
971 stm32x_info
->can_load_options
= true;
974 LOG_WARNING("Cannot identify target as a STM32 family.");
978 /* get flash size from target. */
979 retval
= stm32x_get_flash_size(bank
, &flash_size_in_kb
);
981 /* failed reading flash size or flash size invalid (early silicon),
982 * default to max target family */
983 if (retval
!= ERROR_OK
|| flash_size_in_kb
== 0xffff || flash_size_in_kb
== 0) {
984 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
985 max_flash_size_in_kb
);
986 flash_size_in_kb
= max_flash_size_in_kb
;
989 if (stm32x_info
->has_dual_banks
) {
990 /* split reported size into matching bank */
991 if (bank
->base
!= 0x08080000) {
992 /* bank 0 will be fixed 512k */
993 flash_size_in_kb
= 512;
995 flash_size_in_kb
-= 512;
996 /* bank1 also uses a register offset */
997 stm32x_info
->register_base
= FLASH_REG_BASE_B1
;
998 base_address
= 0x08080000;
1002 /* if the user sets the size manually then ignore the probed value
1003 * this allows us to work around devices that have a invalid flash size register value */
1004 if (stm32x_info
->user_bank_size
) {
1005 LOG_INFO("ignoring flash probed value, using configured bank size");
1006 flash_size_in_kb
= stm32x_info
->user_bank_size
/ 1024;
1009 LOG_INFO("flash size = %d KiB", flash_size_in_kb
);
1011 /* did we assign flash size? */
1012 assert(flash_size_in_kb
!= 0xffff);
1014 /* calculate numbers of pages */
1015 int num_pages
= flash_size_in_kb
* 1024 / page_size
;
1017 /* check that calculation result makes sense */
1018 assert(num_pages
> 0);
1020 free(bank
->sectors
);
1021 bank
->sectors
= NULL
;
1023 free(bank
->prot_blocks
);
1024 bank
->prot_blocks
= NULL
;
1026 bank
->base
= base_address
;
1027 bank
->size
= (num_pages
* page_size
);
1029 bank
->num_sectors
= num_pages
;
1030 bank
->sectors
= alloc_block_array(0, page_size
, num_pages
);
1034 /* calculate number of write protection blocks */
1035 int num_prot_blocks
= num_pages
/ stm32x_info
->ppage_size
;
1036 if (num_prot_blocks
> 32)
1037 num_prot_blocks
= 32;
1039 bank
->num_prot_blocks
= num_prot_blocks
;
1040 bank
->prot_blocks
= alloc_block_array(0, stm32x_info
->ppage_size
* page_size
, num_prot_blocks
);
1041 if (!bank
->prot_blocks
)
1044 if (num_prot_blocks
== 32)
1045 bank
->prot_blocks
[31].size
= (num_pages
- (31 * stm32x_info
->ppage_size
)) * page_size
;
1047 stm32x_info
->probed
= true;
1052 static int stm32x_auto_probe(struct flash_bank
*bank
)
1054 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
1055 if (stm32x_info
->probed
)
1057 return stm32x_probe(bank
);
1061 COMMAND_HANDLER(stm32x_handle_part_id_command
)
1067 static const char *get_stm32f0_revision(uint16_t rev_id
)
1069 const char *rev_str
= NULL
;
1082 static int get_stm32x_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
1084 uint32_t dbgmcu_idcode
;
1086 /* read stm32 device id register */
1087 int retval
= stm32x_get_device_id(bank
, &dbgmcu_idcode
);
1088 if (retval
!= ERROR_OK
)
1091 uint16_t device_id
= dbgmcu_idcode
& 0xfff;
1092 uint16_t rev_id
= dbgmcu_idcode
>> 16;
1093 const char *device_str
;
1094 const char *rev_str
= NULL
;
1096 switch (device_id
) {
1098 device_str
= "STM32F10x (Medium Density)";
1105 case 0x1303: /* gd32f1x0 */
1106 device_str
= "GD32F1x0";
1109 case 0x1704: /* gd32f3x0 */
1110 device_str
= "GD32F3x0";
1114 device_str
= "GD32VF103";
1117 case 0x1909: /* gd32e23x */
1118 device_str
= "GD32E23x";
1136 device_str
= "STM32F10x (Low Density)";
1146 device_str
= "STM32F10x (High Density)";
1164 device_str
= "STM32F10x (Connectivity)";
1178 device_str
= "STM32F100 (Low/Medium Density)";
1192 device_str
= "STM32F302xB/C";
1214 device_str
= "STM32F100 (High Density)";
1228 device_str
= "STM32F10x (XL Density)";
1238 device_str
= "STM32F37x";
1252 device_str
= "STM32F33x";
1262 device_str
= "STM32F302x6/8";
1276 device_str
= "STM32F03x";
1277 rev_str
= get_stm32f0_revision(rev_id
);
1281 device_str
= "STM32F05x";
1282 rev_str
= get_stm32f0_revision(rev_id
);
1286 device_str
= "STM32F04x";
1287 rev_str
= get_stm32f0_revision(rev_id
);
1291 device_str
= "STM32F303xD/E";
1300 device_str
= "STM32F07x";
1301 rev_str
= get_stm32f0_revision(rev_id
);
1305 device_str
= "STM32F09x";
1306 rev_str
= get_stm32f0_revision(rev_id
);
1310 command_print_sameline(cmd
, "Cannot identify target as a STM32F0/1/3\n");
1315 command_print_sameline(cmd
, "%s - Rev: %s", device_str
, rev_str
);
1317 command_print_sameline(cmd
, "%s - Rev: unknown (0x%04x)", device_str
, rev_id
);
1322 COMMAND_HANDLER(stm32x_handle_lock_command
)
1324 struct target
*target
= NULL
;
1325 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1328 return ERROR_COMMAND_SYNTAX_ERROR
;
1330 struct flash_bank
*bank
;
1331 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1332 if (retval
!= ERROR_OK
)
1335 stm32x_info
= bank
->driver_priv
;
1337 target
= bank
->target
;
1339 if (target
->state
!= TARGET_HALTED
) {
1340 LOG_ERROR("Target not halted");
1341 return ERROR_TARGET_NOT_HALTED
;
1344 retval
= stm32x_check_operation_supported(bank
);
1345 if (retval
!= ERROR_OK
)
1348 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1349 command_print(CMD
, "stm32x failed to erase options");
1353 /* set readout protection */
1354 stm32x_info
->option_bytes
.rdp
= 0;
1356 if (stm32x_write_options(bank
) != ERROR_OK
) {
1357 command_print(CMD
, "stm32x failed to lock device");
1361 command_print(CMD
, "stm32x locked");
1366 COMMAND_HANDLER(stm32x_handle_unlock_command
)
1368 struct target
*target
= NULL
;
1371 return ERROR_COMMAND_SYNTAX_ERROR
;
1373 struct flash_bank
*bank
;
1374 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1375 if (retval
!= ERROR_OK
)
1378 target
= bank
->target
;
1380 if (target
->state
!= TARGET_HALTED
) {
1381 LOG_ERROR("Target not halted");
1382 return ERROR_TARGET_NOT_HALTED
;
1385 retval
= stm32x_check_operation_supported(bank
);
1386 if (retval
!= ERROR_OK
)
1389 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1390 command_print(CMD
, "stm32x failed to erase options");
1394 if (stm32x_write_options(bank
) != ERROR_OK
) {
1395 command_print(CMD
, "stm32x failed to unlock device");
1399 command_print(CMD
, "stm32x unlocked.\n"
1400 "INFO: a reset or power cycle is required "
1401 "for the new settings to take effect.");
1406 COMMAND_HANDLER(stm32x_handle_options_read_command
)
1408 uint32_t optionbyte
, protection
;
1409 struct target
*target
= NULL
;
1410 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1413 return ERROR_COMMAND_SYNTAX_ERROR
;
1415 struct flash_bank
*bank
;
1416 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1417 if (retval
!= ERROR_OK
)
1420 stm32x_info
= bank
->driver_priv
;
1422 target
= bank
->target
;
1424 if (target
->state
!= TARGET_HALTED
) {
1425 LOG_ERROR("Target not halted");
1426 return ERROR_TARGET_NOT_HALTED
;
1429 retval
= stm32x_check_operation_supported(bank
);
1430 if (retval
!= ERROR_OK
)
1433 retval
= target_read_u32(target
, STM32_FLASH_OBR_B0
, &optionbyte
);
1434 if (retval
!= ERROR_OK
)
1437 uint16_t user_data
= optionbyte
>> stm32x_info
->user_data_offset
;
1439 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &protection
);
1440 if (retval
!= ERROR_OK
)
1443 if (optionbyte
& (1 << OPT_ERROR
))
1444 command_print(CMD
, "option byte complement error");
1446 command_print(CMD
, "option byte register = 0x%" PRIx32
"", optionbyte
);
1447 command_print(CMD
, "write protection register = 0x%" PRIx32
"", protection
);
1449 command_print(CMD
, "read protection: %s",
1450 (optionbyte
& (1 << OPT_READOUT
)) ? "on" : "off");
1452 /* user option bytes are offset depending on variant */
1453 optionbyte
>>= stm32x_info
->option_offset
;
1455 command_print(CMD
, "watchdog: %sware",
1456 (optionbyte
& (1 << OPT_RDWDGSW
)) ? "soft" : "hard");
1458 command_print(CMD
, "stop mode: %sreset generated upon entry",
1459 (optionbyte
& (1 << OPT_RDRSTSTOP
)) ? "no " : "");
1461 command_print(CMD
, "standby mode: %sreset generated upon entry",
1462 (optionbyte
& (1 << OPT_RDRSTSTDBY
)) ? "no " : "");
1464 if (stm32x_info
->has_dual_banks
)
1465 command_print(CMD
, "boot: bank %d", (optionbyte
& (1 << OPT_BFB2
)) ? 0 : 1);
1467 command_print(CMD
, "user data = 0x%02" PRIx16
"", user_data
);
1472 COMMAND_HANDLER(stm32x_handle_options_write_command
)
1474 struct target
*target
= NULL
;
1475 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1480 return ERROR_COMMAND_SYNTAX_ERROR
;
1482 struct flash_bank
*bank
;
1483 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1484 if (retval
!= ERROR_OK
)
1487 stm32x_info
= bank
->driver_priv
;
1489 target
= bank
->target
;
1491 if (target
->state
!= TARGET_HALTED
) {
1492 LOG_ERROR("Target not halted");
1493 return ERROR_TARGET_NOT_HALTED
;
1496 retval
= stm32x_check_operation_supported(bank
);
1497 if (retval
!= ERROR_OK
)
1500 retval
= stm32x_read_options(bank
);
1501 if (retval
!= ERROR_OK
)
1504 /* start with current options */
1505 optionbyte
= stm32x_info
->option_bytes
.user
;
1506 useropt
= stm32x_info
->option_bytes
.data
;
1508 /* skip over flash bank */
1513 if (strcmp("SWWDG", CMD_ARGV
[0]) == 0)
1514 optionbyte
|= (1 << 0);
1515 else if (strcmp("HWWDG", CMD_ARGV
[0]) == 0)
1516 optionbyte
&= ~(1 << 0);
1517 else if (strcmp("NORSTSTOP", CMD_ARGV
[0]) == 0)
1518 optionbyte
|= (1 << 1);
1519 else if (strcmp("RSTSTOP", CMD_ARGV
[0]) == 0)
1520 optionbyte
&= ~(1 << 1);
1521 else if (strcmp("NORSTSTNDBY", CMD_ARGV
[0]) == 0)
1522 optionbyte
|= (1 << 2);
1523 else if (strcmp("RSTSTNDBY", CMD_ARGV
[0]) == 0)
1524 optionbyte
&= ~(1 << 2);
1525 else if (strcmp("USEROPT", CMD_ARGV
[0]) == 0) {
1527 return ERROR_COMMAND_SYNTAX_ERROR
;
1528 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], useropt
);
1531 } else if (stm32x_info
->has_dual_banks
) {
1532 if (strcmp("BOOT0", CMD_ARGV
[0]) == 0)
1533 optionbyte
|= (1 << 3);
1534 else if (strcmp("BOOT1", CMD_ARGV
[0]) == 0)
1535 optionbyte
&= ~(1 << 3);
1537 return ERROR_COMMAND_SYNTAX_ERROR
;
1539 return ERROR_COMMAND_SYNTAX_ERROR
;
1544 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1545 command_print(CMD
, "stm32x failed to erase options");
1549 stm32x_info
->option_bytes
.user
= optionbyte
;
1550 stm32x_info
->option_bytes
.data
= useropt
;
1552 if (stm32x_write_options(bank
) != ERROR_OK
) {
1553 command_print(CMD
, "stm32x failed to write options");
1557 command_print(CMD
, "stm32x write options complete.\n"
1558 "INFO: %spower cycle is required "
1559 "for the new settings to take effect.",
1560 stm32x_info
->can_load_options
1561 ? "'stm32f1x options_load' command or " : "");
1566 COMMAND_HANDLER(stm32x_handle_options_load_command
)
1569 return ERROR_COMMAND_SYNTAX_ERROR
;
1571 struct flash_bank
*bank
;
1572 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1573 if (retval
!= ERROR_OK
)
1576 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
1578 if (!stm32x_info
->can_load_options
) {
1579 LOG_ERROR("Command not applicable to stm32f1x devices - power cycle is "
1580 "required instead.");
1584 struct target
*target
= bank
->target
;
1586 if (target
->state
!= TARGET_HALTED
) {
1587 LOG_ERROR("Target not halted");
1588 return ERROR_TARGET_NOT_HALTED
;
1591 retval
= stm32x_check_operation_supported(bank
);
1592 if (retval
!= ERROR_OK
)
1595 /* unlock option flash registers */
1596 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
1597 if (retval
!= ERROR_OK
)
1599 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
1600 if (retval
!= ERROR_OK
) {
1601 (void)target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
1605 /* force re-load of option bytes - generates software reset */
1606 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_OBL_LAUNCH
);
1607 if (retval
!= ERROR_OK
)
1613 static int stm32x_mass_erase(struct flash_bank
*bank
)
1615 struct target
*target
= bank
->target
;
1617 if (target
->state
!= TARGET_HALTED
) {
1618 LOG_ERROR("Target not halted");
1619 return ERROR_TARGET_NOT_HALTED
;
1622 /* unlock option flash registers */
1623 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
1624 if (retval
!= ERROR_OK
)
1626 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
1627 if (retval
!= ERROR_OK
)
1630 /* mass erase flash memory */
1631 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_MER
);
1632 if (retval
!= ERROR_OK
)
1634 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
),
1635 FLASH_MER
| FLASH_STRT
);
1636 if (retval
!= ERROR_OK
)
1639 retval
= stm32x_wait_status_busy(bank
, FLASH_ERASE_TIMEOUT
);
1643 int retval2
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
1644 if (retval
== ERROR_OK
)
1650 COMMAND_HANDLER(stm32x_handle_mass_erase_command
)
1653 return ERROR_COMMAND_SYNTAX_ERROR
;
1655 struct flash_bank
*bank
;
1656 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1657 if (retval
!= ERROR_OK
)
1660 retval
= stm32x_mass_erase(bank
);
1661 if (retval
== ERROR_OK
)
1662 command_print(CMD
, "stm32x mass erase complete");
1664 command_print(CMD
, "stm32x mass erase failed");
1669 static const struct command_registration stm32f1x_exec_command_handlers
[] = {
1672 .handler
= stm32x_handle_lock_command
,
1673 .mode
= COMMAND_EXEC
,
1675 .help
= "Lock entire flash device.",
1679 .handler
= stm32x_handle_unlock_command
,
1680 .mode
= COMMAND_EXEC
,
1682 .help
= "Unlock entire protected flash device.",
1685 .name
= "mass_erase",
1686 .handler
= stm32x_handle_mass_erase_command
,
1687 .mode
= COMMAND_EXEC
,
1689 .help
= "Erase entire flash device.",
1692 .name
= "options_read",
1693 .handler
= stm32x_handle_options_read_command
,
1694 .mode
= COMMAND_EXEC
,
1696 .help
= "Read and display device option bytes.",
1699 .name
= "options_write",
1700 .handler
= stm32x_handle_options_write_command
,
1701 .mode
= COMMAND_EXEC
,
1702 .usage
= "bank_id ('SWWDG'|'HWWDG') "
1703 "('RSTSTNDBY'|'NORSTSTNDBY') "
1704 "('RSTSTOP'|'NORSTSTOP') ('USEROPT' user_data)",
1705 .help
= "Replace bits in device option bytes.",
1708 .name
= "options_load",
1709 .handler
= stm32x_handle_options_load_command
,
1710 .mode
= COMMAND_EXEC
,
1712 .help
= "Force re-load of device option bytes.",
1714 COMMAND_REGISTRATION_DONE
1717 static const struct command_registration stm32f1x_command_handlers
[] = {
1720 .mode
= COMMAND_ANY
,
1721 .help
= "stm32f1x flash command group",
1723 .chain
= stm32f1x_exec_command_handlers
,
1725 COMMAND_REGISTRATION_DONE
1728 const struct flash_driver stm32f1x_flash
= {
1730 .commands
= stm32f1x_command_handlers
,
1731 .flash_bank_command
= stm32x_flash_bank_command
,
1732 .erase
= stm32x_erase
,
1733 .protect
= stm32x_protect
,
1734 .write
= stm32x_write
,
1735 .read
= default_flash_read
,
1736 .probe
= stm32x_probe
,
1737 .auto_probe
= stm32x_auto_probe
,
1738 .erase_check
= default_flash_blank_check
,
1739 .protect_check
= stm32x_protect_check
,
1740 .info
= get_stm32x_info
,
1741 .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)