1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2013 by Paul Fertser, fercerpav@gmail.com *
6 * Copyright (C) 2012 by Creative Product Design, marc @ cpdesign.com.au *
7 * Based on at91rm9200.c (c) Anders Larsen *
8 * and RPi GPIO examples by Gert van Loo & Dom *
9 ***************************************************************************/
15 #include <jtag/adapter.h>
16 #include <jtag/interface.h>
17 #include <transport/transport.h>
22 uint32_t bcm2835_peri_base
= 0x20000000;
23 #define BCM2835_GPIO_BASE (bcm2835_peri_base + 0x200000) /* GPIO controller */
25 #define BCM2835_PADS_GPIO_0_27 (bcm2835_peri_base + 0x100000)
26 #define BCM2835_PADS_GPIO_0_27_OFFSET (0x2c / 4)
28 /* See "GPIO Function Select Registers (GPFSELn)" in "Broadcom BCM2835 ARM Peripherals" datasheet. */
29 #define BCM2835_GPIO_MODE_INPUT 0
30 #define BCM2835_GPIO_MODE_OUTPUT 1
32 /* GPIO setup macros */
33 #define MODE_GPIO(g) (*(pio_base+((g)/10))>>(((g)%10)*3) & 7)
34 #define INP_GPIO(g) do { *(pio_base+((g)/10)) &= ~(7<<(((g)%10)*3)); } while (0)
35 #define SET_MODE_GPIO(g, m) do { /* clear the mode bits first, then set as necessary */ \
37 *(pio_base+((g)/10)) |= ((m)<<(((g)%10)*3)); } while (0)
38 #define OUT_GPIO(g) SET_MODE_GPIO(g, BCM2835_GPIO_MODE_OUTPUT)
40 #define GPIO_SET (*(pio_base+7)) /* sets bits which are 1, ignores bits which are 0 */
41 #define GPIO_CLR (*(pio_base+10)) /* clears bits which are 1, ignores bits which are 0 */
42 #define GPIO_LEV (*(pio_base+13)) /* current level of the pin */
44 static int dev_mem_fd
;
45 static volatile uint32_t *pio_base
= MAP_FAILED
;
46 static volatile uint32_t *pads_base
= MAP_FAILED
;
48 /* Transition delay coefficients */
49 static int speed_coeff
= 113714;
50 static int speed_offset
= 28;
51 static unsigned int jtag_delay
;
53 static const struct adapter_gpio_config
*adapter_gpio_config
;
54 static struct initial_gpio_state
{
56 unsigned int output_level
;
57 } initial_gpio_state
[ADAPTER_GPIO_IDX_NUM
];
58 static uint32_t initial_drive_strength_etc
;
60 static inline void bcm2835_gpio_synchronize(void)
62 /* Ensure that previous writes to GPIO registers are flushed out of
63 * the inner shareable domain to prevent pipelined writes to the
64 * same address being merged.
69 static bool is_gpio_config_valid(enum adapter_gpio_config_index idx
)
71 /* Only chip 0 is supported, accept unset value (-1) too */
72 return adapter_gpio_config
[idx
].chip_num
>= -1
73 && adapter_gpio_config
[idx
].chip_num
<= 0
74 && adapter_gpio_config
[idx
].gpio_num
>= 0
75 && adapter_gpio_config
[idx
].gpio_num
<= 31;
78 static void set_gpio_value(const struct adapter_gpio_config
*gpio_config
, int value
)
80 value
= value
^ (gpio_config
->active_low
? 1 : 0);
81 switch (gpio_config
->drive
) {
82 case ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL
:
84 GPIO_SET
= 1 << gpio_config
->gpio_num
;
86 GPIO_CLR
= 1 << gpio_config
->gpio_num
;
87 /* For performance reasons assume the GPIO is already set as an output
88 * and therefore the call can be omitted here.
91 case ADAPTER_GPIO_DRIVE_MODE_OPEN_DRAIN
:
93 INP_GPIO(gpio_config
->gpio_num
);
95 GPIO_CLR
= 1 << gpio_config
->gpio_num
;
96 OUT_GPIO(gpio_config
->gpio_num
);
99 case ADAPTER_GPIO_DRIVE_MODE_OPEN_SOURCE
:
101 GPIO_SET
= 1 << gpio_config
->gpio_num
;
102 OUT_GPIO(gpio_config
->gpio_num
);
104 INP_GPIO(gpio_config
->gpio_num
);
108 bcm2835_gpio_synchronize();
111 static void restore_gpio(enum adapter_gpio_config_index idx
)
113 if (is_gpio_config_valid(idx
)) {
114 SET_MODE_GPIO(adapter_gpio_config
[idx
].gpio_num
, initial_gpio_state
[idx
].mode
);
115 if (initial_gpio_state
[idx
].mode
== BCM2835_GPIO_MODE_OUTPUT
) {
116 if (initial_gpio_state
[idx
].output_level
)
117 GPIO_SET
= 1 << adapter_gpio_config
[idx
].gpio_num
;
119 GPIO_CLR
= 1 << adapter_gpio_config
[idx
].gpio_num
;
122 bcm2835_gpio_synchronize();
125 static void initialize_gpio(enum adapter_gpio_config_index idx
)
127 if (!is_gpio_config_valid(idx
))
130 initial_gpio_state
[idx
].mode
= MODE_GPIO(adapter_gpio_config
[idx
].gpio_num
);
131 unsigned int shift
= adapter_gpio_config
[idx
].gpio_num
;
132 initial_gpio_state
[idx
].output_level
= (GPIO_LEV
>> shift
) & 1;
133 LOG_DEBUG("saved GPIO mode for %s (GPIO %d %d): %d",
134 adapter_gpio_get_name(idx
), adapter_gpio_config
[idx
].chip_num
, adapter_gpio_config
[idx
].gpio_num
,
135 initial_gpio_state
[idx
].mode
);
137 if (adapter_gpio_config
[idx
].pull
!= ADAPTER_GPIO_PULL_NONE
) {
138 LOG_WARNING("BCM2835 GPIO does not support pull-up or pull-down settings (signal %s)",
139 adapter_gpio_get_name(idx
));
142 switch (adapter_gpio_config
[idx
].init_state
) {
143 case ADAPTER_GPIO_INIT_STATE_INACTIVE
:
144 set_gpio_value(&adapter_gpio_config
[idx
], 0);
146 case ADAPTER_GPIO_INIT_STATE_ACTIVE
:
147 set_gpio_value(&adapter_gpio_config
[idx
], 1);
149 case ADAPTER_GPIO_INIT_STATE_INPUT
:
150 INP_GPIO(adapter_gpio_config
[idx
].gpio_num
);
154 /* Direction for non push-pull is already set by set_gpio_value() */
155 if (adapter_gpio_config
[idx
].drive
== ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL
)
156 OUT_GPIO(adapter_gpio_config
[idx
].gpio_num
);
157 bcm2835_gpio_synchronize();
160 static bb_value_t
bcm2835gpio_read(void)
162 unsigned int shift
= adapter_gpio_config
[ADAPTER_GPIO_IDX_TDO
].gpio_num
;
163 uint32_t value
= (GPIO_LEV
>> shift
) & 1;
164 return value
^ (adapter_gpio_config
[ADAPTER_GPIO_IDX_TDO
].active_low
? BB_HIGH
: BB_LOW
);
168 static int bcm2835gpio_write(int tck
, int tms
, int tdi
)
170 uint32_t set
= tck
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TCK
].gpio_num
|
171 tms
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TMS
].gpio_num
|
172 tdi
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TDI
].gpio_num
;
173 uint32_t clear
= !tck
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TCK
].gpio_num
|
174 !tms
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TMS
].gpio_num
|
175 !tdi
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_TDI
].gpio_num
;
179 bcm2835_gpio_synchronize();
181 for (unsigned int i
= 0; i
< jtag_delay
; i
++)
187 /* Requires push-pull drive mode for swclk and swdio */
188 static int bcm2835gpio_swd_write_fast(int swclk
, int swdio
)
190 swclk
= swclk
^ (adapter_gpio_config
[ADAPTER_GPIO_IDX_SWCLK
].active_low
? 1 : 0);
191 swdio
= swdio
^ (adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].active_low
? 1 : 0);
193 uint32_t set
= swclk
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_SWCLK
].gpio_num
|
194 swdio
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
;
195 uint32_t clear
= !swclk
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_SWCLK
].gpio_num
|
196 !swdio
<< adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
;
200 bcm2835_gpio_synchronize();
202 for (unsigned int i
= 0; i
< jtag_delay
; i
++)
208 /* Generic mode that works for open-drain/open-source drive modes, but slower */
209 static int bcm2835gpio_swd_write_generic(int swclk
, int swdio
)
211 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
], swdio
);
212 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_SWCLK
], swclk
); /* Write clock last */
214 for (unsigned int i
= 0; i
< jtag_delay
; ++i
)
220 /* (1) assert or (0) deassert reset lines */
221 static int bcm2835gpio_reset(int trst
, int srst
)
223 /* As the "adapter reset_config" command keeps the srst and trst gpio drive
224 * mode settings in sync we can use our standard set_gpio_value() function
225 * that honours drive mode and active low.
227 if (is_gpio_config_valid(ADAPTER_GPIO_IDX_SRST
))
228 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_SRST
], srst
);
230 if (is_gpio_config_valid(ADAPTER_GPIO_IDX_TRST
))
231 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_TRST
], trst
);
233 LOG_DEBUG("BCM2835 GPIO: bcm2835gpio_reset(%d, %d), trst_gpio: %d %d, srst_gpio: %d %d",
235 adapter_gpio_config
[ADAPTER_GPIO_IDX_TRST
].chip_num
, adapter_gpio_config
[ADAPTER_GPIO_IDX_TRST
].gpio_num
,
236 adapter_gpio_config
[ADAPTER_GPIO_IDX_SRST
].chip_num
, adapter_gpio_config
[ADAPTER_GPIO_IDX_SRST
].gpio_num
);
240 static void bcm2835_swdio_drive(bool is_output
)
243 if (is_gpio_config_valid(ADAPTER_GPIO_IDX_SWDIO_DIR
))
244 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO_DIR
], 1);
245 OUT_GPIO(adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
);
247 INP_GPIO(adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
);
248 if (is_gpio_config_valid(ADAPTER_GPIO_IDX_SWDIO_DIR
))
249 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO_DIR
], 0);
251 bcm2835_gpio_synchronize();
254 static int bcm2835_swdio_read(void)
256 unsigned int shift
= adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
;
257 uint32_t value
= (GPIO_LEV
>> shift
) & 1;
258 return value
^ (adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].active_low
? 1 : 0);
261 static int bcm2835gpio_khz(int khz
, int *jtag_speed
)
264 LOG_DEBUG("BCM2835 GPIO: RCLK not supported");
267 *jtag_speed
= DIV_ROUND_UP(speed_coeff
, khz
) - speed_offset
;
268 LOG_DEBUG("jtag_delay %d", *jtag_speed
);
274 static int bcm2835gpio_speed_div(int speed
, int *khz
)
276 int divisor
= speed
+ speed_offset
;
277 /* divide with roundig to the closest */
278 *khz
= (speed_coeff
+ divisor
/ 2) / divisor
;
282 static int bcm2835gpio_speed(int speed
)
288 COMMAND_HANDLER(bcm2835gpio_handle_speed_coeffs
)
291 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], speed_coeff
);
292 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], speed_offset
);
295 command_print(CMD
, "BCM2835 GPIO: speed_coeffs = %d, speed_offset = %d",
296 speed_coeff
, speed_offset
);
300 COMMAND_HANDLER(bcm2835gpio_handle_peripheral_base
)
303 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], bcm2835_peri_base
);
305 command_print(CMD
, "BCM2835 GPIO: peripheral_base = 0x%08x",
310 static const struct command_registration bcm2835gpio_subcommand_handlers
[] = {
312 .name
= "speed_coeffs",
313 .handler
= &bcm2835gpio_handle_speed_coeffs
,
314 .mode
= COMMAND_CONFIG
,
315 .help
= "SPEED_COEFF and SPEED_OFFSET for delay calculations.",
316 .usage
= "[SPEED_COEFF SPEED_OFFSET]",
319 .name
= "peripheral_base",
320 .handler
= &bcm2835gpio_handle_peripheral_base
,
321 .mode
= COMMAND_CONFIG
,
322 .help
= "peripheral base to access GPIOs (RPi1 0x20000000, RPi2 0x3F000000).",
326 COMMAND_REGISTRATION_DONE
329 static const struct command_registration bcm2835gpio_command_handlers
[] = {
331 .name
= "bcm2835gpio",
333 .help
= "perform bcm2835gpio management",
334 .chain
= bcm2835gpio_subcommand_handlers
,
337 COMMAND_REGISTRATION_DONE
340 static bool bcm2835gpio_jtag_mode_possible(void)
342 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_TCK
))
344 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_TMS
))
346 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_TDI
))
348 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_TDO
))
353 static bool bcm2835gpio_swd_mode_possible(void)
355 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_SWCLK
))
357 if (!is_gpio_config_valid(ADAPTER_GPIO_IDX_SWDIO
))
362 static void bcm2835gpio_munmap(void)
364 if (pio_base
!= MAP_FAILED
) {
365 munmap((void *)pio_base
, sysconf(_SC_PAGE_SIZE
));
366 pio_base
= MAP_FAILED
;
369 if (pads_base
!= MAP_FAILED
) {
370 munmap((void *)pads_base
, sysconf(_SC_PAGE_SIZE
));
371 pads_base
= MAP_FAILED
;
375 static int bcm2835gpio_blink(int on
)
377 if (is_gpio_config_valid(ADAPTER_GPIO_IDX_LED
))
378 set_gpio_value(&adapter_gpio_config
[ADAPTER_GPIO_IDX_LED
], on
);
383 static struct bitbang_interface bcm2835gpio_bitbang
= {
384 .read
= bcm2835gpio_read
,
385 .write
= bcm2835gpio_write
,
386 .swdio_read
= bcm2835_swdio_read
,
387 .swdio_drive
= bcm2835_swdio_drive
,
388 .swd_write
= bcm2835gpio_swd_write_generic
,
389 .blink
= bcm2835gpio_blink
,
392 static int bcm2835gpio_init(void)
394 LOG_INFO("BCM2835 GPIO JTAG/SWD bitbang driver");
396 bitbang_interface
= &bcm2835gpio_bitbang
;
397 adapter_gpio_config
= adapter_gpio_get_config();
399 if (transport_is_jtag() && !bcm2835gpio_jtag_mode_possible()) {
400 LOG_ERROR("Require tck, tms, tdi and tdo gpios for JTAG mode");
401 return ERROR_JTAG_INIT_FAILED
;
404 if (transport_is_swd() && !bcm2835gpio_swd_mode_possible()) {
405 LOG_ERROR("Require swclk and swdio gpio for SWD mode");
406 return ERROR_JTAG_INIT_FAILED
;
409 dev_mem_fd
= open("/dev/gpiomem", O_RDWR
| O_SYNC
);
410 if (dev_mem_fd
< 0) {
411 LOG_DEBUG("Cannot open /dev/gpiomem, fallback to /dev/mem");
412 dev_mem_fd
= open("/dev/mem", O_RDWR
| O_SYNC
);
414 if (dev_mem_fd
< 0) {
415 LOG_ERROR("open: %s", strerror(errno
));
416 return ERROR_JTAG_INIT_FAILED
;
419 pio_base
= mmap(NULL
, sysconf(_SC_PAGE_SIZE
), PROT_READ
| PROT_WRITE
,
420 MAP_SHARED
, dev_mem_fd
, BCM2835_GPIO_BASE
);
422 if (pio_base
== MAP_FAILED
) {
423 LOG_ERROR("mmap: %s", strerror(errno
));
425 return ERROR_JTAG_INIT_FAILED
;
428 pads_base
= mmap(NULL
, sysconf(_SC_PAGE_SIZE
), PROT_READ
| PROT_WRITE
,
429 MAP_SHARED
, dev_mem_fd
, BCM2835_PADS_GPIO_0_27
);
431 if (pads_base
== MAP_FAILED
) {
432 LOG_ERROR("mmap: %s", strerror(errno
));
433 bcm2835gpio_munmap();
435 return ERROR_JTAG_INIT_FAILED
;
440 /* set 4mA drive strength, slew rate limited, hysteresis on */
441 initial_drive_strength_etc
= pads_base
[BCM2835_PADS_GPIO_0_27_OFFSET
] & 0x1f;
442 pads_base
[BCM2835_PADS_GPIO_0_27_OFFSET
] = 0x5a000008 + 1;
444 /* Configure JTAG/SWD signals. Default directions and initial states are handled
445 * by adapter.c and "adapter gpio" command.
447 if (transport_is_jtag()) {
448 initialize_gpio(ADAPTER_GPIO_IDX_TDO
);
449 initialize_gpio(ADAPTER_GPIO_IDX_TDI
);
450 initialize_gpio(ADAPTER_GPIO_IDX_TMS
);
451 initialize_gpio(ADAPTER_GPIO_IDX_TCK
);
452 initialize_gpio(ADAPTER_GPIO_IDX_TRST
);
455 if (transport_is_swd()) {
456 /* swdio and its buffer should be initialized in the order that prevents
457 * two outputs from being connected together. This will occur if the
458 * swdio GPIO of the AM335x is configured as an output while its
459 * external buffer is configured to send the swdio signal from the
460 * target to the AM335x.
462 if (adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].init_state
== ADAPTER_GPIO_INIT_STATE_INPUT
) {
463 initialize_gpio(ADAPTER_GPIO_IDX_SWDIO
);
464 initialize_gpio(ADAPTER_GPIO_IDX_SWDIO_DIR
);
466 initialize_gpio(ADAPTER_GPIO_IDX_SWDIO_DIR
);
467 initialize_gpio(ADAPTER_GPIO_IDX_SWDIO
);
470 initialize_gpio(ADAPTER_GPIO_IDX_SWCLK
);
472 if (adapter_gpio_config
[ADAPTER_GPIO_IDX_SWCLK
].drive
== ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL
&&
473 adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].drive
== ADAPTER_GPIO_DRIVE_MODE_PUSH_PULL
) {
474 LOG_DEBUG("BCM2835 GPIO using fast mode for SWD write");
475 bcm2835gpio_bitbang
.swd_write
= bcm2835gpio_swd_write_fast
;
477 LOG_DEBUG("BCM2835 GPIO using generic mode for SWD write");
478 bcm2835gpio_bitbang
.swd_write
= bcm2835gpio_swd_write_generic
;
482 initialize_gpio(ADAPTER_GPIO_IDX_SRST
);
483 initialize_gpio(ADAPTER_GPIO_IDX_LED
);
488 static int bcm2835gpio_quit(void)
490 if (transport_is_jtag()) {
491 restore_gpio(ADAPTER_GPIO_IDX_TDO
);
492 restore_gpio(ADAPTER_GPIO_IDX_TDI
);
493 restore_gpio(ADAPTER_GPIO_IDX_TCK
);
494 restore_gpio(ADAPTER_GPIO_IDX_TMS
);
495 restore_gpio(ADAPTER_GPIO_IDX_TRST
);
498 if (transport_is_swd()) {
499 /* Restore swdio/swdio_dir to their initial modes, even if that means
500 * connecting two outputs. Begin by making swdio an input so that the
501 * current and final states of swdio and swdio_dir do not have to be
502 * considered to calculate the safe restoration order.
504 INP_GPIO(adapter_gpio_config
[ADAPTER_GPIO_IDX_SWDIO
].gpio_num
);
505 restore_gpio(ADAPTER_GPIO_IDX_SWDIO_DIR
);
506 restore_gpio(ADAPTER_GPIO_IDX_SWDIO
);
507 restore_gpio(ADAPTER_GPIO_IDX_SWCLK
);
510 restore_gpio(ADAPTER_GPIO_IDX_SRST
);
511 restore_gpio(ADAPTER_GPIO_IDX_LED
);
513 /* Restore drive strength. MSB is password ("5A") */
514 pads_base
[BCM2835_PADS_GPIO_0_27_OFFSET
] = 0x5A000000 | initial_drive_strength_etc
;
515 bcm2835gpio_munmap();
521 static const char * const bcm2835_transports
[] = { "jtag", "swd", NULL
};
523 static struct jtag_interface bcm2835gpio_interface
= {
524 .supported
= DEBUG_CAP_TMS_SEQ
,
525 .execute_queue
= bitbang_execute_queue
,
527 struct adapter_driver bcm2835gpio_adapter_driver
= {
528 .name
= "bcm2835gpio",
529 .transports
= bcm2835_transports
,
530 .commands
= bcm2835gpio_command_handlers
,
532 .init
= bcm2835gpio_init
,
533 .quit
= bcm2835gpio_quit
,
534 .reset
= bcm2835gpio_reset
,
535 .speed
= bcm2835gpio_speed
,
536 .khz
= bcm2835gpio_khz
,
537 .speed_div
= bcm2835gpio_speed_div
,
539 .jtag_ops
= &bcm2835gpio_interface
,
540 .swd_ops
= &bitbang_swd
,
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)