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 ***************************************************************************/
28 #include <helper/binarybuffer.h>
29 #include <target/algorithm.h>
30 #include <target/armv7m.h>
32 /* stm32x register locations */
34 #define STM32_FLASH_ACR 0x40022000
35 #define STM32_FLASH_KEYR 0x40022004
36 #define STM32_FLASH_OPTKEYR 0x40022008
37 #define STM32_FLASH_SR 0x4002200C
38 #define STM32_FLASH_CR 0x40022010
39 #define STM32_FLASH_AR 0x40022014
40 #define STM32_FLASH_OBR 0x4002201C
41 #define STM32_FLASH_WRPR 0x40022020
43 /* option byte location */
45 #define STM32_OB_RDP 0x1FFFF800
46 #define STM32_OB_USER 0x1FFFF802
47 #define STM32_OB_DATA0 0x1FFFF804
48 #define STM32_OB_DATA1 0x1FFFF806
49 #define STM32_OB_WRP0 0x1FFFF808
50 #define STM32_OB_WRP1 0x1FFFF80A
51 #define STM32_OB_WRP2 0x1FFFF80C
52 #define STM32_OB_WRP3 0x1FFFF80E
54 /* FLASH_CR register bits */
56 #define FLASH_PG (1 << 0)
57 #define FLASH_PER (1 << 1)
58 #define FLASH_MER (1 << 2)
59 #define FLASH_OPTPG (1 << 4)
60 #define FLASH_OPTER (1 << 5)
61 #define FLASH_STRT (1 << 6)
62 #define FLASH_LOCK (1 << 7)
63 #define FLASH_OPTWRE (1 << 9)
65 /* FLASH_SR register bits */
67 #define FLASH_BSY (1 << 0)
68 #define FLASH_PGERR (1 << 2)
69 #define FLASH_WRPRTERR (1 << 4)
70 #define FLASH_EOP (1 << 5)
72 /* STM32_FLASH_OBR bit definitions (reading) */
77 #define OPT_RDRSTSTOP 3
78 #define OPT_RDRSTSTDBY 4
79 #define OPT_BFB2 5 /* dual flash bank only */
81 /* register unlock keys */
83 #define KEY1 0x45670123
84 #define KEY2 0xCDEF89AB
86 /* we use an offset to access the second bank on dual flash devices
87 * strangely the protection of the second bank is done on the bank0 reg's */
89 #define FLASH_OFFSET_B0 0x00
90 #define FLASH_OFFSET_B1 0x40
95 uint16_t user_options
;
96 uint16_t protection
[4];
99 struct stm32x_flash_bank
101 struct stm32x_options option_bytes
;
102 struct working_area
*write_algorithm
;
107 /* used to access dual flash bank stm32xl
108 * 0x00 will address bank 0 flash
109 * 0x40 will address bank 1 flash */
113 static int stm32x_mass_erase(struct flash_bank
*bank
);
115 /* flash bank stm32x <base> <size> 0 0 <target#>
117 FLASH_BANK_COMMAND_HANDLER(stm32x_flash_bank_command
)
119 struct stm32x_flash_bank
*stm32x_info
;
123 LOG_WARNING("incomplete flash_bank stm32x configuration");
124 return ERROR_FLASH_BANK_INVALID
;
127 stm32x_info
= malloc(sizeof(struct stm32x_flash_bank
));
128 bank
->driver_priv
= stm32x_info
;
130 stm32x_info
->write_algorithm
= NULL
;
131 stm32x_info
->probed
= 0;
132 stm32x_info
->has_dual_banks
= false;
133 stm32x_info
->register_offset
= FLASH_OFFSET_B0
;
138 static inline int stm32x_get_flash_reg(struct flash_bank
*bank
, uint32_t reg
)
140 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
141 return reg
+ stm32x_info
->register_offset
;
144 static inline int stm32x_get_flash_status(struct flash_bank
*bank
, uint32_t *status
)
146 struct target
*target
= bank
->target
;
147 return target_read_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
), status
);
150 static int stm32x_wait_status_busy(struct flash_bank
*bank
, int timeout
)
152 struct target
*target
= bank
->target
;
154 int retval
= ERROR_OK
;
156 /* wait for busy to clear */
159 retval
= stm32x_get_flash_status(bank
, &status
);
160 if (retval
!= ERROR_OK
)
162 LOG_DEBUG("status: 0x%" PRIx32
"", status
);
163 if ((status
& FLASH_BSY
) == 0)
167 LOG_ERROR("timed out waiting for flash");
173 if (status
& FLASH_WRPRTERR
)
175 LOG_ERROR("stm32x device protected");
179 if (status
& FLASH_PGERR
)
181 LOG_ERROR("stm32x device programming failed");
185 /* Clear but report errors */
186 if (status
& (FLASH_WRPRTERR
| FLASH_PGERR
))
188 /* If this operation fails, we ignore it and report the original
191 target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_SR
),
192 FLASH_WRPRTERR
| FLASH_PGERR
);
197 int stm32x_check_operation_supported(struct flash_bank
*bank
)
199 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
201 /* if we have a dual flash bank device then
202 * we need to perform option byte stuff on bank0 only */
203 if (stm32x_info
->register_offset
!= FLASH_OFFSET_B0
)
205 LOG_ERROR("Option Byte Operation's must use bank0");
206 return ERROR_FLASH_OPERATION_FAILED
;
212 static int stm32x_read_options(struct flash_bank
*bank
)
215 struct stm32x_flash_bank
*stm32x_info
= NULL
;
216 struct target
*target
= bank
->target
;
218 stm32x_info
= bank
->driver_priv
;
220 /* read current option bytes */
221 int retval
= target_read_u32(target
, STM32_FLASH_OBR
, &optiondata
);
222 if (retval
!= ERROR_OK
)
225 stm32x_info
->option_bytes
.user_options
= (uint16_t)0xFFF8 | ((optiondata
>> 2) & 0x07);
226 stm32x_info
->option_bytes
.RDP
= (optiondata
& (1 << OPT_READOUT
)) ? 0xFFFF : 0x5AA5;
228 if (optiondata
& (1 << OPT_READOUT
))
229 LOG_INFO("Device Security Bit Set");
231 /* each bit refers to a 4bank protection */
232 retval
= target_read_u32(target
, STM32_FLASH_WRPR
, &optiondata
);
233 if (retval
!= ERROR_OK
)
236 stm32x_info
->option_bytes
.protection
[0] = (uint16_t)optiondata
;
237 stm32x_info
->option_bytes
.protection
[1] = (uint16_t)(optiondata
>> 8);
238 stm32x_info
->option_bytes
.protection
[2] = (uint16_t)(optiondata
>> 16);
239 stm32x_info
->option_bytes
.protection
[3] = (uint16_t)(optiondata
>> 24);
244 static int stm32x_erase_options(struct flash_bank
*bank
)
246 struct stm32x_flash_bank
*stm32x_info
= NULL
;
247 struct target
*target
= bank
->target
;
249 stm32x_info
= bank
->driver_priv
;
251 /* read current options */
252 stm32x_read_options(bank
);
254 /* unlock flash registers */
255 int retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
256 if (retval
!= ERROR_OK
)
259 retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
260 if (retval
!= ERROR_OK
)
263 /* unlock option flash registers */
264 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY1
);
265 if (retval
!= ERROR_OK
)
267 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY2
);
268 if (retval
!= ERROR_OK
)
271 /* erase option bytes */
272 retval
= target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTER
| FLASH_OPTWRE
);
273 if (retval
!= ERROR_OK
)
275 retval
= target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTER
| FLASH_STRT
| FLASH_OPTWRE
);
276 if (retval
!= ERROR_OK
)
279 retval
= stm32x_wait_status_busy(bank
, 10);
280 if (retval
!= ERROR_OK
)
283 /* clear readout protection and complementary option bytes
284 * this will also force a device unlock if set */
285 stm32x_info
->option_bytes
.RDP
= 0x5AA5;
290 static int stm32x_write_options(struct flash_bank
*bank
)
292 struct stm32x_flash_bank
*stm32x_info
= NULL
;
293 struct target
*target
= bank
->target
;
295 stm32x_info
= bank
->driver_priv
;
297 /* unlock flash registers */
298 int retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY1
);
299 if (retval
!= ERROR_OK
)
301 retval
= target_write_u32(target
, STM32_FLASH_KEYR
, KEY2
);
302 if (retval
!= ERROR_OK
)
305 /* unlock option flash registers */
306 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY1
);
307 if (retval
!= ERROR_OK
)
309 retval
= target_write_u32(target
, STM32_FLASH_OPTKEYR
, KEY2
);
310 if (retval
!= ERROR_OK
)
313 /* program option bytes */
314 retval
= target_write_u32(target
, STM32_FLASH_CR
, FLASH_OPTPG
| FLASH_OPTWRE
);
315 if (retval
!= ERROR_OK
)
318 /* write user option byte */
319 retval
= target_write_u16(target
, STM32_OB_USER
, stm32x_info
->option_bytes
.user_options
);
320 if (retval
!= ERROR_OK
)
323 retval
= stm32x_wait_status_busy(bank
, 10);
324 if (retval
!= ERROR_OK
)
327 /* write protection byte 1 */
328 retval
= target_write_u16(target
, STM32_OB_WRP0
, stm32x_info
->option_bytes
.protection
[0]);
329 if (retval
!= ERROR_OK
)
332 retval
= stm32x_wait_status_busy(bank
, 10);
333 if (retval
!= ERROR_OK
)
336 /* write protection byte 2 */
337 retval
= target_write_u16(target
, STM32_OB_WRP1
, stm32x_info
->option_bytes
.protection
[1]);
338 if (retval
!= ERROR_OK
)
341 retval
= stm32x_wait_status_busy(bank
, 10);
342 if (retval
!= ERROR_OK
)
345 /* write protection byte 3 */
346 retval
= target_write_u16(target
, STM32_OB_WRP2
, stm32x_info
->option_bytes
.protection
[2]);
347 if (retval
!= ERROR_OK
)
350 retval
= stm32x_wait_status_busy(bank
, 10);
351 if (retval
!= ERROR_OK
)
354 /* write protection byte 4 */
355 retval
= target_write_u16(target
, STM32_OB_WRP3
, stm32x_info
->option_bytes
.protection
[3]);
356 if (retval
!= ERROR_OK
)
359 retval
= stm32x_wait_status_busy(bank
, 10);
360 if (retval
!= ERROR_OK
)
363 /* write readout protection bit */
364 retval
= target_write_u16(target
, STM32_OB_RDP
, stm32x_info
->option_bytes
.RDP
);
365 if (retval
!= ERROR_OK
)
368 retval
= stm32x_wait_status_busy(bank
, 10);
369 if (retval
!= ERROR_OK
)
372 retval
= target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
373 if (retval
!= ERROR_OK
)
379 static int stm32x_protect_check(struct flash_bank
*bank
)
381 struct target
*target
= bank
->target
;
382 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
389 if (target
->state
!= TARGET_HALTED
)
391 LOG_ERROR("Target not halted");
392 return ERROR_TARGET_NOT_HALTED
;
395 int retval
= stm32x_check_operation_supported(bank
);
396 if (ERROR_OK
!= retval
)
399 /* medium density - each bit refers to a 4bank protection
400 * high density - each bit refers to a 2bank protection */
401 retval
= target_read_u32(target
, STM32_FLASH_WRPR
, &protection
);
402 if (retval
!= ERROR_OK
)
405 /* medium density - each protection bit is for 4 * 1K pages
406 * high density - each protection bit is for 2 * 2K pages */
407 num_bits
= (bank
->num_sectors
/ stm32x_info
->ppage_size
);
409 if (stm32x_info
->ppage_size
== 2)
411 /* high density flash/connectivity line protection */
415 if (protection
& (1 << 31))
418 /* bit 31 controls sector 62 - 255 protection for high density
419 * bit 31 controls sector 62 - 127 protection for connectivity line */
420 for (s
= 62; s
< bank
->num_sectors
; s
++)
422 bank
->sectors
[s
].is_protected
= set
;
425 if (bank
->num_sectors
> 61)
428 for (i
= 0; i
< num_bits
; i
++)
432 if (protection
& (1 << i
))
435 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
436 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
441 /* low/medium density flash protection */
442 for (i
= 0; i
< num_bits
; i
++)
446 if (protection
& (1 << i
))
449 for (s
= 0; s
< stm32x_info
->ppage_size
; s
++)
450 bank
->sectors
[(i
* stm32x_info
->ppage_size
) + s
].is_protected
= set
;
457 static int stm32x_erase(struct flash_bank
*bank
, int first
, int last
)
459 struct target
*target
= bank
->target
;
462 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)))
470 return stm32x_mass_erase(bank
);
473 /* unlock flash registers */
474 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
475 if (retval
!= ERROR_OK
)
477 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
478 if (retval
!= ERROR_OK
)
481 for (i
= first
; i
<= last
; i
++)
483 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
);
484 if (retval
!= ERROR_OK
)
486 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_AR
),
487 bank
->base
+ bank
->sectors
[i
].offset
);
488 if (retval
!= ERROR_OK
)
490 retval
= target_write_u32(target
,
491 stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PER
| FLASH_STRT
);
492 if (retval
!= ERROR_OK
)
495 retval
= stm32x_wait_status_busy(bank
, 100);
496 if (retval
!= ERROR_OK
)
499 bank
->sectors
[i
].is_erased
= 1;
502 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
503 if (retval
!= ERROR_OK
)
509 static int stm32x_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
511 struct stm32x_flash_bank
*stm32x_info
= NULL
;
512 struct target
*target
= bank
->target
;
513 uint16_t prot_reg
[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
518 stm32x_info
= bank
->driver_priv
;
520 if (target
->state
!= TARGET_HALTED
)
522 LOG_ERROR("Target not halted");
523 return ERROR_TARGET_NOT_HALTED
;
526 int retval
= stm32x_check_operation_supported(bank
);
527 if (ERROR_OK
!= retval
)
530 if ((first
% stm32x_info
->ppage_size
) != 0)
532 LOG_WARNING("aligned start protect sector to a %d sector boundary",
533 stm32x_info
->ppage_size
);
534 first
= first
- (first
% stm32x_info
->ppage_size
);
536 if (((last
+ 1) % stm32x_info
->ppage_size
) != 0)
538 LOG_WARNING("aligned end protect sector to a %d sector boundary",
539 stm32x_info
->ppage_size
);
541 last
= last
- (last
% stm32x_info
->ppage_size
);
545 /* medium density - each bit refers to a 4bank protection
546 * high density - each bit refers to a 2bank protection */
547 retval
= target_read_u32(target
, STM32_FLASH_WRPR
, &protection
);
548 if (retval
!= ERROR_OK
)
551 prot_reg
[0] = (uint16_t)protection
;
552 prot_reg
[1] = (uint16_t)(protection
>> 8);
553 prot_reg
[2] = (uint16_t)(protection
>> 16);
554 prot_reg
[3] = (uint16_t)(protection
>> 24);
556 if (stm32x_info
->ppage_size
== 2)
558 /* high density flash */
560 /* bit 7 controls sector 62 - 255 protection */
564 prot_reg
[3] &= ~(1 << 7);
566 prot_reg
[3] |= (1 << 7);
574 for (i
= first
; i
<= last
; i
++)
576 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
577 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
580 prot_reg
[reg
] &= ~(1 << bit
);
582 prot_reg
[reg
] |= (1 << bit
);
587 /* medium density flash */
588 for (i
= first
; i
<= last
; i
++)
590 reg
= (i
/ stm32x_info
->ppage_size
) / 8;
591 bit
= (i
/ stm32x_info
->ppage_size
) - (reg
* 8);
594 prot_reg
[reg
] &= ~(1 << bit
);
596 prot_reg
[reg
] |= (1 << bit
);
600 if ((status
= stm32x_erase_options(bank
)) != ERROR_OK
)
603 stm32x_info
->option_bytes
.protection
[0] = prot_reg
[0];
604 stm32x_info
->option_bytes
.protection
[1] = prot_reg
[1];
605 stm32x_info
->option_bytes
.protection
[2] = prot_reg
[2];
606 stm32x_info
->option_bytes
.protection
[3] = prot_reg
[3];
608 return stm32x_write_options(bank
);
611 static int stm32x_write_block(struct flash_bank
*bank
, uint8_t *buffer
,
612 uint32_t offset
, uint32_t count
)
614 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
615 struct target
*target
= bank
->target
;
616 uint32_t buffer_size
= 16384;
617 struct working_area
*source
;
618 uint32_t address
= bank
->base
+ offset
;
619 struct reg_param reg_params
[4];
620 struct armv7m_algorithm armv7m_info
;
621 int retval
= ERROR_OK
;
623 /* see contib/loaders/flash/stm32x.s for src */
625 static const uint8_t stm32x_flash_write_code
[] = {
626 /* #define STM32_FLASH_CR_OFFSET 0x10 */
627 /* #define STM32_FLASH_SR_OFFSET 0x0C */
629 0x08, 0x4c, /* ldr r4, STM32_FLASH_BASE */
630 0x1c, 0x44, /* add r4, r3 */
631 /* write_half_word: */
632 0x01, 0x23, /* movs r3, #0x01 */
633 0x23, 0x61, /* str r3, [r4, #STM32_FLASH_CR_OFFSET] */
634 0x30, 0xf8, 0x02, 0x3b, /* ldrh r3, [r0], #0x02 */
635 0x21, 0xf8, 0x02, 0x3b, /* strh r3, [r1], #0x02 */
637 0xe3, 0x68, /* ldr r3, [r4, #STM32_FLASH_SR_OFFSET] */
638 0x13, 0xf0, 0x01, 0x0f, /* tst r3, #0x01 */
639 0xfb, 0xd0, /* beq busy */
640 0x13, 0xf0, 0x14, 0x0f, /* tst r3, #0x14 */
641 0x01, 0xd1, /* bne exit */
642 0x01, 0x3a, /* subs r2, r2, #0x01 */
643 0xf0, 0xd1, /* bne write_half_word */
645 0x00, 0xbe, /* bkpt #0x00 */
646 0x00, 0x20, 0x02, 0x40, /* STM32_FLASH_BASE: .word 0x40022000 */
649 /* flash write code */
650 if (target_alloc_working_area(target
, sizeof(stm32x_flash_write_code
),
651 &stm32x_info
->write_algorithm
) != ERROR_OK
)
653 LOG_WARNING("no working area available, can't do block memory writes");
654 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
657 if ((retval
= target_write_buffer(target
, stm32x_info
->write_algorithm
->address
,
658 sizeof(stm32x_flash_write_code
),
659 (uint8_t*)stm32x_flash_write_code
)) != ERROR_OK
)
663 while (target_alloc_working_area_try(target
, buffer_size
, &source
) != ERROR_OK
)
666 if (buffer_size
<= 256)
668 /* if we already allocated the writing code, but failed to get a
669 * buffer, free the algorithm */
670 if (stm32x_info
->write_algorithm
)
671 target_free_working_area(target
, stm32x_info
->write_algorithm
);
673 LOG_WARNING("no large enough working area available, can't do block memory writes");
674 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
678 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
679 armv7m_info
.core_mode
= ARMV7M_MODE_ANY
;
681 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
682 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
683 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
);
684 init_reg_param(®_params
[3], "r3", 32, PARAM_IN_OUT
);
688 uint32_t thisrun_count
= (count
> (buffer_size
/ 2)) ?
689 (buffer_size
/ 2) : count
;
691 if ((retval
= target_write_buffer(target
, source
->address
,
692 thisrun_count
* 2, buffer
)) != ERROR_OK
)
695 buf_set_u32(reg_params
[0].value
, 0, 32, source
->address
);
696 buf_set_u32(reg_params
[1].value
, 0, 32, address
);
697 buf_set_u32(reg_params
[2].value
, 0, 32, thisrun_count
);
698 buf_set_u32(reg_params
[3].value
, 0, 32, stm32x_info
->register_offset
);
700 if ((retval
= target_run_algorithm(target
, 0, NULL
, 4, reg_params
,
701 stm32x_info
->write_algorithm
->address
,
703 10000, &armv7m_info
)) != ERROR_OK
)
705 LOG_ERROR("error executing stm32x flash write algorithm");
709 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_PGERR
)
711 LOG_ERROR("flash memory not erased before writing");
712 /* Clear but report errors */
713 target_write_u32(target
, STM32_FLASH_SR
, FLASH_PGERR
);
718 if (buf_get_u32(reg_params
[3].value
, 0, 32) & FLASH_WRPRTERR
)
720 LOG_ERROR("flash memory write protected");
721 /* Clear but report errors */
722 target_write_u32(target
, STM32_FLASH_SR
, FLASH_WRPRTERR
);
727 buffer
+= thisrun_count
* 2;
728 address
+= thisrun_count
* 2;
729 count
-= thisrun_count
;
732 target_free_working_area(target
, source
);
733 target_free_working_area(target
, stm32x_info
->write_algorithm
);
735 destroy_reg_param(®_params
[0]);
736 destroy_reg_param(®_params
[1]);
737 destroy_reg_param(®_params
[2]);
738 destroy_reg_param(®_params
[3]);
743 static int stm32x_write(struct flash_bank
*bank
, uint8_t *buffer
,
744 uint32_t offset
, uint32_t count
)
746 struct target
*target
= bank
->target
;
747 uint32_t words_remaining
= (count
/ 2);
748 uint32_t bytes_remaining
= (count
& 0x00000001);
749 uint32_t address
= bank
->base
+ offset
;
750 uint32_t bytes_written
= 0;
753 if (bank
->target
->state
!= TARGET_HALTED
)
755 LOG_ERROR("Target not halted");
756 return ERROR_TARGET_NOT_HALTED
;
761 LOG_WARNING("offset 0x%" PRIx32
" breaks required 2-byte alignment", offset
);
762 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
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 /* multiple half words (2-byte) to be programmed? */
774 if (words_remaining
> 0)
776 /* try using a block write */
777 if ((retval
= stm32x_write_block(bank
, buffer
, offset
, words_remaining
)) != ERROR_OK
)
779 if (retval
== ERROR_TARGET_RESOURCE_NOT_AVAILABLE
)
781 /* if block write failed (no sufficient working area),
782 * we use normal (slow) single dword accesses */
783 LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
788 buffer
+= words_remaining
* 2;
789 address
+= words_remaining
* 2;
794 if ((retval
!= ERROR_OK
) && (retval
!= ERROR_TARGET_RESOURCE_NOT_AVAILABLE
))
797 while (words_remaining
> 0)
800 memcpy(&value
, buffer
+ bytes_written
, sizeof(uint16_t));
802 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PG
);
803 if (retval
!= ERROR_OK
)
805 retval
= target_write_u16(target
, address
, value
);
806 if (retval
!= ERROR_OK
)
809 retval
= stm32x_wait_status_busy(bank
, 5);
810 if (retval
!= ERROR_OK
)
820 uint16_t value
= 0xffff;
821 memcpy(&value
, buffer
+ bytes_written
, bytes_remaining
);
823 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_PG
);
824 if (retval
!= ERROR_OK
)
826 retval
= target_write_u16(target
, address
, value
);
827 if (retval
!= ERROR_OK
)
830 retval
= stm32x_wait_status_busy(bank
, 5);
831 if (retval
!= ERROR_OK
)
835 return target_write_u32(target
, STM32_FLASH_CR
, FLASH_LOCK
);
838 static int stm32x_probe(struct flash_bank
*bank
)
840 struct target
*target
= bank
->target
;
841 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
846 uint32_t base_address
= 0x08000000;
848 stm32x_info
->probed
= 0;
849 stm32x_info
->register_offset
= FLASH_OFFSET_B0
;
851 /* read stm32 device id register */
852 int retval
= target_read_u32(target
, 0xE0042000, &device_id
);
853 if (retval
!= ERROR_OK
)
855 LOG_INFO("device id = 0x%08" PRIx32
"", device_id
);
857 /* get flash size from target. */
858 retval
= target_read_u16(target
, 0x1FFFF7E0, &num_pages
);
859 if (retval
!= ERROR_OK
)
861 LOG_WARNING("failed reading flash size, default to max target family");
862 /* failed reading flash size, default to max target family */
866 if ((device_id
& 0x7ff) == 0x410)
868 /* medium density - we have 1k pages
869 * 4 pages for a protection area */
871 stm32x_info
->ppage_size
= 4;
873 /* check for early silicon */
874 if (num_pages
== 0xffff)
876 /* number of sectors incorrect on revA */
877 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
881 else if ((device_id
& 0x7ff) == 0x412)
883 /* low density - we have 1k pages
884 * 4 pages for a protection area */
886 stm32x_info
->ppage_size
= 4;
888 /* check for early silicon */
889 if (num_pages
== 0xffff)
891 /* number of sectors incorrect on revA */
892 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 32k flash");
896 else if ((device_id
& 0x7ff) == 0x414)
898 /* high density - we have 2k pages
899 * 2 pages for a protection area */
901 stm32x_info
->ppage_size
= 2;
903 /* check for early silicon */
904 if (num_pages
== 0xffff)
906 /* number of sectors incorrect on revZ */
907 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 512k flash");
911 else if ((device_id
& 0x7ff) == 0x418)
913 /* connectivity line density - we have 2k pages
914 * 2 pages for a protection area */
916 stm32x_info
->ppage_size
= 2;
918 /* check for early silicon */
919 if (num_pages
== 0xffff)
921 /* number of sectors incorrect on revZ */
922 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 256k flash");
926 else if ((device_id
& 0x7ff) == 0x420)
928 /* value line density - we have 1k pages
929 * 4 pages for a protection area */
931 stm32x_info
->ppage_size
= 4;
933 /* check for early silicon */
934 if (num_pages
== 0xffff)
936 /* number of sectors may be incorrrect on early silicon */
937 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
941 else if ((device_id
& 0x7ff) == 0x428)
943 /* value line density - we have 1k pages
944 * 4 pages for a protection area */
946 stm32x_info
->ppage_size
= 4;
948 /* check for early silicon */
949 if (num_pages
== 0xffff)
951 /* number of sectors may be incorrrect on early silicon */
952 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
957 else if ((device_id
& 0x7ff) == 0x430)
959 /* xl line density - we have 2k pages
960 * 2 pages for a protection area */
962 stm32x_info
->ppage_size
= 2;
963 stm32x_info
->has_dual_banks
= true;
965 /* check for early silicon */
966 if (num_pages
== 0xffff)
968 /* number of sectors may be incorrrect on early silicon */
969 LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 1024k flash");
973 /* split reported size into matching bank */
974 if (bank
->base
!= 0x08080000)
976 /* bank 0 will be fixed 512k */
982 /* bank1 also uses a register offset */
983 stm32x_info
->register_offset
= FLASH_OFFSET_B1
;
984 base_address
= 0x08080000;
989 LOG_WARNING("Cannot identify target as a STM32 family.");
993 LOG_INFO("flash size = %dkbytes", num_pages
);
995 /* calculate numbers of pages */
996 num_pages
/= (page_size
/ 1024);
1000 free(bank
->sectors
);
1001 bank
->sectors
= NULL
;
1004 bank
->base
= base_address
;
1005 bank
->size
= (num_pages
* page_size
);
1006 bank
->num_sectors
= num_pages
;
1007 bank
->sectors
= malloc(sizeof(struct flash_sector
) * num_pages
);
1009 for (i
= 0; i
< num_pages
; i
++)
1011 bank
->sectors
[i
].offset
= i
* page_size
;
1012 bank
->sectors
[i
].size
= page_size
;
1013 bank
->sectors
[i
].is_erased
= -1;
1014 bank
->sectors
[i
].is_protected
= 1;
1017 stm32x_info
->probed
= 1;
1022 static int stm32x_auto_probe(struct flash_bank
*bank
)
1024 struct stm32x_flash_bank
*stm32x_info
= bank
->driver_priv
;
1025 if (stm32x_info
->probed
)
1027 return stm32x_probe(bank
);
1031 COMMAND_HANDLER(stm32x_handle_part_id_command
)
1037 static int get_stm32x_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
1039 struct target
*target
= bank
->target
;
1043 /* read stm32 device id register */
1044 int retval
= target_read_u32(target
, 0xE0042000, &device_id
);
1045 if (retval
!= ERROR_OK
)
1048 if ((device_id
& 0x7ff) == 0x410)
1050 printed
= snprintf(buf
, buf_size
, "stm32x (Medium Density) - Rev: ");
1052 buf_size
-= printed
;
1054 switch (device_id
>> 16)
1057 snprintf(buf
, buf_size
, "A");
1061 snprintf(buf
, buf_size
, "B");
1065 snprintf(buf
, buf_size
, "Z");
1069 snprintf(buf
, buf_size
, "Y");
1073 snprintf(buf
, buf_size
, "unknown");
1077 else if ((device_id
& 0x7ff) == 0x412)
1079 printed
= snprintf(buf
, buf_size
, "stm32x (Low Density) - Rev: ");
1081 buf_size
-= printed
;
1083 switch (device_id
>> 16)
1086 snprintf(buf
, buf_size
, "A");
1090 snprintf(buf
, buf_size
, "unknown");
1094 else if ((device_id
& 0x7ff) == 0x414)
1096 printed
= snprintf(buf
, buf_size
, "stm32x (High Density) - Rev: ");
1098 buf_size
-= printed
;
1100 switch (device_id
>> 16)
1103 snprintf(buf
, buf_size
, "A");
1107 snprintf(buf
, buf_size
, "Z");
1111 snprintf(buf
, buf_size
, "unknown");
1115 else if ((device_id
& 0x7ff) == 0x418)
1117 printed
= snprintf(buf
, buf_size
, "stm32x (Connectivity) - Rev: ");
1119 buf_size
-= printed
;
1121 switch (device_id
>> 16)
1124 snprintf(buf
, buf_size
, "A");
1128 snprintf(buf
, buf_size
, "Z");
1132 snprintf(buf
, buf_size
, "unknown");
1136 else if ((device_id
& 0x7ff) == 0x420)
1138 printed
= snprintf(buf
, buf_size
, "stm32x (Value) - Rev: ");
1140 buf_size
-= printed
;
1142 switch (device_id
>> 16)
1145 snprintf(buf
, buf_size
, "A");
1149 snprintf(buf
, buf_size
, "Z");
1153 snprintf(buf
, buf_size
, "unknown");
1157 else if ((device_id
& 0x7ff) == 0x428)
1159 printed
= snprintf(buf
, buf_size
, "stm32x (Value HD) - Rev: ");
1161 buf_size
-= printed
;
1163 switch (device_id
>> 16)
1166 snprintf(buf
, buf_size
, "A");
1170 snprintf(buf
, buf_size
, "Z");
1174 snprintf(buf
, buf_size
, "unknown");
1178 else if ((device_id
& 0x7ff) == 0x430)
1180 printed
= snprintf(buf
, buf_size
, "stm32x (XL) - Rev: ");
1182 buf_size
-= printed
;
1184 switch (device_id
>> 16)
1187 snprintf(buf
, buf_size
, "A");
1191 snprintf(buf
, buf_size
, "unknown");
1197 snprintf(buf
, buf_size
, "Cannot identify target as a stm32x\n");
1204 COMMAND_HANDLER(stm32x_handle_lock_command
)
1206 struct target
*target
= NULL
;
1207 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1211 command_print(CMD_CTX
, "stm32x lock <bank>");
1215 struct flash_bank
*bank
;
1216 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1217 if (ERROR_OK
!= retval
)
1220 stm32x_info
= bank
->driver_priv
;
1222 target
= bank
->target
;
1224 if (target
->state
!= TARGET_HALTED
)
1226 LOG_ERROR("Target not halted");
1227 return ERROR_TARGET_NOT_HALTED
;
1230 retval
= stm32x_check_operation_supported(bank
);
1231 if (ERROR_OK
!= retval
)
1234 if (stm32x_erase_options(bank
) != ERROR_OK
)
1236 command_print(CMD_CTX
, "stm32x failed to erase options");
1240 /* set readout protection */
1241 stm32x_info
->option_bytes
.RDP
= 0;
1243 if (stm32x_write_options(bank
) != ERROR_OK
)
1245 command_print(CMD_CTX
, "stm32x failed to lock device");
1249 command_print(CMD_CTX
, "stm32x locked");
1254 COMMAND_HANDLER(stm32x_handle_unlock_command
)
1256 struct target
*target
= NULL
;
1260 command_print(CMD_CTX
, "stm32x unlock <bank>");
1264 struct flash_bank
*bank
;
1265 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1266 if (ERROR_OK
!= retval
)
1269 target
= bank
->target
;
1271 if (target
->state
!= TARGET_HALTED
)
1273 LOG_ERROR("Target not halted");
1274 return ERROR_TARGET_NOT_HALTED
;
1277 retval
= stm32x_check_operation_supported(bank
);
1278 if (ERROR_OK
!= retval
)
1281 if (stm32x_erase_options(bank
) != ERROR_OK
)
1283 command_print(CMD_CTX
, "stm32x failed to unlock device");
1287 if (stm32x_write_options(bank
) != ERROR_OK
)
1289 command_print(CMD_CTX
, "stm32x failed to lock device");
1293 command_print(CMD_CTX
, "stm32x unlocked.\n"
1294 "INFO: a reset or power cycle is required "
1295 "for the new settings to take effect.");
1300 COMMAND_HANDLER(stm32x_handle_options_read_command
)
1302 uint32_t optionbyte
;
1303 struct target
*target
= NULL
;
1304 struct stm32x_flash_bank
*stm32x_info
= NULL
;
1308 command_print(CMD_CTX
, "stm32x options_read <bank>");
1312 struct flash_bank
*bank
;
1313 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1314 if (ERROR_OK
!= retval
)
1317 stm32x_info
= bank
->driver_priv
;
1319 target
= bank
->target
;
1321 if (target
->state
!= TARGET_HALTED
)
1323 LOG_ERROR("Target not halted");
1324 return ERROR_TARGET_NOT_HALTED
;
1327 retval
= stm32x_check_operation_supported(bank
);
1328 if (ERROR_OK
!= retval
)
1331 retval
= target_read_u32(target
, STM32_FLASH_OBR
, &optionbyte
);
1332 if (retval
!= ERROR_OK
)
1334 command_print(CMD_CTX
, "Option Byte: 0x%" PRIx32
"", optionbyte
);
1336 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_ERROR
, 1))
1337 command_print(CMD_CTX
, "Option Byte Complement Error");
1339 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_READOUT
, 1))
1340 command_print(CMD_CTX
, "Readout Protection On");
1342 command_print(CMD_CTX
, "Readout Protection Off");
1344 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDWDGSW
, 1))
1345 command_print(CMD_CTX
, "Software Watchdog");
1347 command_print(CMD_CTX
, "Hardware Watchdog");
1349 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDRSTSTOP
, 1))
1350 command_print(CMD_CTX
, "Stop: No reset generated");
1352 command_print(CMD_CTX
, "Stop: Reset generated");
1354 if (buf_get_u32((uint8_t*)&optionbyte
, OPT_RDRSTSTDBY
, 1))
1355 command_print(CMD_CTX
, "Standby: No reset generated");
1357 command_print(CMD_CTX
, "Standby: Reset generated");
1359 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;
1378 command_print(CMD_CTX
, "stm32x options_write <bank> <SWWDG | HWWDG> "
1379 "<RSTSTNDBY | NORSTSTNDBY> <RSTSTOP | NORSTSTOP> <BOOT0 | BOOT1>");
1383 struct flash_bank
*bank
;
1384 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1385 if (ERROR_OK
!= retval
)
1388 stm32x_info
= bank
->driver_priv
;
1390 target
= bank
->target
;
1392 if (target
->state
!= TARGET_HALTED
)
1394 LOG_ERROR("Target not halted");
1395 return ERROR_TARGET_NOT_HALTED
;
1398 retval
= stm32x_check_operation_supported(bank
);
1399 if (ERROR_OK
!= retval
)
1402 /* REVISIT: ignores some options which we will display...
1403 * and doesn't insist on the specified syntax.
1407 if (strcmp(CMD_ARGV
[1], "SWWDG") == 0)
1409 optionbyte
|= (1 << 0);
1411 else /* REVISIT must be "HWWDG" then ... */
1413 optionbyte
&= ~(1 << 0);
1417 if (strcmp(CMD_ARGV
[2], "NORSTSTOP") == 0)
1419 optionbyte
|= (1 << 1);
1421 else /* REVISIT must be "RSTSTNDBY" then ... */
1423 optionbyte
&= ~(1 << 1);
1426 /* OPT_RDRSTSTDBY */
1427 if (strcmp(CMD_ARGV
[3], "NORSTSTNDBY") == 0)
1429 optionbyte
|= (1 << 2);
1431 else /* REVISIT must be "RSTSTOP" then ... */
1433 optionbyte
&= ~(1 << 2);
1436 if (CMD_ARGC
> 4 && stm32x_info
->has_dual_banks
)
1439 if (strcmp(CMD_ARGV
[4], "BOOT0") == 0)
1441 optionbyte
|= (1 << 3);
1445 optionbyte
&= ~(1 << 3);
1449 if (stm32x_erase_options(bank
) != ERROR_OK
)
1451 command_print(CMD_CTX
, "stm32x failed to erase options");
1455 stm32x_info
->option_bytes
.user_options
= optionbyte
;
1457 if (stm32x_write_options(bank
) != ERROR_OK
)
1459 command_print(CMD_CTX
, "stm32x failed to write options");
1463 command_print(CMD_CTX
, "stm32x write options complete.\n"
1464 "INFO: a reset or power cycle is required "
1465 "for the new settings to take effect.");
1470 static int stm32x_mass_erase(struct flash_bank
*bank
)
1472 struct target
*target
= bank
->target
;
1474 if (target
->state
!= TARGET_HALTED
)
1476 LOG_ERROR("Target not halted");
1477 return ERROR_TARGET_NOT_HALTED
;
1480 /* unlock option flash registers */
1481 int retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY1
);
1482 if (retval
!= ERROR_OK
)
1484 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_KEYR
), KEY2
);
1485 if (retval
!= ERROR_OK
)
1488 /* mass erase flash memory */
1489 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_MER
);
1490 if (retval
!= ERROR_OK
)
1492 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_MER
| FLASH_STRT
);
1493 if (retval
!= ERROR_OK
)
1496 retval
= stm32x_wait_status_busy(bank
, 100);
1497 if (retval
!= ERROR_OK
)
1500 retval
= target_write_u32(target
, stm32x_get_flash_reg(bank
, STM32_FLASH_CR
), FLASH_LOCK
);
1501 if (retval
!= ERROR_OK
)
1507 COMMAND_HANDLER(stm32x_handle_mass_erase_command
)
1513 command_print(CMD_CTX
, "stm32x mass_erase <bank>");
1517 struct flash_bank
*bank
;
1518 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &bank
);
1519 if (ERROR_OK
!= retval
)
1522 retval
= stm32x_mass_erase(bank
);
1523 if (retval
== ERROR_OK
)
1525 /* set all sectors as erased */
1526 for (i
= 0; i
< bank
->num_sectors
; i
++)
1528 bank
->sectors
[i
].is_erased
= 1;
1531 command_print(CMD_CTX
, "stm32x mass erase complete");
1535 command_print(CMD_CTX
, "stm32x mass erase failed");
1541 static const struct command_registration stm32x_exec_command_handlers
[] = {
1544 .handler
= stm32x_handle_lock_command
,
1545 .mode
= COMMAND_EXEC
,
1547 .help
= "Lock entire flash device.",
1551 .handler
= stm32x_handle_unlock_command
,
1552 .mode
= COMMAND_EXEC
,
1554 .help
= "Unlock entire protected flash device.",
1557 .name
= "mass_erase",
1558 .handler
= stm32x_handle_mass_erase_command
,
1559 .mode
= COMMAND_EXEC
,
1561 .help
= "Erase entire flash device.",
1564 .name
= "options_read",
1565 .handler
= stm32x_handle_options_read_command
,
1566 .mode
= COMMAND_EXEC
,
1568 .help
= "Read and display device option byte.",
1571 .name
= "options_write",
1572 .handler
= stm32x_handle_options_write_command
,
1573 .mode
= COMMAND_EXEC
,
1574 .usage
= "bank_id ('SWWDG'|'HWWDG') "
1575 "('RSTSTNDBY'|'NORSTSTNDBY') "
1576 "('RSTSTOP'|'NORSTSTOP')",
1577 .help
= "Replace bits in device option byte.",
1579 COMMAND_REGISTRATION_DONE
1582 static const struct command_registration stm32x_command_handlers
[] = {
1585 .mode
= COMMAND_ANY
,
1586 .help
= "stm32f1x flash command group",
1587 .chain
= stm32x_exec_command_handlers
,
1589 COMMAND_REGISTRATION_DONE
1592 struct flash_driver stm32f1x_flash
= {
1594 .commands
= stm32x_command_handlers
,
1595 .flash_bank_command
= stm32x_flash_bank_command
,
1596 .erase
= stm32x_erase
,
1597 .protect
= stm32x_protect
,
1598 .write
= stm32x_write
,
1599 .read
= default_flash_read
,
1600 .probe
= stm32x_probe
,
1601 .auto_probe
= stm32x_auto_probe
,
1602 .erase_check
= default_flash_mem_blank_check
,
1603 .protect_check
= stm32x_protect_check
,
1604 .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)