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