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 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
29 #include <helper/binarybuffer.h>
30 #include <target/algorithm.h>
31 #include <target/armv7m.h>
34 static int stm32x_mass_erase(struct flash_bank
*bank
);
36 /* flash bank stm32x <base> <size> 0 0 <target#>
38 FLASH_BANK_COMMAND_HANDLER(stm32x_flash_bank_command
)
40 struct stm32x_flash_bank
*stm32x_info
;
44 LOG_WARNING("incomplete flash_bank stm32x configuration");
45 return ERROR_FLASH_BANK_INVALID
;
48 stm32x_info
= malloc(sizeof(struct stm32x_flash_bank
));
49 bank
->driver_priv
= stm32x_info
;
51 stm32x_info
->write_algorithm
= NULL
;
52 stm32x_info
->probed
= 0;
57 static uint32_t stm32x_get_flash_status(struct flash_bank
*bank
)
59 struct target
*target
= bank
->target
;
62 target_read_u32(target
, STM32_FLASH_SR
, &status
);
67 static uint32_t stm32x_wait_status_busy(struct flash_bank
*bank
, int timeout
)
69 struct target
*target
= bank
->target
;
72 /* wait for busy to clear */
73 while (((status
= stm32x_get_flash_status(bank
)) & FLASH_BSY
) && (timeout
-- > 0))
75 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
78 /* Clear but report errors */
79 if (status
& (FLASH_WRPRTERR
| FLASH_PGERR
))
81 target_write_u32(target
, STM32_FLASH_SR
, FLASH_WRPRTERR
| FLASH_PGERR
);
86 static int stm32x_read_options(struct flash_bank
*bank
)
89 struct stm32x_flash_bank
*stm32x_info
= NULL
;
90 struct target
*target
= bank
->target
;
92 stm32x_info
= bank
->driver_priv
;
94 /* read current option bytes */
95 target_read_u32(target
, STM32_FLASH_OBR
, &optiondata
);
97 stm32x_info
->option_bytes
.user_options
= (uint16_t)0xFFF8 | ((optiondata
>> 2) & 0x07);
98 stm32x_info
->option_bytes
.RDP
= (optiondata
& (1 << OPT_READOUT
)) ? 0xFFFF : 0x5AA5;
100 if (optiondata
& (1 << OPT_READOUT
))
101 LOG_INFO("Device Security Bit Set");
103 /* each bit refers to a 4bank protection */
104 target_read_u32(target
, STM32_FLASH_WRPR
, &optiondata
);
106 stm32x_info
->option_bytes
.protection
[0] = (uint16_t)optiondata
;
107 stm32x_info
->option_bytes
.protection
[1] = (uint16_t)(optiondata
>> 8);
108 stm32x_info
->option_bytes
.protection
[2] = (uint16_t)(optiondata
>> 16);
109 stm32x_info
->option_bytes
.protection
[3] = (uint16_t)(optiondata
>> 24);
114 static int stm32x_erase_options(struct flash_bank
*bank
)
116 struct stm32x_flash_bank
*stm32x_info
= NULL
;
117 struct target
*target
= bank
->target
;
120 stm32x_info
= bank
->driver_priv
;
122 /* read current options */
123 stm32x_read_options(bank
);
125 /* unlock flash registers */
126 target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
127 target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
129 /* unlock option flash registers */
130 target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY1
);
131 target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY2
);
133 /* erase option bytes */
134 target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTER
| FLASH_OPTWRE
);
135 target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTER
| FLASH_STRT
| FLASH_OPTWRE
);
137 status
= stm32x_wait_status_busy(bank
, 10);
139 if (status
& FLASH_WRPRTERR
)
140 return ERROR_FLASH_OPERATION_FAILED
;
141 if (status
& FLASH_PGERR
)
142 return ERROR_FLASH_OPERATION_FAILED
;
144 /* clear readout protection and complementary option bytes
145 * this will also force a device unlock if set */
146 stm32x_info
->option_bytes
.RDP
= 0x5AA5;
151 static int stm32x_write_options(struct flash_bank
*bank
)
153 struct stm32x_flash_bank
*stm32x_info
= NULL
;
154 struct target
*target
= bank
->target
;
157 stm32x_info
= bank
->driver_priv
;
159 /* unlock flash registers */
160 target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
161 target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
163 /* unlock option flash registers */
164 target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY1
);
165 target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY2
);
167 /* program option bytes */
168 target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTPG
| FLASH_OPTWRE
);
170 /* write user option byte */
171 target_write_u16(target
, STM32_OB_USER
, stm32x_info
->option_bytes
.user_options
);
173 status
= stm32x_wait_status_busy(bank
, 10);
175 if (status
& FLASH_WRPRTERR
)
176 return ERROR_FLASH_OPERATION_FAILED
;
177 if (status
& FLASH_PGERR
)
178 return ERROR_FLASH_OPERATION_FAILED
;
180 /* write protection byte 1 */
181 target_write_u16(target
, STM32_OB_WRP0
, stm32x_info
->option_bytes
.protection
[0]);
183 status
= stm32x_wait_status_busy(bank
, 10);
185 if (status
& FLASH_WRPRTERR
)
186 return ERROR_FLASH_OPERATION_FAILED
;
187 if (status
& FLASH_PGERR
)
188 return ERROR_FLASH_OPERATION_FAILED
;
190 /* write protection byte 2 */
191 target_write_u16(target
, STM32_OB_WRP1
, stm32x_info
->option_bytes
.protection
[1]);
193 status
= stm32x_wait_status_busy(bank
, 10);
195 if (status
& FLASH_WRPRTERR
)
196 return ERROR_FLASH_OPERATION_FAILED
;
197 if (status
& FLASH_PGERR
)
198 return ERROR_FLASH_OPERATION_FAILED
;
200 /* write protection byte 3 */
201 target_write_u16(target
, STM32_OB_WRP2
, stm32x_info
->option_bytes
.protection
[2]);
203 status
= stm32x_wait_status_busy(bank
, 10);
205 if (status
& FLASH_WRPRTERR
)
206 return ERROR_FLASH_OPERATION_FAILED
;
207 if (status
& FLASH_PGERR
)
208 return ERROR_FLASH_OPERATION_FAILED
;
210 /* write protection byte 4 */
211 target_write_u16(target
, STM32_OB_WRP3
, stm32x_info
->option_bytes
.protection
[3]);
213 status
= stm32x_wait_status_busy(bank
, 10);
215 if (status
& FLASH_WRPRTERR
)
216 return ERROR_FLASH_OPERATION_FAILED
;
217 if (status
& FLASH_PGERR
)
218 return ERROR_FLASH_OPERATION_FAILED
;
220 /* write readout protection bit */
221 target_write_u16(target
, STM32_OB_RDP
, stm32x_info
->option_bytes
.RDP
);
223 status
= stm32x_wait_status_busy(bank
, 10);
225 if (status
& FLASH_WRPRTERR
)
226 return ERROR_FLASH_OPERATION_FAILED
;
227 if (status
& FLASH_PGERR
)
228 return ERROR_FLASH_OPERATION_FAILED
;
230 target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
235 static int stm32x_protect_check(struct flash_bank
*bank
)
237 struct target
*target
= bank
->target
;
238 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
245 if (target
->state
!= TARGET_HALTED
)
247 LOG_ERROR("Target not halted");
248 return ERROR_TARGET_NOT_HALTED
;
251 /* medium density - each bit refers to a 4bank protection
252 * high density - each bit refers to a 2bank protection */
253 target_read_u32(target
, STM32_FLASH_WRPR
, &protection
);
255 /* medium density - each protection bit is for 4 * 1K pages
256 * high density - each protection bit is for 2 * 2K pages */
257 num_bits
= (bank
->num_sectors
/ stm32x_info
->ppage_size
);
259 if (stm32x_info
->ppage_size
== 2)
261 /* high density flash/connectivity line protection */
265 if (protection
& (1 << 31))
268 /* bit 31 controls sector 62 - 255 protection for high density
269 * bit 31 controls sector 62 - 127 protection for connectivity line */
270 for (s
= 62; s
< bank
->num_sectors
; s
++)
272 bank
->sectors
[s
].is_protected
= set
;
275 if (bank
->num_sectors
> 61)
278 for (i
= 0; i
< num_bits
; i
++)
282 if (protection
& (1 << i
))
285 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
286 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
291 /* low/medium density flash protection */
292 for (i
= 0; i
< num_bits
; i
++)
296 if (protection
& (1 << i
))
299 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
300 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
307 static int stm32x_erase(struct flash_bank
*bank
, int first
, int last
)
309 struct target
*target
= bank
->target
;
313 if (bank
->target
->state
!= TARGET_HALTED
)
315 LOG_ERROR("Target not halted");
316 return ERROR_TARGET_NOT_HALTED
;
319 if ((first
== 0) && (last
== (bank
->num_sectors
- 1)))
321 return stm32x_mass_erase(bank
);
324 /* unlock flash registers */
325 target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
326 target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
328 for (i
= first
; i
<= last
; i
++)
330 target_write_u32(target
, STM32_FLASH_CR
, FLASH_PER
);
331 target_write_u32(target
, STM32_FLASH_AR
, bank
->base
+ bank
->sectors
[i
].offset
);
332 target_write_u32(target
, STM32_FLASH_CR
, FLASH_PER
| FLASH_STRT
);
334 status
= stm32x_wait_status_busy(bank
, 10);
336 if (status
& FLASH_WRPRTERR
)
337 return ERROR_FLASH_OPERATION_FAILED
;
338 if (status
& FLASH_PGERR
)
339 return ERROR_FLASH_OPERATION_FAILED
;
340 bank
->sectors
[i
].is_erased
= 1;
343 target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
348 static int stm32x_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
350 struct stm32x_flash_bank
*stm32x_info
= NULL
;
351 struct target
*target
= bank
->target
;
352 uint16_t prot_reg
[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
357 stm32x_info
= bank
->driver_priv
;
359 if (target
->state
!= TARGET_HALTED
)
361 LOG_ERROR("Target not halted");
362 return ERROR_TARGET_NOT_HALTED
;
365 if ((first
&& (first
% stm32x_info
->ppage_size
)) || ((last
+ 1) && (last
+ 1) % stm32x_info
->ppage_size
))
367 LOG_WARNING("Error: start and end sectors must be on a %d sector boundary", stm32x_info
->ppage_size
);
368 return ERROR_FLASH_SECTOR_INVALID
;
371 /* medium density - each bit refers to a 4bank protection
372 * high density - each bit refers to a 2bank protection */
373 target_read_u32(target
, STM32_FLASH_WRPR
, &protection
);
375 prot_reg
[0] = (uint16_t)protection
;
376 prot_reg
[1] = (uint16_t)(protection
>> 8);
377 prot_reg
[2] = (uint16_t)(protection
>> 16);
378 prot_reg
[3] = (uint16_t)(protection
>> 24);
380 if (stm32x_info
->ppage_size
== 2)
382 /* high density flash */
384 /* bit 7 controls sector 62 - 255 protection */
388 prot_reg
[3] &= ~(1 << 7);
390 prot_reg
[3] |= (1 << 7);
398 for (i
= first
; i
<= last
; i
++)
400 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
401 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
404 prot_reg
[reg
] &= ~(1 << bit
);
406 prot_reg
[reg
] |= (1 << bit
);
411 /* medium density flash */
412 for (i
= first
; i
<= last
; i
++)
414 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
415 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
418 prot_reg
[reg
] &= ~(1 << bit
);
420 prot_reg
[reg
] |= (1 << bit
);
424 if ((status
= stm32x_erase_options(bank
)) != ERROR_OK
)
427 stm32x_info
->option_bytes
.protection
[0] = prot_reg
[0];
428 stm32x_info
->option_bytes
.protection
[1] = prot_reg
[1];
429 stm32x_info
->option_bytes
.protection
[2] = prot_reg
[2];
430 stm32x_info
->option_bytes
.protection
[3] = prot_reg
[3];
432 return stm32x_write_options(bank
);
435 static int stm32x_write_block(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
437 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
438 struct target
*target
= bank
->target
;
439 uint32_t buffer_size
= 16384;
440 struct working_area
*source
;
441 uint32_t address
= bank
->base
+ offset
;
442 struct reg_param reg_params
[4];
443 struct armv7m_algorithm armv7m_info
;
444 int retval
= ERROR_OK
;
446 uint8_t stm32x_flash_write_code
[] = {
448 0xDF, 0xF8, 0x24, 0x40, /* ldr r4, STM32_FLASH_CR */
449 0x09, 0x4D, /* ldr r5, STM32_FLASH_SR */
450 0x4F, 0xF0, 0x01, 0x03, /* mov r3, #1 */
451 0x23, 0x60, /* str r3, [r4, #0] */
452 0x30, 0xF8, 0x02, 0x3B, /* ldrh r3, [r0], #2 */
453 0x21, 0xF8, 0x02, 0x3B, /* strh r3, [r1], #2 */
455 0x2B, 0x68, /* ldr r3, [r5, #0] */
456 0x13, 0xF0, 0x01, 0x0F, /* tst r3, #0x01 */
457 0xFB, 0xD0, /* beq busy */
458 0x13, 0xF0, 0x14, 0x0F, /* tst r3, #0x14 */
459 0x01, 0xD1, /* bne exit */
460 0x01, 0x3A, /* subs r2, r2, #1 */
461 0xED, 0xD1, /* bne write */
463 0xFE, 0xE7, /* b exit */
464 0x10, 0x20, 0x02, 0x40, /* STM32_FLASH_CR: .word 0x40022010 */
465 0x0C, 0x20, 0x02, 0x40 /* STM32_FLASH_SR: .word 0x4002200C */
468 /* flash write code */
469 if (target_alloc_working_area(target
, sizeof(stm32x_flash_write_code
), &stm32x_info
->write_algorithm
) != ERROR_OK
)
471 LOG_WARNING("no working area available, can't do block memory writes");
472 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
475 if ((retval
= target_write_buffer(target
, stm32x_info
->write_algorithm
->address
, sizeof(stm32x_flash_write_code
), stm32x_flash_write_code
)) != ERROR_OK
)
479 while (target_alloc_working_area(target
, buffer_size
, &source
) != ERROR_OK
)
482 if (buffer_size
<= 256)
484 /* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
485 if (stm32x_info
->write_algorithm
)
486 target_free_working_area(target
, stm32x_info
->write_algorithm
);
488 LOG_WARNING("no large enough working area available, can't do block memory writes");
489 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
493 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
494 armv7m_info
.core_mode
= ARMV7M_MODE_ANY
;
496 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
497 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
498 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
);
499 init_reg_param(®_params
[3], "r3", 32, PARAM_IN
);
503 uint32_t thisrun_count
= (count
> (buffer_size
/ 2)) ? (buffer_size
/ 2) : count
;
505 if ((retval
= target_write_buffer(target
, source
->address
, thisrun_count
* 2, buffer
)) != ERROR_OK
)
508 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
509 buf_set_u32(reg_params
[1].value
, 0, 32, address
);
510 buf_set_u32(reg_params
[2].value
, 0, 32, thisrun_count
);
512 if ((retval
= target_run_algorithm(target
, 0, NULL
, 4, reg_params
, stm32x_info
->write_algorithm
->address
, \
513 stm32x_info
->write_algorithm
->address
+ (sizeof(stm32x_flash_write_code
) - 10), 10000, &armv7m_info
)) != ERROR_OK
)
515 LOG_ERROR("error executing stm32x flash write algorithm");
516 retval
= ERROR_FLASH_OPERATION_FAILED
;
520 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_PGERR
)
522 LOG_ERROR("flash memory not erased before writing");
523 /* Clear but report errors */
524 target_write_u32(target
, STM32_FLASH_SR
, FLASH_PGERR
);
525 retval
= ERROR_FLASH_OPERATION_FAILED
;
529 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_WRPRTERR
)
531 LOG_ERROR("flash memory write protected");
532 /* Clear but report errors */
533 target_write_u32(target
, STM32_FLASH_SR
, FLASH_WRPRTERR
);
534 retval
= ERROR_FLASH_OPERATION_FAILED
;
538 buffer
+= thisrun_count
* 2;
539 address
+= thisrun_count
* 2;
540 count
-= thisrun_count
;
543 target_free_working_area(target
, source
);
544 target_free_working_area(target
, stm32x_info
->write_algorithm
);
546 destroy_reg_param(®_params
[0]);
547 destroy_reg_param(®_params
[1]);
548 destroy_reg_param(®_params
[2]);
549 destroy_reg_param(®_params
[3]);
554 static int stm32x_write(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
556 struct target
*target
= bank
->target
;
557 uint32_t words_remaining
= (count
/ 2);
558 uint32_t bytes_remaining
= (count
& 0x00000001);
559 uint32_t address
= bank
->base
+ offset
;
560 uint32_t bytes_written
= 0;
564 if (bank
->target
->state
!= TARGET_HALTED
)
566 LOG_ERROR("Target not halted");
567 return ERROR_TARGET_NOT_HALTED
;
572 LOG_WARNING("offset 0x%" PRIx32
" breaks required 2-byte alignment", offset
);
573 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
576 /* unlock flash registers */
577 target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
578 target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
580 /* multiple half words (2-byte) to be programmed? */
581 if (words_remaining
> 0)
583 /* try using a block write */
584 if ((retval
= stm32x_write_block(bank
, buffer
, offset
, words_remaining
)) != ERROR_OK
)
586 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
588 /* if block write failed (no sufficient working area),
589 * we use normal (slow) single dword accesses */
590 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
592 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
594 LOG_ERROR("flash writing failed with error code: 0x%x", retval
);
595 return ERROR_FLASH_OPERATION_FAILED
;
600 buffer
+= words_remaining
* 2;
601 address
+= words_remaining
* 2;
606 while (words_remaining
> 0)
609 memcpy(&value
, buffer
+ bytes_written
, sizeof(uint16_t));
611 target_write_u32(target
, STM32_FLASH_CR
, FLASH_PG
);
612 target_write_u16(target
, address
, value
);
614 status
= stm32x_wait_status_busy(bank
, 5);
616 if (status
& FLASH_WRPRTERR
)
618 LOG_ERROR("flash memory not erased before writing");
619 return ERROR_FLASH_OPERATION_FAILED
;
621 if (status
& FLASH_PGERR
)
623 LOG_ERROR("flash memory write protected");
624 return ERROR_FLASH_OPERATION_FAILED
;
634 uint16_t value
= 0xffff;
635 memcpy(&value
, buffer
+ bytes_written
, bytes_remaining
);
637 target_write_u32(target
, STM32_FLASH_CR
, FLASH_PG
);
638 target_write_u16(target
, address
, value
);
640 status
= stm32x_wait_status_busy(bank
, 5);
642 if (status
& FLASH_WRPRTERR
)
644 LOG_ERROR("flash memory not erased before writing");
645 return ERROR_FLASH_OPERATION_FAILED
;
647 if (status
& FLASH_PGERR
)
649 LOG_ERROR("flash memory write protected");
650 return ERROR_FLASH_OPERATION_FAILED
;
654 target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
659 static int stm32x_probe(struct flash_bank
*bank
)
661 struct target
*target
= bank
->target
;
662 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
668 if (bank
->target
->state
!= TARGET_HALTED
)
670 LOG_ERROR("Target not halted");
671 return ERROR_TARGET_NOT_HALTED
;
674 stm32x_info
->probed
= 0;
676 /* read stm32 device id register */
677 target_read_u32(target
, 0xE0042000, &device_id
);
678 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
680 /* get flash size from target */
681 if (target_read_u16(target
, 0x1FFFF7E0, &num_pages
) != ERROR_OK
)
683 /* failed reading flash size, default to max target family */
687 if ((device_id
& 0x7ff) == 0x410)
689 /* medium density - we have 1k pages
690 * 4 pages for a protection area */
692 stm32x_info
->ppage_size
= 4;
694 /* check for early silicon */
695 if (num_pages
== 0xffff)
697 /* number of sectors incorrect on revA */
698 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
702 else if ((device_id
& 0x7ff) == 0x412)
704 /* low density - we have 1k pages
705 * 4 pages for a protection area */
707 stm32x_info
->ppage_size
= 4;
709 /* check for early silicon */
710 if (num_pages
== 0xffff)
712 /* number of sectors incorrect on revA */
713 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 32k flash");
717 else if ((device_id
& 0x7ff) == 0x414)
719 /* high density - we have 2k pages
720 * 2 pages for a protection area */
722 stm32x_info
->ppage_size
= 2;
724 /* check for early silicon */
725 if (num_pages
== 0xffff)
727 /* number of sectors incorrect on revZ */
728 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 512k flash");
732 else if ((device_id
& 0x7ff) == 0x418)
734 /* connectivity line density - we have 2k pages
735 * 2 pages for a protection area */
737 stm32x_info
->ppage_size
= 2;
739 /* check for early silicon */
740 if (num_pages
== 0xffff)
742 /* number of sectors incorrect on revZ */
743 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 256k flash");
749 LOG_WARNING("Cannot identify target as a STM32 family.");
750 return ERROR_FLASH_OPERATION_FAILED
;
753 LOG_INFO("flash size = %dkbytes", num_pages
);
755 /* calculate numbers of pages */
756 num_pages
/= (page_size
/ 1024);
758 bank
->base
= 0x08000000;
759 bank
->size
= (num_pages
* page_size
);
760 bank
->num_sectors
= num_pages
;
761 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
763 for (i
= 0; i
< num_pages
; i
++)
765 bank
->sectors
[i
].offset
= i
* page_size
;
766 bank
->sectors
[i
].size
= page_size
;
767 bank
->sectors
[i
].is_erased
= -1;
768 bank
->sectors
[i
].is_protected
= 1;
771 stm32x_info
->probed
= 1;
776 static int stm32x_auto_probe(struct flash_bank
*bank
)
778 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
779 if (stm32x_info
->probed
)
781 return stm32x_probe(bank
);
785 COMMAND_HANDLER(stm32x_handle_part_id_command
)
791 static int stm32x_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
793 struct target
*target
= bank
->target
;
797 /* read stm32 device id register */
798 target_read_u32(target
, 0xE0042000, &device_id
);
800 if ((device_id
& 0x7ff) == 0x410)
802 printed
= snprintf(buf
, buf_size
, "stm32x (Medium Density) - Rev: ");
806 switch (device_id
>> 16)
809 snprintf(buf
, buf_size
, "A");
813 snprintf(buf
, buf_size
, "B");
817 snprintf(buf
, buf_size
, "Z");
821 snprintf(buf
, buf_size
, "Y");
825 snprintf(buf
, buf_size
, "unknown");
829 else if ((device_id
& 0x7ff) == 0x412)
831 printed
= snprintf(buf
, buf_size
, "stm32x (Low Density) - Rev: ");
835 switch (device_id
>> 16)
838 snprintf(buf
, buf_size
, "A");
842 snprintf(buf
, buf_size
, "unknown");
846 else if ((device_id
& 0x7ff) == 0x414)
848 printed
= snprintf(buf
, buf_size
, "stm32x (High Density) - Rev: ");
852 switch (device_id
>> 16)
855 snprintf(buf
, buf_size
, "A");
859 snprintf(buf
, buf_size
, "Z");
863 snprintf(buf
, buf_size
, "unknown");
867 else if ((device_id
& 0x7ff) == 0x418)
869 printed
= snprintf(buf
, buf_size
, "stm32x (Connectivity) - Rev: ");
873 switch (device_id
>> 16)
876 snprintf(buf
, buf_size
, "A");
880 snprintf(buf
, buf_size
, "Z");
884 snprintf(buf
, buf_size
, "unknown");
890 snprintf(buf
, buf_size
, "Cannot identify target as a stm32x\n");
891 return ERROR_FLASH_OPERATION_FAILED
;
897 COMMAND_HANDLER(stm32x_handle_lock_command
)
899 struct target
*target
= NULL
;
900 struct stm32x_flash_bank
*stm32x_info
= NULL
;
904 command_print(CMD_CTX
, "stm32x lock <bank>");
908 struct flash_bank
*bank
;
909 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
910 if (ERROR_OK
!= retval
)
913 stm32x_info
= bank
->driver_priv
;
915 target
= bank
->target
;
917 if (target
->state
!= TARGET_HALTED
)
919 LOG_ERROR("Target not halted");
920 return ERROR_TARGET_NOT_HALTED
;
923 if (stm32x_erase_options(bank
) != ERROR_OK
)
925 command_print(CMD_CTX
, "stm32x failed to erase options");
929 /* set readout protection */
930 stm32x_info
->option_bytes
.RDP
= 0;
932 if (stm32x_write_options(bank
) != ERROR_OK
)
934 command_print(CMD_CTX
, "stm32x failed to lock device");
938 command_print(CMD_CTX
, "stm32x locked");
943 COMMAND_HANDLER(stm32x_handle_unlock_command
)
945 struct target
*target
= NULL
;
946 struct stm32x_flash_bank
*stm32x_info
= NULL
;
950 command_print(CMD_CTX
, "stm32x unlock <bank>");
954 struct flash_bank
*bank
;
955 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
956 if (ERROR_OK
!= retval
)
959 stm32x_info
= bank
->driver_priv
;
961 target
= bank
->target
;
963 if (target
->state
!= TARGET_HALTED
)
965 LOG_ERROR("Target not halted");
966 return ERROR_TARGET_NOT_HALTED
;
969 if (stm32x_erase_options(bank
) != ERROR_OK
)
971 command_print(CMD_CTX
, "stm32x failed to unlock device");
975 if (stm32x_write_options(bank
) != ERROR_OK
)
977 command_print(CMD_CTX
, "stm32x failed to lock device");
981 command_print(CMD_CTX
, "stm32x unlocked");
986 COMMAND_HANDLER(stm32x_handle_options_read_command
)
989 struct target
*target
= NULL
;
990 struct stm32x_flash_bank
*stm32x_info
= NULL
;
994 command_print(CMD_CTX
, "stm32x options_read <bank>");
998 struct flash_bank
*bank
;
999 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1000 if (ERROR_OK
!= retval
)
1003 stm32x_info
= bank
->driver_priv
;
1005 target
= bank
->target
;
1007 if (target
->state
!= TARGET_HALTED
)
1009 LOG_ERROR("Target not halted");
1010 return ERROR_TARGET_NOT_HALTED
;
1013 target_read_u32(target
, STM32_FLASH_OBR
, &optionbyte
);
1014 command_print(CMD_CTX
, "Option Byte: 0x%" PRIx32
"", optionbyte
);
1016 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_ERROR
, 1))
1017 command_print(CMD_CTX
, "Option Byte Complement Error");
1019 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_READOUT
, 1))
1020 command_print(CMD_CTX
, "Readout Protection On");
1022 command_print(CMD_CTX
, "Readout Protection Off");
1024 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDWDGSW
, 1))
1025 command_print(CMD_CTX
, "Software Watchdog");
1027 command_print(CMD_CTX
, "Hardware Watchdog");
1029 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDRSTSTOP
, 1))
1030 command_print(CMD_CTX
, "Stop: No reset generated");
1032 command_print(CMD_CTX
, "Stop: Reset generated");
1034 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDRSTSTDBY
, 1))
1035 command_print(CMD_CTX
, "Standby: No reset generated");
1037 command_print(CMD_CTX
, "Standby: Reset generated");
1042 COMMAND_HANDLER(stm32x_handle_options_write_command
)
1044 struct target
*target
= NULL
;
1045 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1046 uint16_t optionbyte
= 0xF8;
1050 command_print(CMD_CTX
, "stm32x options_write <bank> <SWWDG | HWWDG> <RSTSTNDBY | NORSTSTNDBY> <RSTSTOP | NORSTSTOP>");
1054 struct flash_bank
*bank
;
1055 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1056 if (ERROR_OK
!= retval
)
1059 stm32x_info
= bank
->driver_priv
;
1061 target
= bank
->target
;
1063 if (target
->state
!= TARGET_HALTED
)
1065 LOG_ERROR("Target not halted");
1066 return ERROR_TARGET_NOT_HALTED
;
1069 if (strcmp(CMD_ARGV
[1], "SWWDG") == 0)
1071 optionbyte
|= (1 << 0);
1075 optionbyte
&= ~(1 << 0);
1078 if (strcmp(CMD_ARGV
[2], "NORSTSTNDBY") == 0)
1080 optionbyte
|= (1 << 1);
1084 optionbyte
&= ~(1 << 1);
1087 if (strcmp(CMD_ARGV
[3], "NORSTSTOP") == 0)
1089 optionbyte
|= (1 << 2);
1093 optionbyte
&= ~(1 << 2);
1096 if (stm32x_erase_options(bank
) != ERROR_OK
)
1098 command_print(CMD_CTX
, "stm32x failed to erase options");
1102 stm32x_info
->option_bytes
.user_options
= optionbyte
;
1104 if (stm32x_write_options(bank
) != ERROR_OK
)
1106 command_print(CMD_CTX
, "stm32x failed to write options");
1110 command_print(CMD_CTX
, "stm32x write options complete");
1115 static int stm32x_mass_erase(struct flash_bank
*bank
)
1117 struct target
*target
= bank
->target
;
1120 if (target
->state
!= TARGET_HALTED
)
1122 LOG_ERROR("Target not halted");
1123 return ERROR_TARGET_NOT_HALTED
;
1126 /* unlock option flash registers */
1127 target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
1128 target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
1130 /* mass erase flash memory */
1131 target_write_u32(target
, STM32_FLASH_CR
, FLASH_MER
);
1132 target_write_u32(target
, STM32_FLASH_CR
, FLASH_MER
| FLASH_STRT
);
1134 status
= stm32x_wait_status_busy(bank
, 10);
1136 target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
1138 if (status
& FLASH_WRPRTERR
)
1140 LOG_ERROR("stm32x device protected");
1144 if (status
& FLASH_PGERR
)
1146 LOG_ERROR("stm32x device programming failed");
1153 COMMAND_HANDLER(stm32x_handle_mass_erase_command
)
1159 command_print(CMD_CTX
, "stm32x mass_erase <bank>");
1163 struct flash_bank
*bank
;
1164 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1165 if (ERROR_OK
!= retval
)
1168 if (stm32x_mass_erase(bank
) == ERROR_OK
)
1170 /* set all sectors as erased */
1171 for (i
= 0; i
< bank
->num_sectors
; i
++)
1173 bank
->sectors
[i
].is_erased
= 1;
1176 command_print(CMD_CTX
, "stm32x mass erase complete");
1180 command_print(CMD_CTX
, "stm32x mass erase failed");
1186 static const struct command_registration stm32x_exec_command_handlers
[] = {
1189 .handler
= &stm32x_handle_lock_command
,
1190 .mode
= COMMAND_EXEC
,
1191 .help
= "lock device",
1195 .handler
= &stm32x_handle_unlock_command
,
1196 .mode
= COMMAND_EXEC
,
1197 .help
= "unlock protected device",
1200 .name
= "mass_erase",
1201 .handler
= &stm32x_handle_mass_erase_command
,
1202 .mode
= COMMAND_EXEC
,
1203 .help
= "mass erase device",
1206 .name
= "options_read",
1207 .handler
= &stm32x_handle_options_read_command
,
1208 .mode
= COMMAND_EXEC
,
1209 .help
= "read device option bytes",
1212 .name
= "options_write",
1213 .handler
= &stm32x_handle_options_write_command
,
1214 .mode
= COMMAND_EXEC
,
1215 .help
= "write device option bytes",
1217 COMMAND_REGISTRATION_DONE
1219 static const struct command_registration stm32x_command_handlers
[] = {
1222 .mode
= COMMAND_ANY
,
1223 .help
= "stm32x flash command group",
1224 .chain
= stm32x_exec_command_handlers
,
1226 COMMAND_REGISTRATION_DONE
1229 struct flash_driver stm32x_flash
= {
1231 .commands
= stm32x_command_handlers
,
1232 .flash_bank_command
= &stm32x_flash_bank_command
,
1233 .erase
= &stm32x_erase
,
1234 .protect
= &stm32x_protect
,
1235 .write
= &stm32x_write
,
1236 .probe
= &stm32x_probe
,
1237 .auto_probe
= &stm32x_auto_probe
,
1238 .erase_check
= &default_flash_mem_blank_check
,
1239 .protect_check
= &stm32x_protect_check
,
1240 .info
= &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)