1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2011 by Broadcom Corporation *
12 * Evan Hunter - ehunter@broadcom.com *
14 * Copyright (C) ST-Ericsson SA 2011 *
15 * michel.jaouen@stericsson.com : smp minimum support *
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. *
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. *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
29 ***************************************************************************/
31 #ifndef OPENOCD_TARGET_TARGET_H
32 #define OPENOCD_TARGET_TARGET_H
34 #include <helper/list.h>
38 struct command_context
;
44 struct gdb_fileio_info
;
47 * TARGET_UNKNOWN = 0: we don't know anything about the target yet
48 * TARGET_RUNNING = 1: the target is executing user code
49 * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
50 * debugger. on an xscale it means that the debug handler is executing
51 * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
52 * not sure how this is used with all the recent changes)
53 * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
54 * behalf of the debugger (e.g. algorithm for flashing)
56 * also see: target_state_name();
64 TARGET_DEBUG_RUNNING
= 4,
72 enum target_reset_mode
{
74 RESET_RUN
= 1, /* reset and let target run */
75 RESET_HALT
= 2, /* reset and halt target out of reset */
76 RESET_INIT
= 3, /* reset and halt target out of reset, then run init script */
79 enum target_debug_reason
{
81 DBG_REASON_BREAKPOINT
= 1,
82 DBG_REASON_WATCHPOINT
= 2,
83 DBG_REASON_WPTANDBKPT
= 3,
84 DBG_REASON_SINGLESTEP
= 4,
85 DBG_REASON_NOTHALTED
= 5,
87 DBG_REASON_UNDEFINED
= 7,
90 enum target_endianness
{
91 TARGET_ENDIAN_UNKNOWN
= 0,
92 TARGET_BIG_ENDIAN
= 1, TARGET_LITTLE_ENDIAN
= 2
100 struct working_area
**user
;
101 struct working_area
*next
;
105 struct target
*target
;
106 /* field for smp display */
107 /* element 0 coreid currently displayed ( 1 till n) */
108 /* element 1 coreid to be displayed at next resume 1 till n 0 means resume
109 * all cores core displayed */
113 /* target back off timer */
114 struct backoff_timer
{
119 /* split target registers into multiple class */
120 enum target_register_class
{
125 /* target_type.h contains the full definition of struct target_type */
127 struct target_type
*type
; /* target type definition (name, access functions) */
128 const char *cmd_name
; /* tcl Name of target */
129 int target_number
; /* DO NOT USE! field to be removed in 2010 */
130 struct jtag_tap
*tap
; /* where on the jtag chain is this */
131 int32_t coreid
; /* which device on the TAP? */
134 * Indicates whether this target has been examined.
136 * Do @b not access this field directly, use target_was_examined()
137 * or target_set_examined().
142 * true if the target is currently running a downloaded
143 * "algorithm" instead of arbitrary user code. OpenOCD code
144 * invoking algorithms is trusted to maintain correctness of
145 * any cached state (e.g. for flash status), which arbitrary
146 * code will have no reason to know about.
150 struct target_event_action
*event_action
;
152 int reset_halt
; /* attempt resetting the CPU into the halted mode? */
153 uint32_t working_area
; /* working area (initialised RAM). Evaluated
154 * upon first allocation from virtual/physical address. */
155 bool working_area_virt_spec
; /* virtual address specified? */
156 uint32_t working_area_virt
; /* virtual address */
157 bool working_area_phys_spec
; /* physical address specified? */
158 uint32_t working_area_phys
; /* physical address */
159 uint32_t working_area_size
; /* size in bytes */
160 uint32_t backup_working_area
; /* whether the content of the working area has to be preserved */
161 struct working_area
*working_areas
;/* list of allocated working areas */
162 enum target_debug_reason debug_reason
;/* reason why the target entered debug state */
163 enum target_endianness endianness
; /* target endianness */
164 /* also see: target_state_name() */
165 enum target_state state
; /* the current backend-state (running, halted, ...) */
166 struct reg_cache
*reg_cache
; /* the first register cache of the target (core regs) */
167 struct breakpoint
*breakpoints
; /* list of breakpoints */
168 struct watchpoint
*watchpoints
; /* list of watchpoints */
169 struct trace
*trace_info
; /* generic trace information */
170 struct debug_msg_receiver
*dbgmsg
; /* list of debug message receivers */
171 uint32_t dbg_msg_enabled
; /* debug message status */
172 void *arch_info
; /* architecture specific information */
173 struct target
*next
; /* next target in list */
175 int display
; /* display async info in telnet session. Do not display
176 * lots of halted/resumed info when stepping in debugger. */
177 bool halt_issued
; /* did we transition to halted state? */
178 int64_t halt_issued_time
; /* Note time when halt was issued */
180 bool dbgbase_set
; /* By default the debug base is not set */
181 uint32_t dbgbase
; /* Really a Cortex-A specific option, but there is no
182 * system in place to support target specific options
184 struct rtos
*rtos
; /* Instance of Real Time Operating System support */
185 bool rtos_auto_detect
; /* A flag that indicates that the RTOS has been specified as "auto"
186 * and must be detected when symbols are offered */
187 struct backoff_timer backoff
;
188 int smp
; /* add some target attributes for smp support */
189 struct target_list
*head
;
190 /* the gdb service is there in case of smp, we have only one gdb server
192 * the target attached to the gdb is changing dynamically by changing
193 * gdb_service->target pointer */
194 struct gdb_service
*gdb_service
;
196 /* file-I/O information for host to do syscall */
197 struct gdb_fileio_info
*fileio_info
;
201 struct target
*target
;
202 struct target_list
*next
;
205 struct gdb_fileio_info
{
213 /** Returns the instance-specific name of the specified target. */
214 static inline const char *target_name(struct target
*target
)
216 return target
->cmd_name
;
219 const char *debug_reason_name(struct target
*t
);
223 /* allow GDB to do stuff before others handle the halted event,
224 * this is in lieu of defining ordering of invocation of events,
225 * which would be more complicated
227 * Telling GDB to halt does not mean that the target stopped running,
228 * simply that we're dropping out of GDB's waiting for step or continue.
230 * This can be useful when e.g. detecting power dropout.
232 TARGET_EVENT_GDB_HALT
,
233 TARGET_EVENT_HALTED
, /* target entered debug state from normal execution or reset */
234 TARGET_EVENT_RESUMED
, /* target resumed to normal execution */
235 TARGET_EVENT_RESUME_START
,
236 TARGET_EVENT_RESUME_END
,
238 TARGET_EVENT_GDB_START
, /* debugger started execution (step/run) */
239 TARGET_EVENT_GDB_END
, /* debugger stopped execution (step/run) */
241 TARGET_EVENT_RESET_START
,
242 TARGET_EVENT_RESET_ASSERT_PRE
,
243 TARGET_EVENT_RESET_ASSERT
, /* C code uses this instead of SRST */
244 TARGET_EVENT_RESET_ASSERT_POST
,
245 TARGET_EVENT_RESET_DEASSERT_PRE
,
246 TARGET_EVENT_RESET_DEASSERT_POST
,
247 TARGET_EVENT_RESET_HALT_PRE
,
248 TARGET_EVENT_RESET_HALT_POST
,
249 TARGET_EVENT_RESET_WAIT_PRE
,
250 TARGET_EVENT_RESET_WAIT_POST
,
251 TARGET_EVENT_RESET_INIT
,
252 TARGET_EVENT_RESET_END
,
254 TARGET_EVENT_DEBUG_HALTED
, /* target entered debug state, but was executing on behalf of the debugger */
255 TARGET_EVENT_DEBUG_RESUMED
, /* target resumed to execute on behalf of the debugger */
257 TARGET_EVENT_EXAMINE_START
,
258 TARGET_EVENT_EXAMINE_END
,
260 TARGET_EVENT_GDB_ATTACH
,
261 TARGET_EVENT_GDB_DETACH
,
263 TARGET_EVENT_GDB_FLASH_ERASE_START
,
264 TARGET_EVENT_GDB_FLASH_ERASE_END
,
265 TARGET_EVENT_GDB_FLASH_WRITE_START
,
266 TARGET_EVENT_GDB_FLASH_WRITE_END
,
268 TARGET_EVENT_TRACE_CONFIG
,
271 struct target_event_action
{
272 enum target_event event
;
273 struct Jim_Interp
*interp
;
274 struct Jim_Obj
*body
;
276 struct target_event_action
*next
;
279 bool target_has_event_action(struct target
*target
, enum target_event event
);
281 struct target_event_callback
{
282 int (*callback
)(struct target
*target
, enum target_event event
, void *priv
);
284 struct target_event_callback
*next
;
287 struct target_reset_callback
{
288 struct list_head list
;
290 int (*callback
)(struct target
*target
, enum target_reset_mode reset_mode
, void *priv
);
293 struct target_trace_callback
{
294 struct list_head list
;
296 int (*callback
)(struct target
*target
, size_t len
, uint8_t *data
, void *priv
);
299 struct target_timer_callback
{
300 int (*callback
)(void *priv
);
306 struct target_timer_callback
*next
;
309 int target_register_commands(struct command_context
*cmd_ctx
);
310 int target_examine(void);
312 int target_register_event_callback(
313 int (*callback
)(struct target
*target
,
314 enum target_event event
, void *priv
),
316 int target_unregister_event_callback(
317 int (*callback
)(struct target
*target
,
318 enum target_event event
, void *priv
),
321 int target_register_reset_callback(
322 int (*callback
)(struct target
*target
,
323 enum target_reset_mode reset_mode
, void *priv
),
325 int target_unregister_reset_callback(
326 int (*callback
)(struct target
*target
,
327 enum target_reset_mode reset_mode
, void *priv
),
330 int target_register_trace_callback(
331 int (*callback
)(struct target
*target
,
332 size_t len
, uint8_t *data
, void *priv
),
334 int target_unregister_trace_callback(
335 int (*callback
)(struct target
*target
,
336 size_t len
, uint8_t *data
, void *priv
),
339 /* Poll the status of the target, detect any error conditions and report them.
341 * Also note that this fn will clear such error conditions, so a subsequent
342 * invocation will then succeed.
344 * These error conditions can be "sticky" error conditions. E.g. writing
345 * to memory could be implemented as an open loop and if memory writes
346 * fails, then a note is made of it, the error is sticky, but the memory
347 * write loop still runs to completion. This improves performance in the
348 * normal case as there is no need to verify that every single write succeed,
349 * yet it is possible to detect error conditions.
351 int target_poll(struct target
*target
);
352 int target_resume(struct target
*target
, int current
, uint32_t address
,
353 int handle_breakpoints
, int debug_execution
);
354 int target_halt(struct target
*target
);
355 int target_call_event_callbacks(struct target
*target
, enum target_event event
);
356 int target_call_reset_callbacks(struct target
*target
, enum target_reset_mode reset_mode
);
357 int target_call_trace_callbacks(struct target
*target
, size_t len
, uint8_t *data
);
360 * The period is very approximate, the callback can happen much more often
361 * or much more rarely than specified
363 int target_register_timer_callback(int (*callback
)(void *priv
),
364 int time_ms
, int periodic
, void *priv
);
365 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
);
366 int target_call_timer_callbacks(void);
368 * Invoke this to ensure that e.g. polling timer callbacks happen before
369 * a synchronous command completes.
371 int target_call_timer_callbacks_now(void);
373 struct target
*get_target_by_num(int num
);
374 struct target
*get_current_target(struct command_context
*cmd_ctx
);
375 struct target
*get_target(const char *id
);
378 * Get the target type name.
380 * This routine is a wrapper for the target->type->name field.
381 * Note that this is not an instance-specific name for his target.
383 const char *target_type_name(struct target
*target
);
386 * Examine the specified @a target, letting it perform any
387 * Initialisation that requires JTAG access.
389 * This routine is a wrapper for target->type->examine.
391 int target_examine_one(struct target
*target
);
393 /** @returns @c true if target_set_examined() has been called. */
394 static inline bool target_was_examined(struct target
*target
)
396 return target
->examined
;
399 /** Sets the @c examined flag for the given target. */
400 /** Use in target->type->examine() after one-time setup is done. */
401 static inline void target_set_examined(struct target
*target
)
403 target
->examined
= true;
407 * Add the @a breakpoint for @a target.
409 * This routine is a wrapper for target->type->add_breakpoint.
411 int target_add_breakpoint(struct target
*target
,
412 struct breakpoint
*breakpoint
);
414 * Add the @a ContextID breakpoint for @a target.
416 * This routine is a wrapper for target->type->add_context_breakpoint.
418 int target_add_context_breakpoint(struct target
*target
,
419 struct breakpoint
*breakpoint
);
421 * Add the @a ContextID & IVA breakpoint for @a target.
423 * This routine is a wrapper for target->type->add_hybrid_breakpoint.
425 int target_add_hybrid_breakpoint(struct target
*target
,
426 struct breakpoint
*breakpoint
);
428 * Remove the @a breakpoint for @a target.
430 * This routine is a wrapper for target->type->remove_breakpoint.
433 int target_remove_breakpoint(struct target
*target
,
434 struct breakpoint
*breakpoint
);
436 * Add the @a watchpoint for @a target.
438 * This routine is a wrapper for target->type->add_watchpoint.
440 int target_add_watchpoint(struct target
*target
,
441 struct watchpoint
*watchpoint
);
443 * Remove the @a watchpoint for @a target.
445 * This routine is a wrapper for target->type->remove_watchpoint.
447 int target_remove_watchpoint(struct target
*target
,
448 struct watchpoint
*watchpoint
);
451 * Find out the just hit @a watchpoint for @a target.
453 * This routine is a wrapper for target->type->hit_watchpoint.
455 int target_hit_watchpoint(struct target
*target
,
456 struct watchpoint
**watchpoint
);
459 * Obtain the registers for GDB.
461 * This routine is a wrapper for target->type->get_gdb_reg_list.
463 int target_get_gdb_reg_list(struct target
*target
,
464 struct reg
**reg_list
[], int *reg_list_size
,
465 enum target_register_class reg_class
);
470 * This routine is a wrapper for target->type->step.
472 int target_step(struct target
*target
,
473 int current
, uint32_t address
, int handle_breakpoints
);
475 * Run an algorithm on the @a target given.
477 * This routine is a wrapper for target->type->run_algorithm.
479 int target_run_algorithm(struct target
*target
,
480 int num_mem_params
, struct mem_param
*mem_params
,
481 int num_reg_params
, struct reg_param
*reg_param
,
482 uint32_t entry_point
, uint32_t exit_point
,
483 int timeout_ms
, void *arch_info
);
486 * Starts an algorithm in the background on the @a target given.
488 * This routine is a wrapper for target->type->start_algorithm.
490 int target_start_algorithm(struct target
*target
,
491 int num_mem_params
, struct mem_param
*mem_params
,
492 int num_reg_params
, struct reg_param
*reg_params
,
493 uint32_t entry_point
, uint32_t exit_point
,
497 * Wait for an algorithm on the @a target given.
499 * This routine is a wrapper for target->type->wait_algorithm.
501 int target_wait_algorithm(struct target
*target
,
502 int num_mem_params
, struct mem_param
*mem_params
,
503 int num_reg_params
, struct reg_param
*reg_params
,
504 uint32_t exit_point
, int timeout_ms
,
508 * This routine is a wrapper for asynchronous algorithms.
511 int target_run_flash_async_algorithm(struct target
*target
,
512 const uint8_t *buffer
, uint32_t count
, int block_size
,
513 int num_mem_params
, struct mem_param
*mem_params
,
514 int num_reg_params
, struct reg_param
*reg_params
,
515 uint32_t buffer_start
, uint32_t buffer_size
,
516 uint32_t entry_point
, uint32_t exit_point
,
520 * Read @a count items of @a size bytes from the memory of @a target at
521 * the @a address given.
523 * This routine is a wrapper for target->type->read_memory.
525 int target_read_memory(struct target
*target
,
526 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
);
527 int target_read_phys_memory(struct target
*target
,
528 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
);
530 * Write @a count items of @a size bytes to the memory of @a target at
531 * the @a address given. @a address must be aligned to @a size
534 * The endianness is the same in the host and target memory for this
538 * Really @a buffer should have been defined as "const void *" and
539 * @a buffer should have been aligned to @a size in the host memory.
541 * This is not enforced via e.g. assert's today and e.g. the
542 * target_write_buffer fn breaks this assumption.
544 * This routine is wrapper for target->type->write_memory.
546 int target_write_memory(struct target
*target
,
547 uint32_t address
, uint32_t size
, uint32_t count
, const uint8_t *buffer
);
548 int target_write_phys_memory(struct target
*target
,
549 uint32_t address
, uint32_t size
, uint32_t count
, const uint8_t *buffer
);
552 * Write to target memory using the virtual address.
554 * Note that this fn is used to implement software breakpoints. Targets
555 * can implement support for software breakpoints to memory marked as read
556 * only by making this fn write to ram even if it is read only(MMU or
559 * It is sufficient to implement for writing a single word(16 or 32 in
560 * ARM32/16 bit case) to write the breakpoint to ram.
562 * The target should also take care of "other things" to make sure that
563 * software breakpoints can be written using this function. E.g.
564 * when there is a separate instruction and data cache, this fn must
565 * make sure that the instruction cache is synced up to the potential
566 * code change that can happen as a result of the memory write(typically
567 * by invalidating the cache).
569 * The high level wrapper fn in target.c will break down this memory write
570 * request to multiple write requests to the target driver to e.g. guarantee
571 * that writing 4 bytes to an aligned address happens with a single 32 bit
572 * write operation, thus making this fn suitable to e.g. write to special
573 * peripheral registers which do not support byte operations.
575 int target_write_buffer(struct target
*target
,
576 uint32_t address
, uint32_t size
, const uint8_t *buffer
);
577 int target_read_buffer(struct target
*target
,
578 uint32_t address
, uint32_t size
, uint8_t *buffer
);
579 int target_checksum_memory(struct target
*target
,
580 uint32_t address
, uint32_t size
, uint32_t *crc
);
581 int target_blank_check_memory(struct target
*target
,
582 uint32_t address
, uint32_t size
, uint32_t *blank
);
583 int target_wait_state(struct target
*target
, enum target_state state
, int ms
);
586 * Obtain file-I/O information from target for GDB to do syscall.
588 * This routine is a wrapper for target->type->get_gdb_fileio_info.
590 int target_get_gdb_fileio_info(struct target
*target
, struct gdb_fileio_info
*fileio_info
);
593 * Pass GDB file-I/O response to target after finishing host syscall.
595 * This routine is a wrapper for target->type->gdb_fileio_end.
597 int target_gdb_fileio_end(struct target
*target
, int retcode
, int fileio_errno
, bool ctrl_c
);
601 /** Return the *name* of this targets current state */
602 const char *target_state_name(struct target
*target
);
604 /** Return the *name* of a target event enumeration value */
605 const char *target_event_name(enum target_event event
);
607 /** Return the *name* of a target reset reason enumeration value */
608 const char *target_reset_mode_name(enum target_reset_mode reset_mode
);
612 * if "area" passed in to target_alloc_working_area() points to a memory
613 * location that goes out of scope (e.g. a pointer on the stack), then
614 * the caller of target_alloc_working_area() is responsible for invoking
615 * target_free_working_area() before "area" goes out of scope.
617 * target_free_all_working_areas() will NULL out the "area" pointer
618 * upon resuming or resetting the CPU.
621 int target_alloc_working_area(struct target
*target
,
622 uint32_t size
, struct working_area
**area
);
623 /* Same as target_alloc_working_area, except that no error is logged
624 * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
626 * This allows the calling code to *try* to allocate target memory
627 * and have a fallback to another behaviour(slower?).
629 int target_alloc_working_area_try(struct target
*target
,
630 uint32_t size
, struct working_area
**area
);
631 int target_free_working_area(struct target
*target
, struct working_area
*area
);
632 void target_free_all_working_areas(struct target
*target
);
633 uint32_t target_get_working_area_avail(struct target
*target
);
636 * Free all the resources allocated by targets and the target layer
638 void target_quit(void);
640 extern struct target
*all_targets
;
642 uint64_t target_buffer_get_u64(struct target
*target
, const uint8_t *buffer
);
643 uint32_t target_buffer_get_u32(struct target
*target
, const uint8_t *buffer
);
644 uint32_t target_buffer_get_u24(struct target
*target
, const uint8_t *buffer
);
645 uint16_t target_buffer_get_u16(struct target
*target
, const uint8_t *buffer
);
646 void target_buffer_set_u64(struct target
*target
, uint8_t *buffer
, uint64_t value
);
647 void target_buffer_set_u32(struct target
*target
, uint8_t *buffer
, uint32_t value
);
648 void target_buffer_set_u24(struct target
*target
, uint8_t *buffer
, uint32_t value
);
649 void target_buffer_set_u16(struct target
*target
, uint8_t *buffer
, uint16_t value
);
651 void target_buffer_get_u64_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint64_t *dstbuf
);
652 void target_buffer_get_u32_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint32_t *dstbuf
);
653 void target_buffer_get_u16_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint16_t *dstbuf
);
654 void target_buffer_set_u64_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint64_t *srcbuf
);
655 void target_buffer_set_u32_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint32_t *srcbuf
);
656 void target_buffer_set_u16_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint16_t *srcbuf
);
658 int target_read_u64(struct target
*target
, uint64_t address
, uint64_t *value
);
659 int target_read_u32(struct target
*target
, uint32_t address
, uint32_t *value
);
660 int target_read_u16(struct target
*target
, uint32_t address
, uint16_t *value
);
661 int target_read_u8(struct target
*target
, uint32_t address
, uint8_t *value
);
662 int target_write_u64(struct target
*target
, uint64_t address
, uint64_t value
);
663 int target_write_u32(struct target
*target
, uint32_t address
, uint32_t value
);
664 int target_write_u16(struct target
*target
, uint32_t address
, uint16_t value
);
665 int target_write_u8(struct target
*target
, uint32_t address
, uint8_t value
);
667 /* Issues USER() statements with target state information */
668 int target_arch_state(struct target
*target
);
670 void target_handle_event(struct target
*t
, enum target_event e
);
672 #define ERROR_TARGET_INVALID (-300)
673 #define ERROR_TARGET_INIT_FAILED (-301)
674 #define ERROR_TARGET_TIMEOUT (-302)
675 #define ERROR_TARGET_NOT_HALTED (-304)
676 #define ERROR_TARGET_FAILURE (-305)
677 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
678 #define ERROR_TARGET_DATA_ABORT (-307)
679 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
680 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
681 #define ERROR_TARGET_NOT_RUNNING (-310)
682 #define ERROR_TARGET_NOT_EXAMINED (-311)
684 extern bool get_target_reset_nag(void);
686 #endif /* OPENOCD_TARGET_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)