1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * Copyright (C) 2011 by Andreas Fritiofson *
9 * andreas.fritiofson@gmail.com *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
32 #include <helper/binarybuffer.h>
33 #include <target/algorithm.h>
34 #include <target/armv7m.h>
36 /* stm32x register locations */
38 #define FLASH_REG_BASE_B0 0x40022000
39 #define FLASH_REG_BASE_B1 0x40022040
41 #define STM32_FLASH_ACR 0x00
42 #define STM32_FLASH_KEYR 0x04
43 #define STM32_FLASH_OPTKEYR 0x08
44 #define STM32_FLASH_SR 0x0C
45 #define STM32_FLASH_CR 0x10
46 #define STM32_FLASH_AR 0x14
47 #define STM32_FLASH_OBR 0x1C
48 #define STM32_FLASH_WRPR 0x20
50 /* TODO: Check if code using these really should be hard coded to bank 0.
51 * There are valid cases, on dual flash devices the protection of the
52 * second bank is done on the bank0 reg's. */
53 #define STM32_FLASH_ACR_B0 0x40022000
54 #define STM32_FLASH_KEYR_B0 0x40022004
55 #define STM32_FLASH_OPTKEYR_B0 0x40022008
56 #define STM32_FLASH_SR_B0 0x4002200C
57 #define STM32_FLASH_CR_B0 0x40022010
58 #define STM32_FLASH_AR_B0 0x40022014
59 #define STM32_FLASH_OBR_B0 0x4002201C
60 #define STM32_FLASH_WRPR_B0 0x40022020
62 /* option byte location */
64 #define STM32_OB_RDP 0x1FFFF800
65 #define STM32_OB_USER 0x1FFFF802
66 #define STM32_OB_DATA0 0x1FFFF804
67 #define STM32_OB_DATA1 0x1FFFF806
68 #define STM32_OB_WRP0 0x1FFFF808
69 #define STM32_OB_WRP1 0x1FFFF80A
70 #define STM32_OB_WRP2 0x1FFFF80C
71 #define STM32_OB_WRP3 0x1FFFF80E
73 /* FLASH_CR register bits */
75 #define FLASH_PG (1 << 0)
76 #define FLASH_PER (1 << 1)
77 #define FLASH_MER (1 << 2)
78 #define FLASH_OPTPG (1 << 4)
79 #define FLASH_OPTER (1 << 5)
80 #define FLASH_STRT (1 << 6)
81 #define FLASH_LOCK (1 << 7)
82 #define FLASH_OPTWRE (1 << 9)
84 /* FLASH_SR register bits */
86 #define FLASH_BSY (1 << 0)
87 #define FLASH_PGERR (1 << 2)
88 #define FLASH_WRPRTERR (1 << 4)
89 #define FLASH_EOP (1 << 5)
91 /* STM32_FLASH_OBR bit definitions (reading) */
96 #define OPT_RDRSTSTOP 3
97 #define OPT_RDRSTSTDBY 4
98 #define OPT_BFB2 5 /* dual flash bank only */
100 /* register unlock keys */
102 #define KEY1 0x45670123
103 #define KEY2 0xCDEF89AB
105 struct stm32x_options
{
107 uint16_t user_options
;
108 uint16_t protection
[4];
111 struct stm32x_flash_bank
{
112 struct stm32x_options option_bytes
;
113 struct working_area
*write_algorithm
;
118 /* used to access dual flash bank stm32xl */
119 uint32_t register_base
;
122 static int stm32x_mass_erase(struct flash_bank
*bank
);
123 static int stm32x_get_device_id(struct flash_bank
*bank
, uint32_t *device_id
);
125 /* flash bank stm32x <base> <size> 0 0 <target#>
127 FLASH_BANK_COMMAND_HANDLER(stm32x_flash_bank_command
)
129 struct stm32x_flash_bank
*stm32x_info
;
132 return ERROR_COMMAND_SYNTAX_ERROR
;
134 stm32x_info
= malloc(sizeof(struct stm32x_flash_bank
));
136 bank
->driver_priv
= stm32x_info
;
137 stm32x_info
->write_algorithm
= NULL
;
138 stm32x_info
->probed
= 0;
139 stm32x_info
->has_dual_banks
= false;
140 stm32x_info
->register_base
= FLASH_REG_BASE_B0
;
145 static inline int stm32x_get_flash_reg(struct flash_bank
*bank
, uint32_t reg
)
147 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
148 return reg
+ stm32x_info
->register_base
;
151 static inline int stm32x_get_flash_status(struct flash_bank
*bank
, uint32_t *status
)
153 struct target
*target
= bank
->target
;
154 return target_read_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
), status
);
157 static int stm32x_wait_status_busy(struct flash_bank
*bank
, int timeout
)
159 struct target
*target
= bank
->target
;
161 int retval
= ERROR_OK
;
163 /* wait for busy to clear */
165 retval
= stm32x_get_flash_status(bank
, &status
);
166 if (retval
!= ERROR_OK
)
168 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
169 if ((status
& FLASH_BSY
) == 0)
171 if (timeout
-- <= 0) {
172 LOG_ERROR("timed out waiting for flash");
178 if (status
& FLASH_WRPRTERR
) {
179 LOG_ERROR("stm32x device protected");
183 if (status
& FLASH_PGERR
) {
184 LOG_ERROR("stm32x device programming failed");
188 /* Clear but report errors */
189 if (status
& (FLASH_WRPRTERR
| FLASH_PGERR
)) {
190 /* If this operation fails, we ignore it and report the original
193 target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
),
194 FLASH_WRPRTERR
| FLASH_PGERR
);
199 int stm32x_check_operation_supported(struct flash_bank
*bank
)
201 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
203 /* if we have a dual flash bank device then
204 * we need to perform option byte stuff on bank0 only */
205 if (stm32x_info
->register_base
!= FLASH_REG_BASE_B0
) {
206 LOG_ERROR("Option Byte Operation's must use bank0");
207 return ERROR_FLASH_OPERATION_FAILED
;
213 static int stm32x_read_options(struct flash_bank
*bank
)
216 struct stm32x_flash_bank
*stm32x_info
= NULL
;
217 struct target
*target
= bank
->target
;
219 stm32x_info
= bank
->driver_priv
;
221 /* read current option bytes */
222 int retval
= target_read_u32(target
, STM32_FLASH_OBR_B0
, &optiondata
);
223 if (retval
!= ERROR_OK
)
226 stm32x_info
->option_bytes
.user_options
= (uint16_t)0xFFF8 | ((optiondata
>> 2) & 0x07);
227 stm32x_info
->option_bytes
.RDP
= (optiondata
& (1 << OPT_READOUT
)) ? 0xFFFF : 0x5AA5;
229 if (optiondata
& (1 << OPT_READOUT
))
230 LOG_INFO("Device Security Bit Set");
232 /* each bit refers to a 4bank protection */
233 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &optiondata
);
234 if (retval
!= ERROR_OK
)
237 stm32x_info
->option_bytes
.protection
[0] = (uint16_t)optiondata
;
238 stm32x_info
->option_bytes
.protection
[1] = (uint16_t)(optiondata
>> 8);
239 stm32x_info
->option_bytes
.protection
[2] = (uint16_t)(optiondata
>> 16);
240 stm32x_info
->option_bytes
.protection
[3] = (uint16_t)(optiondata
>> 24);
245 static int stm32x_erase_options(struct flash_bank
*bank
)
247 struct stm32x_flash_bank
*stm32x_info
= NULL
;
248 struct target
*target
= bank
->target
;
250 stm32x_info
= bank
->driver_priv
;
252 /* stlink is currently does not support 16bit
253 * read/writes. so we cannot write option bytes */
254 struct armv7m_common
*armv7m
= target_to_armv7m(target
);
255 if (armv7m
&& armv7m
->stlink
) {
256 LOG_ERROR("Option bytes currently unsupported for stlink");
260 /* read current options */
261 stm32x_read_options(bank
);
263 /* unlock flash registers */
264 int retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY1
);
265 if (retval
!= ERROR_OK
)
268 retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY2
);
269 if (retval
!= ERROR_OK
)
272 /* unlock option flash registers */
273 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY1
);
274 if (retval
!= ERROR_OK
)
276 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY2
);
277 if (retval
!= ERROR_OK
)
280 /* erase option bytes */
281 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTER
| FLASH_OPTWRE
);
282 if (retval
!= ERROR_OK
)
284 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTER
| FLASH_STRT
| FLASH_OPTWRE
);
285 if (retval
!= ERROR_OK
)
288 retval
= stm32x_wait_status_busy(bank
, 10);
289 if (retval
!= ERROR_OK
)
292 /* clear readout protection and complementary option bytes
293 * this will also force a device unlock if set */
294 stm32x_info
->option_bytes
.RDP
= 0x5AA5;
299 static int stm32x_write_options(struct flash_bank
*bank
)
301 struct stm32x_flash_bank
*stm32x_info
= NULL
;
302 struct target
*target
= bank
->target
;
304 stm32x_info
= bank
->driver_priv
;
306 /* unlock flash registers */
307 int retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY1
);
308 if (retval
!= ERROR_OK
)
310 retval
= target_write_u32(target
, STM32_FLASH_KEYR_B0
, KEY2
);
311 if (retval
!= ERROR_OK
)
314 /* unlock option flash registers */
315 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY1
);
316 if (retval
!= ERROR_OK
)
318 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR_B0
, KEY2
);
319 if (retval
!= ERROR_OK
)
322 /* program option bytes */
323 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_OPTPG
| FLASH_OPTWRE
);
324 if (retval
!= ERROR_OK
)
327 /* write user option byte */
328 retval
= target_write_u16(target
, STM32_OB_USER
, stm32x_info
->option_bytes
.user_options
);
329 if (retval
!= ERROR_OK
)
332 retval
= stm32x_wait_status_busy(bank
, 10);
333 if (retval
!= ERROR_OK
)
336 /* write protection byte 1 */
337 retval
= target_write_u16(target
, STM32_OB_WRP0
, stm32x_info
->option_bytes
.protection
[0]);
338 if (retval
!= ERROR_OK
)
341 retval
= stm32x_wait_status_busy(bank
, 10);
342 if (retval
!= ERROR_OK
)
345 /* write protection byte 2 */
346 retval
= target_write_u16(target
, STM32_OB_WRP1
, stm32x_info
->option_bytes
.protection
[1]);
347 if (retval
!= ERROR_OK
)
350 retval
= stm32x_wait_status_busy(bank
, 10);
351 if (retval
!= ERROR_OK
)
354 /* write protection byte 3 */
355 retval
= target_write_u16(target
, STM32_OB_WRP2
, stm32x_info
->option_bytes
.protection
[2]);
356 if (retval
!= ERROR_OK
)
359 retval
= stm32x_wait_status_busy(bank
, 10);
360 if (retval
!= ERROR_OK
)
363 /* write protection byte 4 */
364 retval
= target_write_u16(target
, STM32_OB_WRP3
, stm32x_info
->option_bytes
.protection
[3]);
365 if (retval
!= ERROR_OK
)
368 retval
= stm32x_wait_status_busy(bank
, 10);
369 if (retval
!= ERROR_OK
)
372 /* write readout protection bit */
373 retval
= target_write_u16(target
, STM32_OB_RDP
, stm32x_info
->option_bytes
.RDP
);
374 if (retval
!= ERROR_OK
)
377 retval
= stm32x_wait_status_busy(bank
, 10);
378 if (retval
!= ERROR_OK
)
381 retval
= target_write_u32(target
, STM32_FLASH_CR_B0
, FLASH_LOCK
);
382 if (retval
!= ERROR_OK
)
388 static int stm32x_protect_check(struct flash_bank
*bank
)
390 struct target
*target
= bank
->target
;
391 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
398 if (target
->state
!= TARGET_HALTED
) {
399 LOG_ERROR("Target not halted");
400 return ERROR_TARGET_NOT_HALTED
;
403 int retval
= stm32x_check_operation_supported(bank
);
404 if (ERROR_OK
!= retval
)
407 /* medium density - each bit refers to a 4bank protection
408 * high density - each bit refers to a 2bank protection */
409 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &protection
);
410 if (retval
!= ERROR_OK
)
413 /* medium density - each protection bit is for 4 * 1K pages
414 * high density - each protection bit is for 2 * 2K pages */
415 num_bits
= (bank
->num_sectors
/ stm32x_info
->ppage_size
);
417 if (stm32x_info
->ppage_size
== 2) {
418 /* high density flash/connectivity line protection */
422 if (protection
& (1 << 31))
425 /* bit 31 controls sector 62 - 255 protection for high density
426 * bit 31 controls sector 62 - 127 protection for connectivity line */
427 for (s
= 62; s
< bank
->num_sectors
; s
++)
428 bank
->sectors
[s
].is_protected
= set
;
430 if (bank
->num_sectors
> 61)
433 for (i
= 0; i
< num_bits
; i
++) {
436 if (protection
& (1 << i
))
439 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
440 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
443 /* low/medium density flash protection */
444 for (i
= 0; i
< num_bits
; i
++) {
447 if (protection
& (1 << i
))
450 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
451 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
458 static int stm32x_erase(struct flash_bank
*bank
, int first
, int last
)
460 struct target
*target
= bank
->target
;
463 if (bank
->target
->state
!= TARGET_HALTED
) {
464 LOG_ERROR("Target not halted");
465 return ERROR_TARGET_NOT_HALTED
;
468 if ((first
== 0) && (last
== (bank
->num_sectors
- 1)))
469 return stm32x_mass_erase(bank
);
471 /* unlock flash registers */
472 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
473 if (retval
!= ERROR_OK
)
475 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
476 if (retval
!= ERROR_OK
)
479 for (i
= first
; i
<= last
; i
++) {
480 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
);
481 if (retval
!= ERROR_OK
)
483 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_AR
),
484 bank
->base
+ bank
->sectors
[i
].offset
);
485 if (retval
!= ERROR_OK
)
487 retval
= target_write_u32(target
,
488 stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
| FLASH_STRT
);
489 if (retval
!= ERROR_OK
)
492 retval
= stm32x_wait_status_busy(bank
, 100);
493 if (retval
!= ERROR_OK
)
496 bank
->sectors
[i
].is_erased
= 1;
499 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
500 if (retval
!= ERROR_OK
)
506 static int stm32x_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
508 struct stm32x_flash_bank
*stm32x_info
= NULL
;
509 struct target
*target
= bank
->target
;
510 uint16_t prot_reg
[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
515 stm32x_info
= bank
->driver_priv
;
517 if (target
->state
!= TARGET_HALTED
) {
518 LOG_ERROR("Target not halted");
519 return ERROR_TARGET_NOT_HALTED
;
522 int retval
= stm32x_check_operation_supported(bank
);
523 if (ERROR_OK
!= retval
)
526 if ((first
% stm32x_info
->ppage_size
) != 0) {
527 LOG_WARNING("aligned start protect sector to a %d sector boundary",
528 stm32x_info
->ppage_size
);
529 first
= first
- (first
% stm32x_info
->ppage_size
);
531 if (((last
+ 1) % stm32x_info
->ppage_size
) != 0) {
532 LOG_WARNING("aligned end protect sector to a %d sector boundary",
533 stm32x_info
->ppage_size
);
535 last
= last
- (last
% stm32x_info
->ppage_size
);
539 /* medium density - each bit refers to a 4bank protection
540 * high density - each bit refers to a 2bank protection */
541 retval
= target_read_u32(target
, STM32_FLASH_WRPR_B0
, &protection
);
542 if (retval
!= ERROR_OK
)
545 prot_reg
[0] = (uint16_t)protection
;
546 prot_reg
[1] = (uint16_t)(protection
>> 8);
547 prot_reg
[2] = (uint16_t)(protection
>> 16);
548 prot_reg
[3] = (uint16_t)(protection
>> 24);
550 if (stm32x_info
->ppage_size
== 2) {
551 /* high density flash */
553 /* bit 7 controls sector 62 - 255 protection */
556 prot_reg
[3] &= ~(1 << 7);
558 prot_reg
[3] |= (1 << 7);
566 for (i
= first
; i
<= last
; i
++) {
567 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
568 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
571 prot_reg
[reg
] &= ~(1 << bit
);
573 prot_reg
[reg
] |= (1 << bit
);
576 /* medium density flash */
577 for (i
= first
; i
<= last
; i
++) {
578 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
579 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
582 prot_reg
[reg
] &= ~(1 << bit
);
584 prot_reg
[reg
] |= (1 << bit
);
588 status
= stm32x_erase_options(bank
);
589 if (status
!= ERROR_OK
)
592 stm32x_info
->option_bytes
.protection
[0] = prot_reg
[0];
593 stm32x_info
->option_bytes
.protection
[1] = prot_reg
[1];
594 stm32x_info
->option_bytes
.protection
[2] = prot_reg
[2];
595 stm32x_info
->option_bytes
.protection
[3] = prot_reg
[3];
597 return stm32x_write_options(bank
);
600 static int stm32x_write_block(struct flash_bank
*bank
, uint8_t *buffer
,
601 uint32_t offset
, uint32_t count
)
603 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
604 struct target
*target
= bank
->target
;
605 uint32_t buffer_size
= 16384;
606 struct working_area
*source
;
607 uint32_t address
= bank
->base
+ offset
;
608 struct reg_param reg_params
[5];
609 struct armv7m_algorithm armv7m_info
;
610 int retval
= ERROR_OK
;
612 /* see contrib/loaders/flash/stm32f1x.S for src */
614 static const uint8_t stm32x_flash_write_code
[] = {
615 /* #define STM32_FLASH_SR_OFFSET 0x0C */
617 0x16, 0x68, /* ldr r6, [r2, #0] */
618 0x00, 0x2e, /* cmp r6, #0 */
619 0x18, 0xd0, /* beq exit */
620 0x55, 0x68, /* ldr r5, [r2, #4] */
621 0xb5, 0x42, /* cmp r5, r6 */
622 0xf9, 0xd0, /* beq wait_fifo */
623 0x2e, 0x88, /* ldrh r6, [r5, #0] */
624 0x26, 0x80, /* strh r6, [r4, #0] */
625 0x02, 0x35, /* adds r5, #2 */
626 0x02, 0x34, /* adds r4, #2 */
628 0xc6, 0x68, /* ldr r6, [r0, #STM32_FLASH_SR_OFFSET] */
629 0x01, 0x27, /* movs r7, #1 */
630 0x3e, 0x42, /* tst r6, r7 */
631 0xfb, 0xd1, /* bne busy */
632 0x14, 0x27, /* movs r7, #0x14 */
633 0x3e, 0x42, /* tst r6, r7 */
634 0x08, 0xd1, /* bne error */
635 0x9d, 0x42, /* cmp r5, r3 */
636 0x01, 0xd3, /* bcc no_wrap */
637 0x15, 0x46, /* mov r5, r2 */
638 0x08, 0x35, /* adds r5, #8 */
640 0x55, 0x60, /* str r5, [r2, #4] */
641 0x01, 0x39, /* subs r1, r1, #1 */
642 0x00, 0x29, /* cmp r1, #0 */
643 0x02, 0xd0, /* beq exit */
644 0xe5, 0xe7, /* b wait_fifo */
646 0x00, 0x20, /* movs r0, #0 */
647 0x50, 0x60, /* str r0, [r2, #4] */
649 0x30, 0x46, /* mov r0, r6 */
650 0x00, 0xbe, /* bkpt #0 */
653 /* flash write code */
654 if (target_alloc_working_area(target
, sizeof(stm32x_flash_write_code
),
655 &stm32x_info
->write_algorithm
) != ERROR_OK
) {
656 LOG_WARNING("no working area available, can't do block memory writes");
657 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
660 retval
= target_write_buffer(target
, stm32x_info
->write_algorithm
->address
,
661 sizeof(stm32x_flash_write_code
), (uint8_t *)stm32x_flash_write_code
);
662 if (retval
!= ERROR_OK
)
666 while (target_alloc_working_area_try(target
, buffer_size
, &source
) != ERROR_OK
) {
668 buffer_size
&= ~3UL; /* Make sure it's 4 byte aligned */
669 if (buffer_size
<= 256) {
670 /* if we already allocated the writing code, but failed to get a
671 * buffer, free the algorithm */
672 if (stm32x_info
->write_algorithm
)
673 target_free_working_area(target
, stm32x_info
->write_algorithm
);
675 LOG_WARNING("no large enough working area available, can't do block memory writes");
676 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
680 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* flash base (in), status (out) */
681 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* count (halfword-16bit) */
682 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* buffer start */
683 init_reg_param(®_params
[3], "r3", 32, PARAM_OUT
); /* buffer end */
684 init_reg_param(®_params
[4], "r4", 32, PARAM_IN_OUT
); /* target address */
686 buf_set_u32(reg_params
[0].value
, 0, 32, stm32x_info
->register_base
);
687 buf_set_u32(reg_params
[1].value
, 0, 32, count
);
688 buf_set_u32(reg_params
[2].value
, 0, 32, source
->address
);
689 buf_set_u32(reg_params
[3].value
, 0, 32, source
->address
+ source
->size
);
690 buf_set_u32(reg_params
[4].value
, 0, 32, address
);
692 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
693 armv7m_info
.core_mode
= ARMV7M_MODE_ANY
;
695 retval
= target_run_flash_async_algorithm(target
, buffer
, count
, 2,
698 source
->address
, source
->size
,
699 stm32x_info
->write_algorithm
->address
, 0,
702 if (retval
== ERROR_FLASH_OPERATION_FAILED
) {
703 LOG_ERROR("flash write failed at address 0x%"PRIx32
,
704 buf_get_u32(reg_params
[4].value
, 0, 32));
706 if (buf_get_u32(reg_params
[0].value
, 0, 32) & FLASH_PGERR
) {
707 LOG_ERROR("flash memory not erased before writing");
708 /* Clear but report errors */
709 target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
), FLASH_PGERR
);
712 if (buf_get_u32(reg_params
[0].value
, 0, 32) & FLASH_WRPRTERR
) {
713 LOG_ERROR("flash memory write protected");
714 /* Clear but report errors */
715 target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
), FLASH_WRPRTERR
);
719 target_free_working_area(target
, source
);
720 target_free_working_area(target
, stm32x_info
->write_algorithm
);
722 destroy_reg_param(®_params
[0]);
723 destroy_reg_param(®_params
[1]);
724 destroy_reg_param(®_params
[2]);
725 destroy_reg_param(®_params
[3]);
726 destroy_reg_param(®_params
[4]);
731 static int stm32x_write(struct flash_bank
*bank
, uint8_t *buffer
,
732 uint32_t offset
, uint32_t count
)
734 struct target
*target
= bank
->target
;
735 uint8_t *new_buffer
= NULL
;
737 if (bank
->target
->state
!= TARGET_HALTED
) {
738 LOG_ERROR("Target not halted");
739 return ERROR_TARGET_NOT_HALTED
;
743 LOG_ERROR("offset 0x%" PRIx32
" breaks required 2-byte alignment", offset
);
744 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
747 /* If there's an odd number of bytes, the data has to be padded. Duplicate
748 * the buffer and use the normal code path with a single block write since
749 * it's probably cheaper than to special case the last odd write using
750 * discrete accesses. */
752 new_buffer
= malloc(count
+ 1);
753 if (new_buffer
== NULL
) {
754 LOG_ERROR("odd number of bytes to write and no memory for padding buffer");
757 LOG_INFO("odd number of bytes to write, padding with 0xff");
758 buffer
= memcpy(new_buffer
, buffer
, count
);
759 buffer
[count
++] = 0xff;
762 uint32_t words_remaining
= count
/ 2;
765 /* unlock flash registers */
766 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
767 if (retval
!= ERROR_OK
)
769 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
770 if (retval
!= ERROR_OK
)
773 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PG
);
774 if (retval
!= ERROR_OK
)
777 /* try using a block write */
778 retval
= stm32x_write_block(bank
, buffer
, offset
, words_remaining
);
780 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
) {
781 /* if block write failed (no sufficient working area),
782 * we use normal (slow) single halfword accesses */
783 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
785 while (words_remaining
> 0) {
787 memcpy(&value
, buffer
, sizeof(uint16_t));
789 retval
= target_write_u16(target
, bank
->base
+ offset
, value
);
790 if (retval
!= ERROR_OK
)
791 goto reset_pg_and_lock
;
793 retval
= stm32x_wait_status_busy(bank
, 5);
794 if (retval
!= ERROR_OK
)
795 goto reset_pg_and_lock
;
804 retval2
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
805 if (retval
== ERROR_OK
)
815 static int stm32x_get_device_id(struct flash_bank
*bank
, uint32_t *device_id
)
817 /* This check the device CPUID core register to detect
818 * the M0 from the M3 devices. */
820 struct target
*target
= bank
->target
;
821 uint32_t cpuid
, device_id_register
= 0;
823 /* Get the CPUID from the ARM Core
824 * http://infocenter.arm.com/help/topic/com.arm.doc.ddi0432c/DDI0432C_cortex_m0_r0p0_trm.pdf 4.2.1 */
825 int retval
= target_read_u32(target
, 0xE000ED00, &cpuid
);
826 if (retval
!= ERROR_OK
)
829 if (((cpuid
>> 4) & 0xFFF) == 0xC20) {
830 /* 0xC20 is M0 devices */
831 device_id_register
= 0x40015800;
832 } else if (((cpuid
>> 4) & 0xFFF) == 0xC23) {
833 /* 0xC23 is M3 devices */
834 device_id_register
= 0xE0042000;
835 } else if (((cpuid
>> 4) & 0xFFF) == 0xC24) {
836 /* 0xC24 is M4 devices */
837 device_id_register
= 0xE0042000;
839 LOG_ERROR("Cannot identify target as a stm32x");
843 /* read stm32 device id register */
844 retval
= target_read_u32(target
, device_id_register
, device_id
);
845 if (retval
!= ERROR_OK
)
851 static int stm32x_get_flash_size(struct flash_bank
*bank
, uint16_t *flash_size_in_kb
)
853 struct target
*target
= bank
->target
;
854 uint32_t cpuid
, flash_size_reg
;
856 int retval
= target_read_u32(target
, 0xE000ED00, &cpuid
);
857 if (retval
!= ERROR_OK
)
860 if (((cpuid
>> 4) & 0xFFF) == 0xC20) {
861 /* 0xC20 is M0 devices */
862 flash_size_reg
= 0x1FFFF7CC;
863 } else if (((cpuid
>> 4) & 0xFFF) == 0xC23) {
864 /* 0xC23 is M3 devices */
865 flash_size_reg
= 0x1FFFF7E0;
866 } else if (((cpuid
>> 4) & 0xFFF) == 0xC24) {
867 /* 0xC24 is M4 devices */
868 flash_size_reg
= 0x1FFFF7CC;
870 LOG_ERROR("Cannot identify target as a stm32x");
874 retval
= target_read_u16(target
, flash_size_reg
, flash_size_in_kb
);
875 if (retval
!= ERROR_OK
)
881 static int stm32x_probe(struct flash_bank
*bank
)
883 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
885 uint16_t flash_size_in_kb
;
886 uint16_t max_flash_size_in_kb
;
889 uint32_t base_address
= 0x08000000;
891 stm32x_info
->probed
= 0;
892 stm32x_info
->register_base
= FLASH_REG_BASE_B0
;
894 /* read stm32 device id register */
895 int retval
= stm32x_get_device_id(bank
, &device_id
);
896 if (retval
!= ERROR_OK
)
899 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
901 /* set page size, protection granularity and max flash size depending on family */
902 switch (device_id
& 0xfff) {
903 case 0x410: /* medium density */
905 stm32x_info
->ppage_size
= 4;
906 max_flash_size_in_kb
= 128;
908 case 0x412: /* low density */
910 stm32x_info
->ppage_size
= 4;
911 max_flash_size_in_kb
= 32;
913 case 0x414: /* high density */
915 stm32x_info
->ppage_size
= 2;
916 max_flash_size_in_kb
= 512;
918 case 0x418: /* connectivity line density */
920 stm32x_info
->ppage_size
= 2;
921 max_flash_size_in_kb
= 256;
923 case 0x420: /* value line density */
925 stm32x_info
->ppage_size
= 4;
926 max_flash_size_in_kb
= 128;
928 case 0x422: /* stm32f30x */
930 stm32x_info
->ppage_size
= 2;
931 max_flash_size_in_kb
= 256;
933 case 0x428: /* value line High density */
935 stm32x_info
->ppage_size
= 4;
936 max_flash_size_in_kb
= 128;
938 case 0x430: /* xl line density (dual flash banks) */
940 stm32x_info
->ppage_size
= 2;
941 max_flash_size_in_kb
= 1024;
942 stm32x_info
->has_dual_banks
= true;
944 case 0x432: /* stm32f37x */
946 stm32x_info
->ppage_size
= 2;
947 max_flash_size_in_kb
= 256;
949 case 0x440: /* stm32f0x */
951 stm32x_info
->ppage_size
= 4;
952 max_flash_size_in_kb
= 64;
955 LOG_WARNING("Cannot identify target as a STM32 family.");
959 /* get flash size from target. */
960 retval
= stm32x_get_flash_size(bank
, &flash_size_in_kb
);
962 /* failed reading flash size or flash size invalid (early silicon),
963 * default to max target family */
964 if (retval
!= ERROR_OK
|| flash_size_in_kb
== 0xffff || flash_size_in_kb
== 0) {
965 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming %dk flash",
966 max_flash_size_in_kb
);
967 flash_size_in_kb
= max_flash_size_in_kb
;
970 if (stm32x_info
->has_dual_banks
) {
971 /* split reported size into matching bank */
972 if (bank
->base
!= 0x08080000) {
973 /* bank 0 will be fixed 512k */
974 flash_size_in_kb
= 512;
976 flash_size_in_kb
-= 512;
977 /* bank1 also uses a register offset */
978 stm32x_info
->register_base
= FLASH_REG_BASE_B1
;
979 base_address
= 0x08080000;
983 LOG_INFO("flash size = %dkbytes", flash_size_in_kb
);
985 /* did we assign flash size? */
986 assert(flash_size_in_kb
!= 0xffff);
988 /* calculate numbers of pages */
989 int num_pages
= flash_size_in_kb
* 1024 / page_size
;
991 /* check that calculation result makes sense */
992 assert(num_pages
> 0);
996 bank
->sectors
= NULL
;
999 bank
->base
= base_address
;
1000 bank
->size
= (num_pages
* page_size
);
1001 bank
->num_sectors
= num_pages
;
1002 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
1004 for (i
= 0; i
< num_pages
; i
++) {
1005 bank
->sectors
[i
].offset
= i
* page_size
;
1006 bank
->sectors
[i
].size
= page_size
;
1007 bank
->sectors
[i
].is_erased
= -1;
1008 bank
->sectors
[i
].is_protected
= 1;
1011 stm32x_info
->probed
= 1;
1016 static int stm32x_auto_probe(struct flash_bank
*bank
)
1018 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
1019 if (stm32x_info
->probed
)
1021 return stm32x_probe(bank
);
1025 COMMAND_HANDLER(stm32x_handle_part_id_command
)
1031 static int get_stm32x_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
1036 /* read stm32 device id register */
1037 int retval
= stm32x_get_device_id(bank
, &device_id
);
1038 if (retval
!= ERROR_OK
)
1041 if ((device_id
& 0xfff) == 0x410) {
1042 printed
= snprintf(buf
, buf_size
, "stm32x (Medium Density) - Rev: ");
1044 buf_size
-= printed
;
1046 switch (device_id
>> 16) {
1048 snprintf(buf
, buf_size
, "A");
1052 snprintf(buf
, buf_size
, "B");
1056 snprintf(buf
, buf_size
, "Z");
1060 snprintf(buf
, buf_size
, "Y");
1064 snprintf(buf
, buf_size
, "unknown");
1067 } else if ((device_id
& 0xfff) == 0x412) {
1068 printed
= snprintf(buf
, buf_size
, "stm32x (Low Density) - Rev: ");
1070 buf_size
-= printed
;
1072 switch (device_id
>> 16) {
1074 snprintf(buf
, buf_size
, "A");
1078 snprintf(buf
, buf_size
, "unknown");
1081 } else if ((device_id
& 0xfff) == 0x414) {
1082 printed
= snprintf(buf
, buf_size
, "stm32x (High Density) - Rev: ");
1084 buf_size
-= printed
;
1086 switch (device_id
>> 16) {
1088 snprintf(buf
, buf_size
, "A");
1092 snprintf(buf
, buf_size
, "Z");
1096 snprintf(buf
, buf_size
, "unknown");
1099 } else if ((device_id
& 0xfff) == 0x418) {
1100 printed
= snprintf(buf
, buf_size
, "stm32x (Connectivity) - Rev: ");
1102 buf_size
-= printed
;
1104 switch (device_id
>> 16) {
1106 snprintf(buf
, buf_size
, "A");
1110 snprintf(buf
, buf_size
, "Z");
1114 snprintf(buf
, buf_size
, "unknown");
1117 } else if ((device_id
& 0xfff) == 0x420) {
1118 printed
= snprintf(buf
, buf_size
, "stm32x (Value) - Rev: ");
1120 buf_size
-= printed
;
1122 switch (device_id
>> 16) {
1124 snprintf(buf
, buf_size
, "A");
1128 snprintf(buf
, buf_size
, "Z");
1132 snprintf(buf
, buf_size
, "unknown");
1135 } else if ((device_id
& 0xfff) == 0x422) {
1136 printed
= snprintf(buf
, buf_size
, "stm32f30x - Rev: ");
1138 buf_size
-= printed
;
1140 switch (device_id
>> 16) {
1142 snprintf(buf
, buf_size
, "1.0");
1146 snprintf(buf
, buf_size
, "unknown");
1149 } else if ((device_id
& 0xfff) == 0x428) {
1150 printed
= snprintf(buf
, buf_size
, "stm32x (Value HD) - Rev: ");
1152 buf_size
-= printed
;
1154 switch (device_id
>> 16) {
1156 snprintf(buf
, buf_size
, "A");
1160 snprintf(buf
, buf_size
, "Z");
1164 snprintf(buf
, buf_size
, "unknown");
1167 } else if ((device_id
& 0xfff) == 0x430) {
1168 printed
= snprintf(buf
, buf_size
, "stm32x (XL) - Rev: ");
1170 buf_size
-= printed
;
1172 switch (device_id
>> 16) {
1174 snprintf(buf
, buf_size
, "A");
1178 snprintf(buf
, buf_size
, "unknown");
1181 } else if ((device_id
& 0xfff) == 0x432) {
1182 printed
= snprintf(buf
, buf_size
, "stm32f37x - Rev: ");
1184 buf_size
-= printed
;
1186 switch (device_id
>> 16) {
1188 snprintf(buf
, buf_size
, "1.0");
1192 snprintf(buf
, buf_size
, "unknown");
1195 } else if ((device_id
& 0xfff) == 0x440) {
1196 printed
= snprintf(buf
, buf_size
, "stm32f0x - Rev: ");
1198 buf_size
-= printed
;
1200 switch (device_id
>> 16) {
1202 snprintf(buf
, buf_size
, "1.0");
1206 snprintf(buf
, buf_size
, "2.0");
1210 snprintf(buf
, buf_size
, "unknown");
1214 snprintf(buf
, buf_size
, "Cannot identify target as a stm32x\n");
1221 COMMAND_HANDLER(stm32x_handle_lock_command
)
1223 struct target
*target
= NULL
;
1224 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1227 return ERROR_COMMAND_SYNTAX_ERROR
;
1229 struct flash_bank
*bank
;
1230 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1231 if (ERROR_OK
!= retval
)
1234 stm32x_info
= bank
->driver_priv
;
1236 target
= bank
->target
;
1238 if (target
->state
!= TARGET_HALTED
) {
1239 LOG_ERROR("Target not halted");
1240 return ERROR_TARGET_NOT_HALTED
;
1243 retval
= stm32x_check_operation_supported(bank
);
1244 if (ERROR_OK
!= retval
)
1247 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1248 command_print(CMD_CTX
, "stm32x failed to erase options");
1252 /* set readout protection */
1253 stm32x_info
->option_bytes
.RDP
= 0;
1255 if (stm32x_write_options(bank
) != ERROR_OK
) {
1256 command_print(CMD_CTX
, "stm32x failed to lock device");
1260 command_print(CMD_CTX
, "stm32x locked");
1265 COMMAND_HANDLER(stm32x_handle_unlock_command
)
1267 struct target
*target
= NULL
;
1270 return ERROR_COMMAND_SYNTAX_ERROR
;
1272 struct flash_bank
*bank
;
1273 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1274 if (ERROR_OK
!= retval
)
1277 target
= bank
->target
;
1279 if (target
->state
!= TARGET_HALTED
) {
1280 LOG_ERROR("Target not halted");
1281 return ERROR_TARGET_NOT_HALTED
;
1284 retval
= stm32x_check_operation_supported(bank
);
1285 if (ERROR_OK
!= retval
)
1288 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1289 command_print(CMD_CTX
, "stm32x failed to unlock device");
1293 if (stm32x_write_options(bank
) != ERROR_OK
) {
1294 command_print(CMD_CTX
, "stm32x failed to lock device");
1298 command_print(CMD_CTX
, "stm32x unlocked.\n"
1299 "INFO: a reset or power cycle is required "
1300 "for the new settings to take effect.");
1305 COMMAND_HANDLER(stm32x_handle_options_read_command
)
1307 uint32_t optionbyte
;
1308 struct target
*target
= NULL
;
1309 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1312 return ERROR_COMMAND_SYNTAX_ERROR
;
1314 struct flash_bank
*bank
;
1315 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1316 if (ERROR_OK
!= retval
)
1319 stm32x_info
= bank
->driver_priv
;
1321 target
= bank
->target
;
1323 if (target
->state
!= TARGET_HALTED
) {
1324 LOG_ERROR("Target not halted");
1325 return ERROR_TARGET_NOT_HALTED
;
1328 retval
= stm32x_check_operation_supported(bank
);
1329 if (ERROR_OK
!= retval
)
1332 retval
= target_read_u32(target
, STM32_FLASH_OBR_B0
, &optionbyte
);
1333 if (retval
!= ERROR_OK
)
1335 command_print(CMD_CTX
, "Option Byte: 0x%" PRIx32
"", optionbyte
);
1337 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_ERROR
, 1))
1338 command_print(CMD_CTX
, "Option Byte Complement Error");
1340 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_READOUT
, 1))
1341 command_print(CMD_CTX
, "Readout Protection On");
1343 command_print(CMD_CTX
, "Readout Protection Off");
1345 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_RDWDGSW
, 1))
1346 command_print(CMD_CTX
, "Software Watchdog");
1348 command_print(CMD_CTX
, "Hardware Watchdog");
1350 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_RDRSTSTOP
, 1))
1351 command_print(CMD_CTX
, "Stop: No reset generated");
1353 command_print(CMD_CTX
, "Stop: Reset generated");
1355 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_RDRSTSTDBY
, 1))
1356 command_print(CMD_CTX
, "Standby: No reset generated");
1358 command_print(CMD_CTX
, "Standby: Reset generated");
1360 if (stm32x_info
->has_dual_banks
) {
1361 if (buf_get_u32((uint8_t *)&optionbyte
, OPT_BFB2
, 1))
1362 command_print(CMD_CTX
, "Boot: Bank 0");
1364 command_print(CMD_CTX
, "Boot: Bank 1");
1370 COMMAND_HANDLER(stm32x_handle_options_write_command
)
1372 struct target
*target
= NULL
;
1373 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1374 uint16_t optionbyte
= 0xF8;
1377 return ERROR_COMMAND_SYNTAX_ERROR
;
1379 struct flash_bank
*bank
;
1380 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1381 if (ERROR_OK
!= retval
)
1384 stm32x_info
= bank
->driver_priv
;
1386 target
= bank
->target
;
1388 if (target
->state
!= TARGET_HALTED
) {
1389 LOG_ERROR("Target not halted");
1390 return ERROR_TARGET_NOT_HALTED
;
1393 retval
= stm32x_check_operation_supported(bank
);
1394 if (ERROR_OK
!= retval
)
1397 /* REVISIT: ignores some options which we will display...
1398 * and doesn't insist on the specified syntax.
1402 if (strcmp(CMD_ARGV
[1], "SWWDG") == 0)
1403 optionbyte
|= (1 << 0);
1404 else /* REVISIT must be "HWWDG" then ... */
1405 optionbyte
&= ~(1 << 0);
1408 if (strcmp(CMD_ARGV
[2], "NORSTSTOP") == 0)
1409 optionbyte
|= (1 << 1);
1410 else /* REVISIT must be "RSTSTNDBY" then ... */
1411 optionbyte
&= ~(1 << 1);
1413 /* OPT_RDRSTSTDBY */
1414 if (strcmp(CMD_ARGV
[3], "NORSTSTNDBY") == 0)
1415 optionbyte
|= (1 << 2);
1416 else /* REVISIT must be "RSTSTOP" then ... */
1417 optionbyte
&= ~(1 << 2);
1419 if (CMD_ARGC
> 4 && stm32x_info
->has_dual_banks
) {
1421 if (strcmp(CMD_ARGV
[4], "BOOT0") == 0)
1422 optionbyte
|= (1 << 3);
1424 optionbyte
&= ~(1 << 3);
1427 if (stm32x_erase_options(bank
) != ERROR_OK
) {
1428 command_print(CMD_CTX
, "stm32x failed to erase options");
1432 stm32x_info
->option_bytes
.user_options
= optionbyte
;
1434 if (stm32x_write_options(bank
) != ERROR_OK
) {
1435 command_print(CMD_CTX
, "stm32x failed to write options");
1439 command_print(CMD_CTX
, "stm32x write options complete.\n"
1440 "INFO: a reset or power cycle is required "
1441 "for the new settings to take effect.");
1446 static int stm32x_mass_erase(struct flash_bank
*bank
)
1448 struct target
*target
= bank
->target
;
1450 if (target
->state
!= TARGET_HALTED
) {
1451 LOG_ERROR("Target not halted");
1452 return ERROR_TARGET_NOT_HALTED
;
1455 /* unlock option flash registers */
1456 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
1457 if (retval
!= ERROR_OK
)
1459 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
1460 if (retval
!= ERROR_OK
)
1463 /* mass erase flash memory */
1464 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_MER
);
1465 if (retval
!= ERROR_OK
)
1467 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
),
1468 FLASH_MER
| FLASH_STRT
);
1469 if (retval
!= ERROR_OK
)
1472 retval
= stm32x_wait_status_busy(bank
, 100);
1473 if (retval
!= ERROR_OK
)
1476 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
1477 if (retval
!= ERROR_OK
)
1483 COMMAND_HANDLER(stm32x_handle_mass_erase_command
)
1488 return ERROR_COMMAND_SYNTAX_ERROR
;
1490 struct flash_bank
*bank
;
1491 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1492 if (ERROR_OK
!= retval
)
1495 retval
= stm32x_mass_erase(bank
);
1496 if (retval
== ERROR_OK
) {
1497 /* set all sectors as erased */
1498 for (i
= 0; i
< bank
->num_sectors
; i
++)
1499 bank
->sectors
[i
].is_erased
= 1;
1501 command_print(CMD_CTX
, "stm32x mass erase complete");
1503 command_print(CMD_CTX
, "stm32x mass erase failed");
1508 static const struct command_registration stm32x_exec_command_handlers
[] = {
1511 .handler
= stm32x_handle_lock_command
,
1512 .mode
= COMMAND_EXEC
,
1514 .help
= "Lock entire flash device.",
1518 .handler
= stm32x_handle_unlock_command
,
1519 .mode
= COMMAND_EXEC
,
1521 .help
= "Unlock entire protected flash device.",
1524 .name
= "mass_erase",
1525 .handler
= stm32x_handle_mass_erase_command
,
1526 .mode
= COMMAND_EXEC
,
1528 .help
= "Erase entire flash device.",
1531 .name
= "options_read",
1532 .handler
= stm32x_handle_options_read_command
,
1533 .mode
= COMMAND_EXEC
,
1535 .help
= "Read and display device option byte.",
1538 .name
= "options_write",
1539 .handler
= stm32x_handle_options_write_command
,
1540 .mode
= COMMAND_EXEC
,
1541 .usage
= "bank_id ('SWWDG'|'HWWDG') "
1542 "('RSTSTNDBY'|'NORSTSTNDBY') "
1543 "('RSTSTOP'|'NORSTSTOP')",
1544 .help
= "Replace bits in device option byte.",
1546 COMMAND_REGISTRATION_DONE
1549 static const struct command_registration stm32x_command_handlers
[] = {
1552 .mode
= COMMAND_ANY
,
1553 .help
= "stm32f1x flash command group",
1555 .chain
= stm32x_exec_command_handlers
,
1557 COMMAND_REGISTRATION_DONE
1560 struct flash_driver stm32f1x_flash
= {
1562 .commands
= stm32x_command_handlers
,
1563 .flash_bank_command
= stm32x_flash_bank_command
,
1564 .erase
= stm32x_erase
,
1565 .protect
= stm32x_protect
,
1566 .write
= stm32x_write
,
1567 .read
= default_flash_read
,
1568 .probe
= stm32x_probe
,
1569 .auto_probe
= stm32x_auto_probe
,
1570 .erase_check
= default_flash_blank_check
,
1571 .protect_check
= stm32x_protect_check
,
1572 .info
= get_stm32x_info
,
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)