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