target: Remove read_memory_imp
[openocd.git] / src / target / target.h
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * Copyright (C) 2011 by Broadcom Corporation *
12 * Evan Hunter - ehunter@broadcom.com *
13 * *
14 * Copyright (C) ST-Ericsson SA 2011 *
15 * michel.jaouen@stericsson.com : smp minimum support *
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
26 * *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program; if not, write to the *
29 * Free Software Foundation, Inc., *
30 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
31 ***************************************************************************/
32
33 #ifndef TARGET_H
34 #define TARGET_H
35
36 struct reg;
37 struct trace;
38 struct command_context;
39 struct breakpoint;
40 struct watchpoint;
41 struct mem_param;
42 struct reg_param;
43 struct target_list;
44
45 /*
46 * TARGET_UNKNOWN = 0: we don't know anything about the target yet
47 * TARGET_RUNNING = 1: the target is executing user code
48 * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
49 * debugger. on an xscale it means that the debug handler is executing
50 * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
51 * not sure how this is used with all the recent changes)
52 * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
53 * behalf of the debugger (e.g. algorithm for flashing)
54 *
55 * also see: target_state_name();
56 */
57
58 enum target_state {
59 TARGET_UNKNOWN = 0,
60 TARGET_RUNNING = 1,
61 TARGET_HALTED = 2,
62 TARGET_RESET = 3,
63 TARGET_DEBUG_RUNNING = 4,
64 };
65
66 enum nvp_assert {
67 NVP_DEASSERT,
68 NVP_ASSERT,
69 };
70
71 enum target_reset_mode {
72 RESET_UNKNOWN = 0,
73 RESET_RUN = 1, /* reset and let target run */
74 RESET_HALT = 2, /* reset and halt target out of reset */
75 RESET_INIT = 3, /* reset and halt target out of reset, then run init script */
76 };
77
78 enum target_debug_reason {
79 DBG_REASON_DBGRQ = 0,
80 DBG_REASON_BREAKPOINT = 1,
81 DBG_REASON_WATCHPOINT = 2,
82 DBG_REASON_WPTANDBKPT = 3,
83 DBG_REASON_SINGLESTEP = 4,
84 DBG_REASON_NOTHALTED = 5,
85 DBG_REASON_UNDEFINED = 6
86 };
87
88 enum target_endianness {
89 TARGET_ENDIAN_UNKNOWN = 0,
90 TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
91 };
92
93 struct working_area {
94 uint32_t address;
95 uint32_t size;
96 bool free;
97 uint8_t *backup;
98 struct working_area **user;
99 struct working_area *next;
100 };
101
102 struct gdb_service {
103 struct target *target;
104 /* field for smp display */
105 /* element 0 coreid currently displayed ( 1 till n) */
106 /* element 1 coreid to be displayed at next resume 1 till n 0 means resume
107 * all cores core displayed */
108 int32_t core[2];
109 };
110
111 /* target back off timer */
112 struct backoff_timer {
113 int times;
114 int count;
115 };
116
117 /* target_type.h contains the full definition of struct target_type */
118 struct target {
119 struct target_type *type; /* target type definition (name, access functions) */
120 const char *cmd_name; /* tcl Name of target */
121 int target_number; /* DO NOT USE! field to be removed in 2010 */
122 struct jtag_tap *tap; /* where on the jtag chain is this */
123 int32_t coreid; /* which device on the TAP? */
124 const char *variant; /* what variant of this chip is it? */
125
126 /**
127 * Indicates whether this target has been examined.
128 *
129 * Do @b not access this field directly, use target_was_examined()
130 * or target_set_examined().
131 */
132 bool examined;
133
134 /**
135 * true if the target is currently running a downloaded
136 * "algorithm" instead of arbitrary user code. OpenOCD code
137 * invoking algorithms is trusted to maintain correctness of
138 * any cached state (e.g. for flash status), which arbitrary
139 * code will have no reason to know about.
140 */
141 bool running_alg;
142
143 struct target_event_action *event_action;
144
145 int reset_halt; /* attempt resetting the CPU into the halted mode? */
146 uint32_t working_area; /* working area (initialised RAM). Evaluated
147 * upon first allocation from virtual/physical address. */
148 bool working_area_virt_spec; /* virtual address specified? */
149 uint32_t working_area_virt; /* virtual address */
150 bool working_area_phys_spec; /* virtual address specified? */
151 uint32_t working_area_phys; /* physical address */
152 uint32_t working_area_size; /* size in bytes */
153 uint32_t backup_working_area; /* whether the content of the working area has to be preserved */
154 struct working_area *working_areas;/* list of allocated working areas */
155 enum target_debug_reason debug_reason;/* reason why the target entered debug state */
156 enum target_endianness endianness; /* target endianness */
157 /* also see: target_state_name() */
158 enum target_state state; /* the current backend-state (running, halted, ...) */
159 struct reg_cache *reg_cache; /* the first register cache of the target (core regs) */
160 struct breakpoint *breakpoints; /* list of breakpoints */
161 struct watchpoint *watchpoints; /* list of watchpoints */
162 struct trace *trace_info; /* generic trace information */
163 struct debug_msg_receiver *dbgmsg; /* list of debug message receivers */
164 uint32_t dbg_msg_enabled; /* debug message status */
165 void *arch_info; /* architecture specific information */
166 struct target *next; /* next target in list */
167
168 int display; /* display async info in telnet session. Do not display
169 * lots of halted/resumed info when stepping in debugger. */
170 bool halt_issued; /* did we transition to halted state? */
171 long long halt_issued_time; /* Note time when halt was issued */
172
173 bool dbgbase_set; /* By default the debug base is not set */
174 uint32_t dbgbase; /* Really a Cortex-A specific option, but there is no
175 * system in place to support target specific options
176 * currently. */
177 struct rtos *rtos; /* Instance of Real Time Operating System support */
178 bool rtos_auto_detect; /* A flag that indicates that the RTOS has been specified as "auto"
179 * and must be detected when symbols are offered */
180 struct backoff_timer backoff;
181 int smp; /* add some target attributes for smp support */
182 struct target_list *head;
183 /* the gdb service is there in case of smp, we have only one gdb server
184 * for all smp target
185 * the target attached to the gdb is changing dynamically by changing
186 * gdb_service->target pointer */
187 struct gdb_service *gdb_service;
188 };
189
190 struct target_list {
191 struct target *target;
192 struct target_list *next;
193 };
194
195 /** Returns the instance-specific name of the specified target. */
196 static inline const char *target_name(struct target *target)
197 {
198 return target->cmd_name;
199 }
200
201 const char *debug_reason_name(struct target *t);
202
203 enum target_event {
204
205 /* allow GDB to do stuff before others handle the halted event,
206 * this is in lieu of defining ordering of invocation of events,
207 * which would be more complicated
208 *
209 * Telling GDB to halt does not mean that the target stopped running,
210 * simply that we're dropping out of GDB's waiting for step or continue.
211 *
212 * This can be useful when e.g. detecting power dropout.
213 */
214 TARGET_EVENT_GDB_HALT,
215 TARGET_EVENT_HALTED, /* target entered debug state from normal execution or reset */
216 TARGET_EVENT_RESUMED, /* target resumed to normal execution */
217 TARGET_EVENT_RESUME_START,
218 TARGET_EVENT_RESUME_END,
219
220 TARGET_EVENT_GDB_START, /* debugger started execution (step/run) */
221 TARGET_EVENT_GDB_END, /* debugger stopped execution (step/run) */
222
223 TARGET_EVENT_RESET_START,
224 TARGET_EVENT_RESET_ASSERT_PRE,
225 TARGET_EVENT_RESET_ASSERT, /* C code uses this instead of SRST */
226 TARGET_EVENT_RESET_ASSERT_POST,
227 TARGET_EVENT_RESET_DEASSERT_PRE,
228 TARGET_EVENT_RESET_DEASSERT_POST,
229 TARGET_EVENT_RESET_HALT_PRE,
230 TARGET_EVENT_RESET_HALT_POST,
231 TARGET_EVENT_RESET_WAIT_PRE,
232 TARGET_EVENT_RESET_WAIT_POST,
233 TARGET_EVENT_RESET_INIT,
234 TARGET_EVENT_RESET_END,
235
236 TARGET_EVENT_DEBUG_HALTED, /* target entered debug state, but was executing on behalf of the debugger */
237 TARGET_EVENT_DEBUG_RESUMED, /* target resumed to execute on behalf of the debugger */
238
239 TARGET_EVENT_EXAMINE_START,
240 TARGET_EVENT_EXAMINE_END,
241
242 TARGET_EVENT_GDB_ATTACH,
243 TARGET_EVENT_GDB_DETACH,
244
245 TARGET_EVENT_GDB_FLASH_ERASE_START,
246 TARGET_EVENT_GDB_FLASH_ERASE_END,
247 TARGET_EVENT_GDB_FLASH_WRITE_START,
248 TARGET_EVENT_GDB_FLASH_WRITE_END,
249 };
250
251 struct target_event_action {
252 enum target_event event;
253 struct Jim_Interp *interp;
254 struct Jim_Obj *body;
255 int has_percent;
256 struct target_event_action *next;
257 };
258
259 bool target_has_event_action(struct target *target, enum target_event event);
260
261 struct target_event_callback {
262 int (*callback)(struct target *target, enum target_event event, void *priv);
263 void *priv;
264 struct target_event_callback *next;
265 };
266
267 struct target_timer_callback {
268 int (*callback)(void *priv);
269 int time_ms;
270 int periodic;
271 struct timeval when;
272 void *priv;
273 struct target_timer_callback *next;
274 };
275
276 int target_register_commands(struct command_context *cmd_ctx);
277 int target_examine(void);
278
279 int target_register_event_callback(
280 int (*callback)(struct target *target,
281 enum target_event event, void *priv),
282 void *priv);
283 int target_unregister_event_callback(
284 int (*callback)(struct target *target,
285 enum target_event event, void *priv),
286 void *priv);
287
288 /* Poll the status of the target, detect any error conditions and report them.
289 *
290 * Also note that this fn will clear such error conditions, so a subsequent
291 * invocation will then succeed.
292 *
293 * These error conditions can be "sticky" error conditions. E.g. writing
294 * to memory could be implemented as an open loop and if memory writes
295 * fails, then a note is made of it, the error is sticky, but the memory
296 * write loop still runs to completion. This improves performance in the
297 * normal case as there is no need to verify that every single write succeed,
298 * yet it is possible to detect error conditions.
299 */
300 int target_poll(struct target *target);
301 int target_resume(struct target *target, int current, uint32_t address,
302 int handle_breakpoints, int debug_execution);
303 int target_halt(struct target *target);
304 int target_call_event_callbacks(struct target *target, enum target_event event);
305
306 /**
307 * The period is very approximate, the callback can happen much more often
308 * or much more rarely than specified
309 */
310 int target_register_timer_callback(int (*callback)(void *priv),
311 int time_ms, int periodic, void *priv);
312
313 int target_call_timer_callbacks(void);
314 /**
315 * Invoke this to ensure that e.g. polling timer callbacks happen before
316 * a synchronous command completes.
317 */
318 int target_call_timer_callbacks_now(void);
319
320 struct target *get_current_target(struct command_context *cmd_ctx);
321 struct target *get_target(const char *id);
322
323 /**
324 * Get the target type name.
325 *
326 * This routine is a wrapper for the target->type->name field.
327 * Note that this is not an instance-specific name for his target.
328 */
329 const char *target_type_name(struct target *target);
330
331 /**
332 * Examine the specified @a target, letting it perform any
333 * Initialisation that requires JTAG access.
334 *
335 * This routine is a wrapper for target->type->examine.
336 */
337 int target_examine_one(struct target *target);
338
339 /** @returns @c true if target_set_examined() has been called. */
340 static inline bool target_was_examined(struct target *target)
341 {
342 return target->examined;
343 }
344
345 /** Sets the @c examined flag for the given target. */
346 /** Use in target->type->examine() after one-time setup is done. */
347 static inline void target_set_examined(struct target *target)
348 {
349 target->examined = true;
350 }
351
352 /**
353 * Add the @a breakpoint for @a target.
354 *
355 * This routine is a wrapper for target->type->add_breakpoint.
356 */
357 int target_add_breakpoint(struct target *target,
358 struct breakpoint *breakpoint);
359 /**
360 * Add the @a ContextID breakpoint for @a target.
361 *
362 * This routine is a wrapper for target->type->add_context_breakpoint.
363 */
364 int target_add_context_breakpoint(struct target *target,
365 struct breakpoint *breakpoint);
366 /**
367 * Add the @a ContextID & IVA breakpoint for @a target.
368 *
369 * This routine is a wrapper for target->type->add_hybrid_breakpoint.
370 */
371 int target_add_hybrid_breakpoint(struct target *target,
372 struct breakpoint *breakpoint);
373 /**
374 * Remove the @a breakpoint for @a target.
375 *
376 * This routine is a wrapper for target->type->remove_breakpoint.
377 */
378
379 int target_remove_breakpoint(struct target *target,
380 struct breakpoint *breakpoint);
381 /**
382 * Add the @a watchpoint for @a target.
383 *
384 * This routine is a wrapper for target->type->add_watchpoint.
385 */
386 int target_add_watchpoint(struct target *target,
387 struct watchpoint *watchpoint);
388 /**
389 * Remove the @a watchpoint for @a target.
390 *
391 * This routine is a wrapper for target->type->remove_watchpoint.
392 */
393 int target_remove_watchpoint(struct target *target,
394 struct watchpoint *watchpoint);
395
396 /**
397 * Obtain the registers for GDB.
398 *
399 * This routine is a wrapper for target->type->get_gdb_reg_list.
400 */
401 int target_get_gdb_reg_list(struct target *target,
402 struct reg **reg_list[], int *reg_list_size);
403
404 /**
405 * Step the target.
406 *
407 * This routine is a wrapper for target->type->step.
408 */
409 int target_step(struct target *target,
410 int current, uint32_t address, int handle_breakpoints);
411 /**
412 * Run an algorithm on the @a target given.
413 *
414 * This routine is a wrapper for target->type->run_algorithm.
415 */
416 int target_run_algorithm(struct target *target,
417 int num_mem_params, struct mem_param *mem_params,
418 int num_reg_params, struct reg_param *reg_param,
419 uint32_t entry_point, uint32_t exit_point,
420 int timeout_ms, void *arch_info);
421
422 /**
423 * Starts an algorithm in the background on the @a target given.
424 *
425 * This routine is a wrapper for target->type->start_algorithm.
426 */
427 int target_start_algorithm(struct target *target,
428 int num_mem_params, struct mem_param *mem_params,
429 int num_reg_params, struct reg_param *reg_params,
430 uint32_t entry_point, uint32_t exit_point,
431 void *arch_info);
432
433 /**
434 * Wait for an algorithm on the @a target given.
435 *
436 * This routine is a wrapper for target->type->wait_algorithm.
437 */
438 int target_wait_algorithm(struct target *target,
439 int num_mem_params, struct mem_param *mem_params,
440 int num_reg_params, struct reg_param *reg_params,
441 uint32_t exit_point, int timeout_ms,
442 void *arch_info);
443
444 /**
445 * This routine is a wrapper for asynchronous algorithms.
446 *
447 */
448 int target_run_flash_async_algorithm(struct target *target,
449 uint8_t *buffer, uint32_t count, int block_size,
450 int num_mem_params, struct mem_param *mem_params,
451 int num_reg_params, struct reg_param *reg_params,
452 uint32_t buffer_start, uint32_t buffer_size,
453 uint32_t entry_point, uint32_t exit_point,
454 void *arch_info);
455
456 /**
457 * Read @a count items of @a size bytes from the memory of @a target at
458 * the @a address given.
459 *
460 * This routine is a wrapper for target->type->read_memory.
461 */
462 int target_read_memory(struct target *target,
463 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
464 int target_read_phys_memory(struct target *target,
465 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
466 /**
467 * Write @a count items of @a size bytes to the memory of @a target at
468 * the @a address given. @a address must be aligned to @a size
469 * in target memory.
470 *
471 * The endianness is the same in the host and target memory for this
472 * function.
473 *
474 * \todo TODO:
475 * Really @a buffer should have been defined as "const void *" and
476 * @a buffer should have been aligned to @a size in the host memory.
477 *
478 * This is not enforced via e.g. assert's today and e.g. the
479 * target_write_buffer fn breaks this assumption.
480 *
481 * This routine is wrapper for target->type->write_memory.
482 */
483 int target_write_memory(struct target *target,
484 uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
485 int target_write_phys_memory(struct target *target,
486 uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
487
488 /**
489 * Write @a count items of 4 bytes to the memory of @a target at
490 * the @a address given. Because it operates only on whole words,
491 * this should be faster than target_write_memory().
492 *
493 * This routine is wrapper for target->type->bulk_write_memory.
494 */
495 int target_bulk_write_memory(struct target *target,
496 uint32_t address, uint32_t count, const uint8_t *buffer);
497
498 /*
499 * Write to target memory using the virtual address.
500 *
501 * Note that this fn is used to implement software breakpoints. Targets
502 * can implement support for software breakpoints to memory marked as read
503 * only by making this fn write to ram even if it is read only(MMU or
504 * MPUs).
505 *
506 * It is sufficient to implement for writing a single word(16 or 32 in
507 * ARM32/16 bit case) to write the breakpoint to ram.
508 *
509 * The target should also take care of "other things" to make sure that
510 * software breakpoints can be written using this function. E.g.
511 * when there is a separate instruction and data cache, this fn must
512 * make sure that the instruction cache is synced up to the potential
513 * code change that can happen as a result of the memory write(typically
514 * by invalidating the cache).
515 *
516 * The high level wrapper fn in target.c will break down this memory write
517 * request to multiple write requests to the target driver to e.g. guarantee
518 * that writing 4 bytes to an aligned address happens with a single 32 bit
519 * write operation, thus making this fn suitable to e.g. write to special
520 * peripheral registers which do not support byte operations.
521 */
522 int target_write_buffer(struct target *target,
523 uint32_t address, uint32_t size, const uint8_t *buffer);
524 int target_read_buffer(struct target *target,
525 uint32_t address, uint32_t size, uint8_t *buffer);
526 int target_checksum_memory(struct target *target,
527 uint32_t address, uint32_t size, uint32_t *crc);
528 int target_blank_check_memory(struct target *target,
529 uint32_t address, uint32_t size, uint32_t *blank);
530 int target_wait_state(struct target *target, enum target_state state, int ms);
531
532 /** Return the *name* of this targets current state */
533 const char *target_state_name(struct target *target);
534
535 /* DANGER!!!!!
536 *
537 * if "area" passed in to target_alloc_working_area() points to a memory
538 * location that goes out of scope (e.g. a pointer on the stack), then
539 * the caller of target_alloc_working_area() is responsible for invoking
540 * target_free_working_area() before "area" goes out of scope.
541 *
542 * target_free_all_working_areas() will NULL out the "area" pointer
543 * upon resuming or resetting the CPU.
544 *
545 */
546 int target_alloc_working_area(struct target *target,
547 uint32_t size, struct working_area **area);
548 /* Same as target_alloc_working_area, except that no error is logged
549 * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
550 *
551 * This allows the calling code to *try* to allocate target memory
552 * and have a fallback to another behaviour(slower?).
553 */
554 int target_alloc_working_area_try(struct target *target,
555 uint32_t size, struct working_area **area);
556 int target_free_working_area(struct target *target, struct working_area *area);
557 void target_free_all_working_areas(struct target *target);
558 uint32_t target_get_working_area_avail(struct target *target);
559
560 extern struct target *all_targets;
561
562 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer);
563 uint32_t target_buffer_get_u24(struct target *target, const uint8_t *buffer);
564 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer);
565 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value);
566 void target_buffer_set_u24(struct target *target, uint8_t *buffer, uint32_t value);
567 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value);
568
569 void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf);
570 void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, uint32_t count, uint16_t *dstbuf);
571 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, uint32_t *srcbuf);
572 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, uint16_t *srcbuf);
573
574 int target_read_u32(struct target *target, uint32_t address, uint32_t *value);
575 int target_read_u16(struct target *target, uint32_t address, uint16_t *value);
576 int target_read_u8(struct target *target, uint32_t address, uint8_t *value);
577 int target_write_u32(struct target *target, uint32_t address, uint32_t value);
578 int target_write_u16(struct target *target, uint32_t address, uint16_t value);
579 int target_write_u8(struct target *target, uint32_t address, uint8_t value);
580
581 /* Issues USER() statements with target state information */
582 int target_arch_state(struct target *target);
583
584 void target_handle_event(struct target *t, enum target_event e);
585
586 #define ERROR_TARGET_INVALID (-300)
587 #define ERROR_TARGET_INIT_FAILED (-301)
588 #define ERROR_TARGET_TIMEOUT (-302)
589 #define ERROR_TARGET_NOT_HALTED (-304)
590 #define ERROR_TARGET_FAILURE (-305)
591 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
592 #define ERROR_TARGET_DATA_ABORT (-307)
593 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
594 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
595 #define ERROR_TARGET_NOT_RUNNING (-310)
596 #define ERROR_TARGET_NOT_EXAMINED (-311)
597
598 extern bool get_target_reset_nag(void);
599
600 #endif /* TARGET_H */

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)