1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath *
5 * Dominic.Rath@gmx.de *
7 * Copyright (C) 2007-2010 Øyvind Harboe *
8 * oyvind.harboe@zylin.com *
10 * Copyright (C) 2008 by Spencer Oliver *
11 * spen@spen-soft.co.uk *
13 * Copyright (C) 2011 by Broadcom Corporation *
14 * Evan Hunter - ehunter@broadcom.com *
16 * Copyright (C) ST-Ericsson SA 2011 *
17 * michel.jaouen@stericsson.com : smp minimum support *
18 ***************************************************************************/
20 #ifndef OPENOCD_TARGET_TARGET_H
21 #define OPENOCD_TARGET_TARGET_H
23 #include <helper/list.h>
24 #include "helper/replacements.h"
25 #include "helper/system.h"
30 struct command_context
;
31 struct command_invocation
;
37 struct gdb_fileio_info
;
40 * TARGET_UNKNOWN = 0: we don't know anything about the target yet
41 * TARGET_RUNNING = 1: the target is executing or ready to execute user code
42 * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
43 * debugger. on an xscale it means that the debug handler is executing
44 * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
45 * not sure how this is used with all the recent changes)
46 * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
47 * behalf of the debugger (e.g. algorithm for flashing)
49 * also see: target_state_name();
57 TARGET_DEBUG_RUNNING
= 4,
60 enum target_reset_mode
{
62 RESET_RUN
= 1, /* reset and let target run */
63 RESET_HALT
= 2, /* reset and halt target out of reset */
64 RESET_INIT
= 3, /* reset and halt target out of reset, then run init script */
67 enum target_debug_reason
{
69 DBG_REASON_BREAKPOINT
= 1,
70 DBG_REASON_WATCHPOINT
= 2,
71 DBG_REASON_WPTANDBKPT
= 3,
72 DBG_REASON_SINGLESTEP
= 4,
73 DBG_REASON_NOTHALTED
= 5,
75 DBG_REASON_EXC_CATCH
= 7,
76 DBG_REASON_UNDEFINED
= 8,
79 enum target_endianness
{
80 TARGET_ENDIAN_UNKNOWN
= 0,
81 TARGET_BIG_ENDIAN
= 1, TARGET_LITTLE_ENDIAN
= 2
85 target_addr_t address
;
89 struct working_area
**user
;
90 struct working_area
*next
;
94 struct target
*target
;
95 /* field for smp display */
96 /* element 0 coreid currently displayed ( 1 till n) */
97 /* element 1 coreid to be displayed at next resume 1 till n 0 means resume
98 * all cores core displayed */
102 /* target back off timer */
103 struct backoff_timer
{
108 /* split target registers into multiple class */
109 enum target_register_class
{
114 /* target_type.h contains the full definition of struct target_type */
116 struct target_type
*type
; /* target type definition (name, access functions) */
117 char *cmd_name
; /* tcl Name of target */
118 struct jtag_tap
*tap
; /* where on the jtag chain is this */
119 int32_t coreid
; /* which device on the TAP? */
121 /** Should we defer examine to later */
125 * Indicates whether this target has been examined.
127 * Do @b not access this field directly, use target_was_examined()
128 * or target_set_examined().
133 * true if the target is currently running a downloaded
134 * "algorithm" instead of arbitrary user code. OpenOCD code
135 * invoking algorithms is trusted to maintain correctness of
136 * any cached state (e.g. for flash status), which arbitrary
137 * code will have no reason to know about.
141 struct target_event_action
*event_action
;
143 bool reset_halt
; /* attempt resetting the CPU into the halted mode? */
144 target_addr_t working_area
; /* working area (initialised RAM). Evaluated
145 * upon first allocation from virtual/physical address. */
146 bool working_area_virt_spec
; /* virtual address specified? */
147 target_addr_t working_area_virt
; /* virtual address */
148 bool working_area_phys_spec
; /* physical address specified? */
149 target_addr_t working_area_phys
; /* physical address */
150 uint32_t working_area_size
; /* size in bytes */
151 bool backup_working_area
; /* whether the content of the working area has to be preserved */
152 struct working_area
*working_areas
;/* list of allocated working areas */
153 enum target_debug_reason debug_reason
;/* reason why the target entered debug state */
154 enum target_endianness endianness
; /* target endianness */
155 /* also see: target_state_name() */
156 enum target_state state
; /* the current backend-state (running, halted, ...) */
157 struct reg_cache
*reg_cache
; /* the first register cache of the target (core regs) */
158 struct breakpoint
*breakpoints
; /* list of breakpoints */
159 struct watchpoint
*watchpoints
; /* list of watchpoints */
160 struct trace
*trace_info
; /* generic trace information */
161 struct debug_msg_receiver
*dbgmsg
; /* list of debug message receivers */
162 uint32_t dbg_msg_enabled
; /* debug message status */
163 void *arch_info
; /* architecture specific information */
164 void *private_config
; /* pointer to target specific config data (for jim_configure hook) */
165 struct target
*next
; /* next target in list */
167 bool verbose_halt_msg
; /* display async info in telnet session. Do not display
168 * lots of halted/resumed info when stepping in debugger. */
169 bool halt_issued
; /* did we transition to halted state? */
170 int64_t halt_issued_time
; /* Note time when halt was issued */
172 /* ARM v7/v8 targets with ADIv5 interface */
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
177 bool has_dap
; /* set to true if target has ADIv5 support */
178 bool dap_configured
; /* set to true if ADIv5 DAP is configured */
179 bool tap_configured
; /* set to true if JTAG tap has been configured
180 * through -chain-position */
182 struct rtos
*rtos
; /* Instance of Real Time Operating System support */
183 bool rtos_auto_detect
; /* A flag that indicates that the RTOS has been specified as "auto"
184 * and must be detected when symbols are offered */
185 struct backoff_timer backoff
;
186 int smp
; /* Unique non-zero number for each SMP group */
187 struct list_head
*smp_targets
; /* list all targets in this smp group/cluster
188 * The head of the list is shared between the
189 * cluster, thus here there is a pointer */
190 bool smp_halt_event_postponed
; /* Some SMP implementations (currently Cortex-M) stores
191 * 'halted' events and emits them after all targets of
192 * the SMP group has been polled */
194 /* the gdb service is there in case of smp, we have only one gdb server
196 * the target attached to the gdb is changing dynamically by changing
197 * gdb_service->target pointer */
198 struct gdb_service
*gdb_service
;
200 /* file-I/O information for host to do syscall */
201 struct gdb_fileio_info
*fileio_info
;
203 char *gdb_port_override
; /* target-specific override for gdb_port */
205 int gdb_max_connections
; /* max number of simultaneous gdb connections */
207 /* The semihosting information, extracted from the target. */
208 struct semihosting
*semihosting
;
213 struct target
*target
;
216 struct gdb_fileio_info
{
224 /** Returns a description of the endianness for the specified target. */
225 static inline const char *target_endianness(const struct target
*target
)
227 return (target
->endianness
== TARGET_ENDIAN_UNKNOWN
) ? "unknown" :
228 (target
->endianness
== TARGET_BIG_ENDIAN
) ? "big endian" : "little endian";
231 /** Returns the instance-specific name of the specified target. */
232 static inline const char *target_name(const struct target
*target
)
234 return target
->cmd_name
;
237 const char *debug_reason_name(const struct target
*t
);
241 /* allow GDB to do stuff before others handle the halted event,
242 * this is in lieu of defining ordering of invocation of events,
243 * which would be more complicated
245 * Telling GDB to halt does not mean that the target stopped running,
246 * simply that we're dropping out of GDB's waiting for step or continue.
248 * This can be useful when e.g. detecting power dropout.
250 TARGET_EVENT_GDB_HALT
,
251 TARGET_EVENT_HALTED
, /* target entered debug state from normal execution or reset */
252 TARGET_EVENT_RESUMED
, /* target resumed to normal execution */
253 TARGET_EVENT_RESUME_START
,
254 TARGET_EVENT_RESUME_END
,
255 TARGET_EVENT_STEP_START
,
256 TARGET_EVENT_STEP_END
,
258 TARGET_EVENT_GDB_START
, /* debugger started execution (step/run) */
259 TARGET_EVENT_GDB_END
, /* debugger stopped execution (step/run) */
261 TARGET_EVENT_RESET_START
,
262 TARGET_EVENT_RESET_ASSERT_PRE
,
263 TARGET_EVENT_RESET_ASSERT
, /* C code uses this instead of SRST */
264 TARGET_EVENT_RESET_ASSERT_POST
,
265 TARGET_EVENT_RESET_DEASSERT_PRE
,
266 TARGET_EVENT_RESET_DEASSERT_POST
,
267 TARGET_EVENT_RESET_INIT
,
268 TARGET_EVENT_RESET_END
,
270 TARGET_EVENT_DEBUG_HALTED
, /* target entered debug state, but was executing on behalf of the debugger */
271 TARGET_EVENT_DEBUG_RESUMED
, /* target resumed to execute on behalf of the debugger */
273 TARGET_EVENT_EXAMINE_START
,
274 TARGET_EVENT_EXAMINE_FAIL
,
275 TARGET_EVENT_EXAMINE_END
,
277 TARGET_EVENT_GDB_ATTACH
,
278 TARGET_EVENT_GDB_DETACH
,
280 TARGET_EVENT_GDB_FLASH_ERASE_START
,
281 TARGET_EVENT_GDB_FLASH_ERASE_END
,
282 TARGET_EVENT_GDB_FLASH_WRITE_START
,
283 TARGET_EVENT_GDB_FLASH_WRITE_END
,
285 TARGET_EVENT_TRACE_CONFIG
,
287 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X100
= 0x100, /* semihosting allows user cmds from 0x100 to 0x1ff */
288 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X101
= 0x101,
289 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X102
= 0x102,
290 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X103
= 0x103,
291 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X104
= 0x104,
292 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X105
= 0x105,
293 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X106
= 0x106,
294 TARGET_EVENT_SEMIHOSTING_USER_CMD_0X107
= 0x107,
297 struct target_event_action
{
298 enum target_event event
;
301 struct target_event_action
*next
;
304 bool target_has_event_action(const struct target
*target
, enum target_event event
);
306 struct target_event_callback
{
307 int (*callback
)(struct target
*target
, enum target_event event
, void *priv
);
309 struct target_event_callback
*next
;
312 struct target_reset_callback
{
313 struct list_head list
;
315 int (*callback
)(struct target
*target
, enum target_reset_mode reset_mode
, void *priv
);
318 struct target_trace_callback
{
319 struct list_head list
;
321 int (*callback
)(struct target
*target
, size_t len
, uint8_t *data
, void *priv
);
324 enum target_timer_type
{
325 TARGET_TIMER_TYPE_ONESHOT
,
326 TARGET_TIMER_TYPE_PERIODIC
329 struct target_timer_callback
{
330 int (*callback
)(void *priv
);
331 unsigned int time_ms
;
332 enum target_timer_type type
;
334 int64_t when
; /* output of timeval_ms() */
336 struct target_timer_callback
*next
;
339 struct target_memory_check_block
{
340 target_addr_t address
;
345 int target_register_commands(struct command_context
*cmd_ctx
);
346 int target_examine(void);
348 int target_register_event_callback(
349 int (*callback
)(struct target
*target
,
350 enum target_event event
, void *priv
),
352 int target_unregister_event_callback(
353 int (*callback
)(struct target
*target
,
354 enum target_event event
, void *priv
),
357 int target_register_reset_callback(
358 int (*callback
)(struct target
*target
,
359 enum target_reset_mode reset_mode
, void *priv
),
361 int target_unregister_reset_callback(
362 int (*callback
)(struct target
*target
,
363 enum target_reset_mode reset_mode
, void *priv
),
366 int target_register_trace_callback(
367 int (*callback
)(struct target
*target
,
368 size_t len
, uint8_t *data
, void *priv
),
370 int target_unregister_trace_callback(
371 int (*callback
)(struct target
*target
,
372 size_t len
, uint8_t *data
, void *priv
),
375 /* Poll the status of the target, detect any error conditions and report them.
377 * Also note that this fn will clear such error conditions, so a subsequent
378 * invocation will then succeed.
380 * These error conditions can be "sticky" error conditions. E.g. writing
381 * to memory could be implemented as an open loop and if memory writes
382 * fails, then a note is made of it, the error is sticky, but the memory
383 * write loop still runs to completion. This improves performance in the
384 * normal case as there is no need to verify that every single write succeed,
385 * yet it is possible to detect error conditions.
387 int target_poll(struct target
*target
);
388 int target_resume(struct target
*target
, int current
, target_addr_t address
,
389 int handle_breakpoints
, int debug_execution
);
390 int target_halt(struct target
*target
);
391 int target_call_event_callbacks(struct target
*target
, enum target_event event
);
392 int target_call_reset_callbacks(struct target
*target
, enum target_reset_mode reset_mode
);
393 int target_call_trace_callbacks(struct target
*target
, size_t len
, uint8_t *data
);
396 * The period is very approximate, the callback can happen much more often
397 * or much more rarely than specified
399 int target_register_timer_callback(int (*callback
)(void *priv
),
400 unsigned int time_ms
, enum target_timer_type type
, void *priv
);
401 int target_unregister_timer_callback(int (*callback
)(void *priv
), void *priv
);
402 int target_call_timer_callbacks(void);
404 * Invoke this to ensure that e.g. polling timer callbacks happen before
405 * a synchronous command completes.
407 int target_call_timer_callbacks_now(void);
409 * Returns when the next registered event will take place. Callers can use this
410 * to go to sleep until that time occurs.
412 int64_t target_timer_next_event(void);
414 struct target
*get_current_target(struct command_context
*cmd_ctx
);
415 struct target
*get_current_target_or_null(struct command_context
*cmd_ctx
);
416 struct target
*get_target(const char *id
);
419 * Get the target type name.
421 * This routine is a wrapper for the target->type->name field.
422 * Note that this is not an instance-specific name for his target.
424 const char *target_type_name(const struct target
*target
);
427 * Examine the specified @a target, letting it perform any
428 * Initialisation that requires JTAG access.
430 * This routine is a wrapper for target->type->examine.
432 int target_examine_one(struct target
*target
);
434 /** @returns @c true if target_set_examined() has been called. */
435 static inline bool target_was_examined(const struct target
*target
)
437 return target
->examined
;
440 /** Sets the @c examined flag for the given target. */
441 /** Use in target->type->examine() after one-time setup is done. */
442 static inline void target_set_examined(struct target
*target
)
444 target
->examined
= true;
448 * Add the @a breakpoint for @a target.
450 * This routine is a wrapper for target->type->add_breakpoint.
452 int target_add_breakpoint(struct target
*target
,
453 struct breakpoint
*breakpoint
);
455 * Add the @a ContextID breakpoint for @a target.
457 * This routine is a wrapper for target->type->add_context_breakpoint.
459 int target_add_context_breakpoint(struct target
*target
,
460 struct breakpoint
*breakpoint
);
462 * Add the @a ContextID & IVA breakpoint for @a target.
464 * This routine is a wrapper for target->type->add_hybrid_breakpoint.
466 int target_add_hybrid_breakpoint(struct target
*target
,
467 struct breakpoint
*breakpoint
);
469 * Remove the @a breakpoint for @a target.
471 * This routine is a wrapper for target->type->remove_breakpoint.
474 int target_remove_breakpoint(struct target
*target
,
475 struct breakpoint
*breakpoint
);
477 * Add the @a watchpoint for @a target.
479 * This routine is a wrapper for target->type->add_watchpoint.
481 int target_add_watchpoint(struct target
*target
,
482 struct watchpoint
*watchpoint
);
484 * Remove the @a watchpoint for @a target.
486 * This routine is a wrapper for target->type->remove_watchpoint.
488 int target_remove_watchpoint(struct target
*target
,
489 struct watchpoint
*watchpoint
);
492 * Find out the just hit @a watchpoint for @a target.
494 * This routine is a wrapper for target->type->hit_watchpoint.
496 int target_hit_watchpoint(struct target
*target
,
497 struct watchpoint
**watchpoint
);
500 * Obtain the architecture for GDB.
502 * This routine is a wrapper for target->type->get_gdb_arch.
504 const char *target_get_gdb_arch(const struct target
*target
);
507 * Obtain the registers for GDB.
509 * This routine is a wrapper for target->type->get_gdb_reg_list.
511 int target_get_gdb_reg_list(struct target
*target
,
512 struct reg
**reg_list
[], int *reg_list_size
,
513 enum target_register_class reg_class
);
516 * Obtain the registers for GDB, but don't read register values from the
519 * This routine is a wrapper for target->type->get_gdb_reg_list_noread.
521 int target_get_gdb_reg_list_noread(struct target
*target
,
522 struct reg
**reg_list
[], int *reg_list_size
,
523 enum target_register_class reg_class
);
526 * Check if @a target allows GDB connections.
528 * Some target do not implement the necessary code required by GDB.
530 bool target_supports_gdb_connection(const struct target
*target
);
535 * This routine is a wrapper for target->type->step.
537 int target_step(struct target
*target
,
538 int current
, target_addr_t address
, int handle_breakpoints
);
540 * Run an algorithm on the @a target given.
542 * This routine is a wrapper for target->type->run_algorithm.
544 int target_run_algorithm(struct target
*target
,
545 int num_mem_params
, struct mem_param
*mem_params
,
546 int num_reg_params
, struct reg_param
*reg_param
,
547 target_addr_t entry_point
, target_addr_t exit_point
,
548 unsigned int timeout_ms
, void *arch_info
);
551 * Starts an algorithm in the background on the @a target given.
553 * This routine is a wrapper for target->type->start_algorithm.
555 int target_start_algorithm(struct target
*target
,
556 int num_mem_params
, struct mem_param
*mem_params
,
557 int num_reg_params
, struct reg_param
*reg_params
,
558 target_addr_t entry_point
, target_addr_t exit_point
,
562 * Wait for an algorithm on the @a target given.
564 * This routine is a wrapper for target->type->wait_algorithm.
566 int target_wait_algorithm(struct target
*target
,
567 int num_mem_params
, struct mem_param
*mem_params
,
568 int num_reg_params
, struct reg_param
*reg_params
,
569 target_addr_t exit_point
, unsigned int timeout_ms
,
573 * This routine is a wrapper for asynchronous algorithms.
576 int target_run_flash_async_algorithm(struct target
*target
,
577 const uint8_t *buffer
, uint32_t count
, int block_size
,
578 int num_mem_params
, struct mem_param
*mem_params
,
579 int num_reg_params
, struct reg_param
*reg_params
,
580 uint32_t buffer_start
, uint32_t buffer_size
,
581 uint32_t entry_point
, uint32_t exit_point
,
585 * This routine is a wrapper for asynchronous algorithms.
588 int target_run_read_async_algorithm(struct target
*target
,
589 uint8_t *buffer
, uint32_t count
, int block_size
,
590 int num_mem_params
, struct mem_param
*mem_params
,
591 int num_reg_params
, struct reg_param
*reg_params
,
592 uint32_t buffer_start
, uint32_t buffer_size
,
593 uint32_t entry_point
, uint32_t exit_point
,
597 * Read @a count items of @a size bytes from the memory of @a target at
598 * the @a address given.
600 * This routine is a wrapper for target->type->read_memory.
602 int target_read_memory(struct target
*target
,
603 target_addr_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
);
604 int target_read_phys_memory(struct target
*target
,
605 target_addr_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
);
607 * Write @a count items of @a size bytes to the memory of @a target at
608 * the @a address given. @a address must be aligned to @a size
611 * The endianness is the same in the host and target memory for this
615 * Really @a buffer should have been defined as "const void *" and
616 * @a buffer should have been aligned to @a size in the host memory.
618 * This is not enforced via e.g. assert's today and e.g. the
619 * target_write_buffer fn breaks this assumption.
621 * This routine is wrapper for target->type->write_memory.
623 int target_write_memory(struct target
*target
,
624 target_addr_t address
, uint32_t size
, uint32_t count
, const uint8_t *buffer
);
625 int target_write_phys_memory(struct target
*target
,
626 target_addr_t address
, uint32_t size
, uint32_t count
, const uint8_t *buffer
);
629 * Write to target memory using the virtual address.
631 * Note that this fn is used to implement software breakpoints. Targets
632 * can implement support for software breakpoints to memory marked as read
633 * only by making this fn write to ram even if it is read only(MMU or
636 * It is sufficient to implement for writing a single word(16 or 32 in
637 * ARM32/16 bit case) to write the breakpoint to ram.
639 * The target should also take care of "other things" to make sure that
640 * software breakpoints can be written using this function. E.g.
641 * when there is a separate instruction and data cache, this fn must
642 * make sure that the instruction cache is synced up to the potential
643 * code change that can happen as a result of the memory write(typically
644 * by invalidating the cache).
646 * The high level wrapper fn in target.c will break down this memory write
647 * request to multiple write requests to the target driver to e.g. guarantee
648 * that writing 4 bytes to an aligned address happens with a single 32 bit
649 * write operation, thus making this fn suitable to e.g. write to special
650 * peripheral registers which do not support byte operations.
652 int target_write_buffer(struct target
*target
,
653 target_addr_t address
, uint32_t size
, const uint8_t *buffer
);
654 int target_read_buffer(struct target
*target
,
655 target_addr_t address
, uint32_t size
, uint8_t *buffer
);
656 int target_checksum_memory(struct target
*target
,
657 target_addr_t address
, uint32_t size
, uint32_t *crc
);
658 int target_blank_check_memory(struct target
*target
,
659 struct target_memory_check_block
*blocks
, int num_blocks
,
660 uint8_t erased_value
);
661 int target_wait_state(struct target
*target
, enum target_state state
, unsigned int ms
);
664 * Obtain file-I/O information from target for GDB to do syscall.
666 * This routine is a wrapper for target->type->get_gdb_fileio_info.
668 int target_get_gdb_fileio_info(struct target
*target
, struct gdb_fileio_info
*fileio_info
);
671 * Pass GDB file-I/O response to target after finishing host syscall.
673 * This routine is a wrapper for target->type->gdb_fileio_end.
675 int target_gdb_fileio_end(struct target
*target
, int retcode
, int fileio_errno
, bool ctrl_c
);
678 * Return the highest accessible address for this target.
680 target_addr_t
target_address_max(struct target
*target
);
683 * Return the number of address bits this target supports.
685 * This routine is a wrapper for target->type->address_bits.
687 unsigned target_address_bits(struct target
*target
);
690 * Return the number of data bits this target supports.
692 * This routine is a wrapper for target->type->data_bits.
694 unsigned int target_data_bits(struct target
*target
);
696 /** Return the *name* of this targets current state */
697 const char *target_state_name(const struct target
*target
);
699 /** Return the *name* of a target event enumeration value */
700 const char *target_event_name(enum target_event event
);
702 /** Return the *name* of a target reset reason enumeration value */
703 const char *target_reset_mode_name(enum target_reset_mode reset_mode
);
707 * if "area" passed in to target_alloc_working_area() points to a memory
708 * location that goes out of scope (e.g. a pointer on the stack), then
709 * the caller of target_alloc_working_area() is responsible for invoking
710 * target_free_working_area() before "area" goes out of scope.
712 * target_free_all_working_areas() will NULL out the "area" pointer
713 * upon resuming or resetting the CPU.
716 int target_alloc_working_area(struct target
*target
,
717 uint32_t size
, struct working_area
**area
);
718 /* Same as target_alloc_working_area, except that no error is logged
719 * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
721 * This allows the calling code to *try* to allocate target memory
722 * and have a fallback to another behaviour(slower?).
724 int target_alloc_working_area_try(struct target
*target
,
725 uint32_t size
, struct working_area
**area
);
727 * Free a working area.
728 * Restore target data if area backup is configured.
730 * @param area Pointer to the area to be freed or NULL
731 * @returns ERROR_OK if successful; error code if restore failed
733 int target_free_working_area(struct target
*target
, struct working_area
*area
);
734 void target_free_all_working_areas(struct target
*target
);
735 uint32_t target_get_working_area_avail(struct target
*target
);
738 * Free all the resources allocated by targets and the target layer
740 void target_quit(void);
742 extern struct target
*all_targets
;
744 uint64_t target_buffer_get_u64(struct target
*target
, const uint8_t *buffer
);
745 uint32_t target_buffer_get_u32(struct target
*target
, const uint8_t *buffer
);
746 uint32_t target_buffer_get_u24(struct target
*target
, const uint8_t *buffer
);
747 uint16_t target_buffer_get_u16(struct target
*target
, const uint8_t *buffer
);
748 void target_buffer_set_u64(struct target
*target
, uint8_t *buffer
, uint64_t value
);
749 void target_buffer_set_u32(struct target
*target
, uint8_t *buffer
, uint32_t value
);
750 void target_buffer_set_u24(struct target
*target
, uint8_t *buffer
, uint32_t value
);
751 void target_buffer_set_u16(struct target
*target
, uint8_t *buffer
, uint16_t value
);
753 void target_buffer_get_u64_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint64_t *dstbuf
);
754 void target_buffer_get_u32_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint32_t *dstbuf
);
755 void target_buffer_get_u16_array(struct target
*target
, const uint8_t *buffer
, uint32_t count
, uint16_t *dstbuf
);
756 void target_buffer_set_u64_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint64_t *srcbuf
);
757 void target_buffer_set_u32_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint32_t *srcbuf
);
758 void target_buffer_set_u16_array(struct target
*target
, uint8_t *buffer
, uint32_t count
, const uint16_t *srcbuf
);
760 int target_read_u64(struct target
*target
, target_addr_t address
, uint64_t *value
);
761 int target_read_u32(struct target
*target
, target_addr_t address
, uint32_t *value
);
762 int target_read_u16(struct target
*target
, target_addr_t address
, uint16_t *value
);
763 int target_read_u8(struct target
*target
, target_addr_t address
, uint8_t *value
);
764 int target_write_u64(struct target
*target
, target_addr_t address
, uint64_t value
);
765 int target_write_u32(struct target
*target
, target_addr_t address
, uint32_t value
);
766 int target_write_u16(struct target
*target
, target_addr_t address
, uint16_t value
);
767 int target_write_u8(struct target
*target
, target_addr_t address
, uint8_t value
);
769 int target_write_phys_u64(struct target
*target
, target_addr_t address
, uint64_t value
);
770 int target_write_phys_u32(struct target
*target
, target_addr_t address
, uint32_t value
);
771 int target_write_phys_u16(struct target
*target
, target_addr_t address
, uint16_t value
);
772 int target_write_phys_u8(struct target
*target
, target_addr_t address
, uint8_t value
);
774 /* Issues USER() statements with target state information */
775 int target_arch_state(struct target
*target
);
777 void target_handle_event(struct target
*t
, enum target_event e
);
779 void target_handle_md_output(struct command_invocation
*cmd
,
780 struct target
*target
, target_addr_t address
, unsigned size
,
781 unsigned count
, const uint8_t *buffer
);
783 int target_profiling_default(struct target
*target
, uint32_t *samples
, uint32_t
784 max_num_samples
, uint32_t *num_samples
, uint32_t seconds
);
786 #define ERROR_TARGET_INVALID (-300)
787 #define ERROR_TARGET_INIT_FAILED (-301)
788 #define ERROR_TARGET_TIMEOUT (-302)
789 #define ERROR_TARGET_NOT_HALTED (-304)
790 #define ERROR_TARGET_FAILURE (-305)
791 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
792 #define ERROR_TARGET_DATA_ABORT (-307)
793 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
794 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
795 #define ERROR_TARGET_NOT_RUNNING (-310)
796 #define ERROR_TARGET_NOT_EXAMINED (-311)
797 #define ERROR_TARGET_DUPLICATE_BREAKPOINT (-312)
798 #define ERROR_TARGET_ALGO_EXIT (-313)
799 #define ERROR_TARGET_SIZE_NOT_SUPPORTED (-314)
800 #define ERROR_TARGET_PACKING_NOT_SUPPORTED (-315)
802 extern bool get_target_reset_nag(void);
804 #define TARGET_DEFAULT_POLLING_INTERVAL 100
806 const char *target_debug_reason_str(enum target_debug_reason reason
);
808 #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)