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 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
32 #include <helper/types.h>
36 struct command_context
;
44 * TARGET_UNKNOWN = 0: we don't know anything about the target yet
45 * TARGET_RUNNING = 1: the target is executing user code
46 * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
47 * debugger. on an xscale it means that the debug handler is executing
48 * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
49 * not sure how this is used with all the recent changes)
50 * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
51 * behalf of the debugger (e.g. algorithm for flashing)
53 * also see: target_state_name();
63 TARGET_DEBUG_RUNNING
= 4,
71 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
82 DBG_REASON_BREAKPOINT
= 1,
83 DBG_REASON_WATCHPOINT
= 2,
84 DBG_REASON_WPTANDBKPT
= 3,
85 DBG_REASON_SINGLESTEP
= 4,
86 DBG_REASON_NOTHALTED
= 5,
87 DBG_REASON_UNDEFINED
= 6
90 enum target_endianness
92 TARGET_ENDIAN_UNKNOWN
= 0,
93 TARGET_BIG_ENDIAN
= 1, TARGET_LITTLE_ENDIAN
= 2
102 struct working_area
**user
;
103 struct working_area
*next
;
106 // target_type.h contains the full definitionof struct targe_type
109 struct target_type
*type
; /* target type definition (name, access functions) */
110 const char *cmd_name
; /* tcl Name of target */
111 int target_number
; /* DO NOT USE! field to be removed in 2010 */
112 struct jtag_tap
*tap
; /* where on the jtag chain is this */
113 int coreid
; /* which device on the TAP? */
114 const char *variant
; /* what variant of this chip is it? */
117 * Indicates whether this target has been examined.
119 * Do @b not access this field directly, use target_was_examined()
120 * or target_set_examined().
124 /** true iff the target is currently running a downloaded
125 * "algorithm" instetad of arbitrary user code. OpenOCD code
126 * invoking algorithms is trusted to maintain correctness of
127 * any cached state (e.g. for flash status), which arbitrary
128 * code will have no reason to know about.
132 struct target_event_action
*event_action
;
134 int reset_halt
; /* attempt resetting the CPU into the halted mode? */
135 uint32_t working_area
; /* working area (initialized RAM). Evaluated
136 * upon first allocation from virtual/physical address. */
137 bool working_area_virt_spec
; /* virtual address specified? */
138 uint32_t working_area_virt
; /* virtual address */
139 bool working_area_phys_spec
; /* virtual address specified? */
140 uint32_t working_area_phys
; /* physical address */
141 uint32_t working_area_size
; /* size in bytes */
142 uint32_t backup_working_area
; /* whether the content of the working area has to be preserved */
143 struct working_area
*working_areas
;/* list of allocated working areas */
144 enum target_debug_reason debug_reason
;/* reason why the target entered debug state */
145 enum target_endianness endianness
; /* target endianness */
146 // also see: target_state_name()
147 enum target_state state
; /* the current backend-state (running, halted, ...) */
148 struct reg_cache
*reg_cache
; /* the first register cache of the target (core regs) */
149 struct breakpoint
*breakpoints
; /* list of breakpoints */
150 struct watchpoint
*watchpoints
; /* list of watchpoints */
151 struct trace
*trace_info
; /* generic trace information */
152 struct debug_msg_receiver
*dbgmsg
;/* list of debug message receivers */
153 uint32_t dbg_msg_enabled
; /* debug message status */
154 void *arch_info
; /* architecture specific information */
155 struct target
*next
; /* next target in list */
157 int display
; /* display async info in telnet session. Do not display
158 * lots of halted/resumed info when stepping in debugger. */
159 bool halt_issued
; /* did we transition to halted state? */
160 long long halt_issued_time
; /* Note time when halt was issued */
162 bool dbgbase_set
; /* By default the debug base is not set */
163 uint32_t dbgbase
; /* Really a Cortex-A specific option, but there is no
164 system in place to support target specific options
166 struct rtos
*rtos
; /* Instance of Real Time Operating System support */
167 bool rtos_auto_detect
; /* A flag that indicates that the RTOS has been specified as "auto"
168 * and must be detected when symbols are offered */
171 /** Returns the instance-specific name of the specified target. */
172 static inline const char *target_name(struct target
*target
)
174 return target
->cmd_name
;
177 const char *debug_reason_name(struct target
*t
);
181 /* LD historical names
182 * - Prior to the great TCL change
183 * - June/July/Aug 2008
185 TARGET_EVENT_OLD_gdb_program_config
,
186 TARGET_EVENT_OLD_pre_resume
,
188 /* allow GDB to do stuff before others handle the halted event,
189 * this is in lieu of defining ordering of invocation of events,
190 * which would be more complicated
192 * Telling GDB to halt does not mean that the target stopped running,
193 * simply that we're dropping out of GDB's waiting for step or continue.
195 * This can be useful when e.g. detecting power dropout.
197 TARGET_EVENT_GDB_HALT
,
198 TARGET_EVENT_HALTED
, /* target entered debug state from normal execution or reset */
199 TARGET_EVENT_RESUMED
, /* target resumed to normal execution */
200 TARGET_EVENT_RESUME_START
,
201 TARGET_EVENT_RESUME_END
,
203 TARGET_EVENT_GDB_START
, /* debugger started execution (step/run) */
204 TARGET_EVENT_GDB_END
, /* debugger stopped execution (step/run) */
206 TARGET_EVENT_RESET_START
,
207 TARGET_EVENT_RESET_ASSERT_PRE
,
208 TARGET_EVENT_RESET_ASSERT
, /* C code uses this instead of SRST */
209 TARGET_EVENT_RESET_ASSERT_POST
,
210 TARGET_EVENT_RESET_DEASSERT_PRE
,
211 TARGET_EVENT_RESET_DEASSERT_POST
,
212 TARGET_EVENT_RESET_HALT_PRE
,
213 TARGET_EVENT_RESET_HALT_POST
,
214 TARGET_EVENT_RESET_WAIT_PRE
,
215 TARGET_EVENT_RESET_WAIT_POST
,
216 TARGET_EVENT_RESET_INIT
,
217 TARGET_EVENT_RESET_END
,
219 TARGET_EVENT_DEBUG_HALTED
, /* target entered debug state, but was executing on behalf of the debugger */
220 TARGET_EVENT_DEBUG_RESUMED
, /* target resumed to execute on behalf of the debugger */
222 TARGET_EVENT_EXAMINE_START
,
223 TARGET_EVENT_EXAMINE_END
,
225 TARGET_EVENT_GDB_ATTACH
,
226 TARGET_EVENT_GDB_DETACH
,
228 TARGET_EVENT_GDB_FLASH_ERASE_START
,
229 TARGET_EVENT_GDB_FLASH_ERASE_END
,
230 TARGET_EVENT_GDB_FLASH_WRITE_START
,
231 TARGET_EVENT_GDB_FLASH_WRITE_END
,
234 struct target_event_action
{
235 enum target_event event
;
236 struct Jim_Interp
*interp
;
237 struct Jim_Obj
*body
;
239 struct target_event_action
*next
;
242 bool target_has_event_action(struct target
*target
, enum target_event event
);
244 struct target_event_callback
246 int (*callback
)(struct target
*target
, enum target_event event
, void *priv
);
248 struct target_event_callback
*next
;
251 struct target_timer_callback
253 int (*callback
)(void *priv
);
258 struct target_timer_callback
*next
;
261 int target_register_commands(struct command_context
*cmd_ctx
);
262 int target_examine(void);
264 int target_register_event_callback(
265 int (*callback
)(struct target
*target
,
266 enum target_event event
, void *priv
),
268 int target_unregister_event_callback(
269 int (*callback
)(struct target
*target
,
270 enum target_event event
, void *priv
),
272 /* Poll the status of the target, detect any error conditions and report them.
274 * Also note that this fn will clear such error conditions, so a subsequent
275 * invocation will then succeed.
277 * These error conditions can be "sticky" error conditions. E.g. writing
278 * to memory could be implemented as an open loop and if memory writes
279 * fails, then a note is made of it, the error is sticky, but the memory
280 * write loop still runs to completion. This improves performance in the
281 * normal case as there is no need to verify that every single write succeed,
282 * yet it is possible to detect error condtions.
284 int target_poll(struct target
*target
);
285 int target_resume(struct target
*target
, int current
, uint32_t address
,
286 int handle_breakpoints
, int debug_execution
);
287 int target_halt(struct target
*target
);
288 int target_call_event_callbacks(struct target
*target
, enum target_event event
);
291 * The period is very approximate, the callback can happen much more often
292 * or much more rarely than specified
294 int target_register_timer_callback(int (*callback
)(void *priv
),
295 int time_ms
, int periodic
, void *priv
);
297 int target_call_timer_callbacks(void);
299 * Invoke this to ensure that e.g. polling timer callbacks happen before
300 * a syncrhonous command completes.
302 int target_call_timer_callbacks_now(void);
304 struct target
* get_current_target(struct command_context
*cmd_ctx
);
305 struct target
*get_target(const char *id
);
308 * Get the target type name.
310 * This routine is a wrapper for the target->type->name field.
311 * Note that this is not an instance-specific name for his target.
313 const char *target_type_name(struct target
*target
);
316 * Examine the specified @a target, letting it perform any
317 * initialization that requires JTAG access.
319 * This routine is a wrapper for target->type->examine.
321 int target_examine_one(struct target
*target
);
323 /// @returns @c true if target_set_examined() has been called.
324 static inline bool target_was_examined(struct target
*target
)
326 return target
->examined
;
329 /// Sets the @c examined flag for the given target.
330 /// Use in target->type->examine() after one-time setup is done.
331 static inline void target_set_examined(struct target
*target
)
333 target
->examined
= true;
337 * Add the @a breakpoint for @a target.
339 * This routine is a wrapper for target->type->add_breakpoint.
341 int target_add_breakpoint(struct target
*target
,
342 struct breakpoint
*breakpoint
);
344 * Remove the @a breakpoint for @a target.
346 * This routine is a wrapper for target->type->remove_breakpoint.
348 int target_remove_breakpoint(struct target
*target
,
349 struct breakpoint
*breakpoint
);
351 * Add the @a watchpoint for @a target.
353 * This routine is a wrapper for target->type->add_watchpoint.
355 int target_add_watchpoint(struct target
*target
,
356 struct watchpoint
*watchpoint
);
358 * Remove the @a watchpoint for @a target.
360 * This routine is a wrapper for target->type->remove_watchpoint.
362 int target_remove_watchpoint(struct target
*target
,
363 struct watchpoint
*watchpoint
);
366 * Obtain the registers for GDB.
368 * This routine is a wrapper for target->type->get_gdb_reg_list.
370 int target_get_gdb_reg_list(struct target
*target
,
371 struct reg
**reg_list
[], int *reg_list_size
);
376 * This routine is a wrapper for target->type->step.
378 int target_step(struct target
*target
,
379 int current
, uint32_t address
, int handle_breakpoints
);
381 * Run an algorithm on the @a target given.
383 * This routine is a wrapper for target->type->run_algorithm.
385 int target_run_algorithm(struct target
*target
,
386 int num_mem_params
, struct mem_param
*mem_params
,
387 int num_reg_params
, struct reg_param
*reg_param
,
388 uint32_t entry_point
, uint32_t exit_point
,
389 int timeout_ms
, void *arch_info
);
392 * Read @a count items of @a size bytes from the memory of @a target at
393 * the @a address given.
395 * This routine is a wrapper for target->type->read_memory.
397 int target_read_memory(struct target
*target
,
398 uint32_t address
, uint32_t size
, uint32_t count
, uint8_t *buffer
);
400 * Write @a count items of @a size bytes to the memory of @a target at
401 * the @a address given. @a address must be aligned to @a size
404 * The endianness is the same in the host and target memory for this
408 * Really @a buffer should have been defined as "const void *" and
409 * @a buffer should have been aligned to @a size in the host memory.
411 * This is not enforced via e.g. assert's today and e.g. the
412 * target_write_buffer fn breaks this assumption.
414 * This routine is wrapper for target->type->write_memory.
416 int target_write_memory(struct target
*target
,
417 uint32_t address
, uint32_t size
, uint32_t count
, const uint8_t *buffer
);
420 * Write @a count items of 4 bytes to the memory of @a target at
421 * the @a address given. Because it operates only on whole words,
422 * this should be faster than target_write_memory().
424 * This routine is wrapper for target->type->bulk_write_memory.
426 int target_bulk_write_memory(struct target
*target
,
427 uint32_t address
, uint32_t count
, const uint8_t *buffer
);
430 * Write to target memory using the virtual address.
432 * Note that this fn is used to implement software breakpoints. Targets
433 * can implement support for software breakpoints to memory marked as read
434 * only by making this fn write to ram even if it is read only(MMU or
437 * It is sufficient to implement for writing a single word(16 or 32 in
438 * ARM32/16 bit case) to write the breakpoint to ram.
440 * The target should also take care of "other things" to make sure that
441 * software breakpoints can be written using this function. E.g.
442 * when there is a separate instruction and data cache, this fn must
443 * make sure that the instruction cache is synced up to the potential
444 * code change that can happen as a result of the memory write(typically
445 * by invalidating the cache).
447 * The high level wrapper fn in target.c will break down this memory write
448 * request to multiple write requests to the target driver to e.g. guarantee
449 * that writing 4 bytes to an aligned address happens with a single 32 bit
450 * write operation, thus making this fn suitable to e.g. write to special
451 * peripheral registers which do not support byte operations.
453 int target_write_buffer(struct target
*target
,
454 uint32_t address
, uint32_t size
, const uint8_t *buffer
);
455 int target_read_buffer(struct target
*target
,
456 uint32_t address
, uint32_t size
, uint8_t *buffer
);
457 int target_checksum_memory(struct target
*target
,
458 uint32_t address
, uint32_t size
, uint32_t* crc
);
459 int target_blank_check_memory(struct target
*target
,
460 uint32_t address
, uint32_t size
, uint32_t* blank
);
461 int target_wait_state(struct target
*target
, enum target_state state
, int ms
);
463 /** Return the *name* of this targets current state */
464 const char *target_state_name( struct target
*target
);
468 * if "area" passed in to target_alloc_working_area() points to a memory
469 * location that goes out of scope (e.g. a pointer on the stack), then
470 * the caller of target_alloc_working_area() is responsible for invoking
471 * target_free_working_area() before "area" goes out of scope.
473 * target_free_all_working_areas() will NULL out the "area" pointer
474 * upon resuming or resetting the CPU.
477 int target_alloc_working_area(struct target
*target
,
478 uint32_t size
, struct working_area
**area
);
479 /* Same as target_alloc_working_area, except that no error is logged
480 * when ERROR_TARGET_RESOURCE_NOT_AVAILABLE is returned.
482 * This allows the calling code to *try* to allocate target memory
483 * and have a fallback to another behavior(slower?).
485 int target_alloc_working_area_try(struct target
*target
,
486 uint32_t size
, struct working_area
**area
);
487 int target_free_working_area(struct target
*target
, struct working_area
*area
);
488 void target_free_all_working_areas(struct target
*target
);
490 extern struct target
*all_targets
;
492 uint32_t target_buffer_get_u32(struct target
*target
, const uint8_t *buffer
);
493 uint32_t target_buffer_get_u24(struct target
*target
, const uint8_t *buffer
);
494 uint16_t target_buffer_get_u16(struct target
*target
, const uint8_t *buffer
);
495 void target_buffer_set_u32(struct target
*target
, uint8_t *buffer
, uint32_t value
);
496 void target_buffer_set_u24(struct target
*target
, uint8_t *buffer
, uint32_t value
);
497 void target_buffer_set_u16(struct target
*target
, uint8_t *buffer
, uint16_t value
);
499 int target_read_u32(struct target
*target
, uint32_t address
, uint32_t *value
);
500 int target_read_u16(struct target
*target
, uint32_t address
, uint16_t *value
);
501 int target_read_u8(struct target
*target
, uint32_t address
, uint8_t *value
);
502 int target_write_u32(struct target
*target
, uint32_t address
, uint32_t value
);
503 int target_write_u16(struct target
*target
, uint32_t address
, uint16_t value
);
504 int target_write_u8(struct target
*target
, uint32_t address
, uint8_t value
);
506 /* Issues USER() statements with target state information */
507 int target_arch_state(struct target
*target
);
509 void target_handle_event(struct target
*t
, enum target_event e
);
511 #define ERROR_TARGET_INVALID (-300)
512 #define ERROR_TARGET_INIT_FAILED (-301)
513 #define ERROR_TARGET_TIMEOUT (-302)
514 #define ERROR_TARGET_NOT_HALTED (-304)
515 #define ERROR_TARGET_FAILURE (-305)
516 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
517 #define ERROR_TARGET_DATA_ABORT (-307)
518 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
519 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
520 #define ERROR_TARGET_NOT_RUNNING (-310)
521 #define ERROR_TARGET_NOT_EXAMINED (-311)
523 extern bool get_target_reset_nag(void);
525 #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)