51fb299cf66ef444dbaadf350e910f0810b533c2
[openocd.git] / src / target / target.h
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008,2009 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26 #ifndef TARGET_H
27 #define TARGET_H
28
29 #include <stddef.h>
30 #include "types.h"
31 #include "jim.h"
32
33 struct reg;
34 struct trace;
35 struct command_context;
36 struct breakpoint;
37 struct watchpoint;
38 struct mem_param;
39 struct reg_param;
40
41
42 /**
43 * Cast a member of a structure out to the containing structure.
44 * @param ptr The pointer to the member.
45 * @param type The type of the container struct this is embedded in.
46 * @param member The name of the member within the struct.
47 *
48 * This is a mechanism which is used throughout the Linux kernel.
49 */
50 #define container_of(ptr, type, member) ({ \
51 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
52 (type *)( (char *)__mptr - offsetof(type,member) );})
53
54 /*
55 * TARGET_UNKNOWN = 0: we don't know anything about the target yet
56 * TARGET_RUNNING = 1: the target is executing user code
57 * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
58 * debugger. on an xscale it means that the debug handler is executing
59 * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
60 * not sure how this is used with all the recent changes)
61 * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
62 * behalf of the debugger (e.g. algorithm for flashing)
63 *
64 * also see: target_state_name();
65 */
66
67
68 enum target_state
69 {
70 TARGET_UNKNOWN = 0,
71 TARGET_RUNNING = 1,
72 TARGET_HALTED = 2,
73 TARGET_RESET = 3,
74 TARGET_DEBUG_RUNNING = 4,
75 };
76
77 extern const Jim_Nvp nvp_target_state[];
78
79 enum nvp_assert {
80 NVP_DEASSERT,
81 NVP_ASSERT,
82 };
83
84 extern const Jim_Nvp nvp_assert[];
85
86 enum target_reset_mode
87 {
88 RESET_UNKNOWN = 0,
89 RESET_RUN = 1, /* reset and let target run */
90 RESET_HALT = 2, /* reset and halt target out of reset */
91 RESET_INIT = 3, /* reset and halt target out of reset, then run init script */
92 };
93
94 extern const Jim_Nvp nvp_reset_mode[];
95
96 enum target_debug_reason
97 {
98 DBG_REASON_DBGRQ = 0,
99 DBG_REASON_BREAKPOINT = 1,
100 DBG_REASON_WATCHPOINT = 2,
101 DBG_REASON_WPTANDBKPT = 3,
102 DBG_REASON_SINGLESTEP = 4,
103 DBG_REASON_NOTHALTED = 5,
104 DBG_REASON_UNDEFINED = 6
105 };
106
107 extern const Jim_Nvp nvp_target_debug_reason[];
108
109 enum target_endianess
110 {
111 TARGET_ENDIAN_UNKNOWN = 0,
112 TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
113 };
114
115 extern const Jim_Nvp nvp_target_endian[];
116
117 struct working_area
118 {
119 uint32_t address;
120 uint32_t size;
121 int free;
122 uint8_t *backup;
123 struct working_area **user;
124 struct working_area *next;
125 };
126
127 // target_type.h contains the full definitionof struct targe_type
128 struct target
129 {
130 struct target_type *type; /* target type definition (name, access functions) */
131 const char *cmd_name; /* tcl Name of target */
132 int target_number; /* DO NOT USE! field to be removed in 2010 */
133 struct jtag_tap *tap; /* where on the jtag chain is this */
134 const char *variant; /* what variant of this chip is it? */
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 struct target_event_action *event_action;
145
146 int reset_halt; /* attempt resetting the CPU into the halted mode? */
147 uint32_t working_area; /* working area (initialized RAM). Evaluated
148 * upon first allocation from virtual/physical address. */
149 bool working_area_virt_spec; /* virtual address specified? */
150 uint32_t working_area_virt; /* virtual address */
151 bool working_area_phys_spec; /* virtual address specified? */
152 uint32_t working_area_phys; /* physical address */
153 uint32_t working_area_size; /* size in bytes */
154 uint32_t backup_working_area; /* whether the content of the working area has to be preserved */
155 struct working_area *working_areas;/* list of allocated working areas */
156 enum target_debug_reason debug_reason;/* reason why the target entered debug state */
157 enum target_endianess endianness; /* target endianess */
158 // also see: target_state_name()
159 enum target_state state; /* the current backend-state (running, halted, ...) */
160 struct reg_cache *reg_cache; /* the first register cache of the target (core regs) */
161 struct breakpoint *breakpoints; /* list of breakpoints */
162 struct watchpoint *watchpoints; /* list of watchpoints */
163 struct trace *trace_info; /* generic trace information */
164 struct debug_msg_receiver *dbgmsg;/* list of debug message receivers */
165 uint32_t dbg_msg_enabled; /* debug message status */
166 void *arch_info; /* architecture specific information */
167 struct target *next; /* next target in list */
168
169 int display; /* display async info in telnet session. Do not display
170 * lots of halted/resumed info when stepping in debugger. */
171 bool halt_issued; /* did we transition to halted state? */
172 long long halt_issued_time; /* Note time when halt was issued */
173 };
174
175 enum target_event
176 {
177 /* LD historical names
178 * - Prior to the great TCL change
179 * - June/July/Aug 2008
180 * - Duane Ellis */
181 TARGET_EVENT_OLD_gdb_program_config,
182 TARGET_EVENT_OLD_pre_reset,
183 TARGET_EVENT_OLD_post_reset,
184 TARGET_EVENT_OLD_pre_resume,
185
186 /* allow GDB to do stuff before others handle the halted event,
187 * this is in lieu of defining ordering of invocation of events,
188 * which would be more complicated
189 *
190 * Telling GDB to halt does not mean that the target stopped running,
191 * simply that we're dropping out of GDB's waiting for step or continue.
192 *
193 * This can be useful when e.g. detecting power dropout.
194 */
195 TARGET_EVENT_GDB_HALT,
196 TARGET_EVENT_HALTED, /* target entered debug state from normal execution or reset */
197 TARGET_EVENT_RESUMED, /* target resumed to normal execution */
198 TARGET_EVENT_RESUME_START,
199 TARGET_EVENT_RESUME_END,
200
201 TARGET_EVENT_GDB_START, /* debugger started execution (step/run) */
202 TARGET_EVENT_GDB_END, /* debugger stopped execution (step/run) */
203
204 TARGET_EVENT_RESET_START,
205 TARGET_EVENT_RESET_ASSERT_PRE,
206 TARGET_EVENT_RESET_ASSERT_POST,
207 TARGET_EVENT_RESET_DEASSERT_PRE,
208 TARGET_EVENT_RESET_DEASSERT_POST,
209 TARGET_EVENT_RESET_HALT_PRE,
210 TARGET_EVENT_RESET_HALT_POST,
211 TARGET_EVENT_RESET_WAIT_PRE,
212 TARGET_EVENT_RESET_WAIT_POST,
213 TARGET_EVENT_RESET_INIT,
214 TARGET_EVENT_RESET_END,
215
216 TARGET_EVENT_DEBUG_HALTED, /* target entered debug state, but was executing on behalf of the debugger */
217 TARGET_EVENT_DEBUG_RESUMED, /* target resumed to execute on behalf of the debugger */
218
219 TARGET_EVENT_EXAMINE_START,
220 TARGET_EVENT_EXAMINE_END,
221
222 TARGET_EVENT_GDB_ATTACH,
223 TARGET_EVENT_GDB_DETACH,
224
225 TARGET_EVENT_GDB_FLASH_ERASE_START,
226 TARGET_EVENT_GDB_FLASH_ERASE_END,
227 TARGET_EVENT_GDB_FLASH_WRITE_START,
228 TARGET_EVENT_GDB_FLASH_WRITE_END,
229 };
230
231 struct target_event_action {
232 enum target_event event;
233 struct Jim_Obj *body;
234 int has_percent;
235 struct target_event_action *next;
236 };
237
238 struct target_event_callback
239 {
240 int (*callback)(struct target *target, enum target_event event, void *priv);
241 void *priv;
242 struct target_event_callback *next;
243 };
244
245 struct target_timer_callback
246 {
247 int (*callback)(void *priv);
248 int time_ms;
249 int periodic;
250 struct timeval when;
251 void *priv;
252 struct target_timer_callback *next;
253 };
254
255 int target_register_commands(struct command_context *cmd_ctx);
256 int target_register_user_commands(struct command_context *cmd_ctx);
257 int target_init(struct command_context *cmd_ctx);
258 int target_examine(void);
259 int handle_target(void *priv);
260 int target_process_reset(struct command_context *cmd_ctx,
261 enum target_reset_mode reset_mode);
262
263 int target_register_event_callback(
264 int (*callback)(struct target *target,
265 enum target_event event, void *priv),
266 void *priv);
267 int target_unregister_event_callback(
268 int (*callback)(struct target *target,
269 enum target_event event, void *priv),
270 void *priv);
271 int target_poll(struct target *target);
272 int target_resume(struct target *target, int current, uint32_t address,
273 int handle_breakpoints, int debug_execution);
274 int target_halt(struct target *target);
275 int target_call_event_callbacks(struct target *target, enum target_event event);
276
277 /**
278 * The period is very approximate, the callback can happen much more often
279 * or much more rarely than specified
280 */
281 int target_register_timer_callback(int (*callback)(void *priv),
282 int time_ms, int periodic, void *priv);
283 int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
284
285 int target_call_timer_callbacks(void);
286 /**
287 * Invoke this to ensure that e.g. polling timer callbacks happen before
288 * a syncrhonous command completes.
289 */
290 int target_call_timer_callbacks_now(void);
291
292 struct target* get_current_target(struct command_context *cmd_ctx);
293 struct target *get_target(const char *id);
294
295 /**
296 * Get the target name.
297 *
298 * This routine is a wrapper for the target->type->name field.
299 */
300 const char *target_get_name(struct target *target);
301
302 /**
303 * Examine the specified @a target, letting it perform any
304 * initialization that requires JTAG access.
305 *
306 * This routine is a wrapper for target->type->examine.
307 */
308 int target_examine_one(struct target *target);
309
310 /// @returns @c true if target_set_examined() has been called.
311 static inline bool target_was_examined(struct target *target)
312 {
313 return target->examined;
314 }
315
316 /// Sets the @c examined flag for the given target.
317 /// Use in target->type->examine() after one-time setup is done.
318 static inline void target_set_examined(struct target *target)
319 {
320 target->examined = true;
321 }
322
323 /**
324 * Add the @a breakpoint for @a target.
325 *
326 * This routine is a wrapper for target->type->add_breakpoint.
327 */
328 int target_add_breakpoint(struct target *target,
329 struct breakpoint *breakpoint);
330 /**
331 * Remove the @a breakpoint for @a target.
332 *
333 * This routine is a wrapper for target->type->remove_breakpoint.
334 */
335 int target_remove_breakpoint(struct target *target,
336 struct breakpoint *breakpoint);
337 /**
338 * Add the @a watchpoint for @a target.
339 *
340 * This routine is a wrapper for target->type->add_watchpoint.
341 */
342 int target_add_watchpoint(struct target *target,
343 struct watchpoint *watchpoint);
344 /**
345 * Remove the @a watchpoint for @a target.
346 *
347 * This routine is a wrapper for target->type->remove_watchpoint.
348 */
349 int target_remove_watchpoint(struct target *target,
350 struct watchpoint *watchpoint);
351
352 /**
353 * Obtain the registers for GDB.
354 *
355 * This routine is a wrapper for target->type->get_gdb_reg_list.
356 */
357 int target_get_gdb_reg_list(struct target *target,
358 struct reg **reg_list[], int *reg_list_size);
359
360 /**
361 * Step the target.
362 *
363 * This routine is a wrapper for target->type->step.
364 */
365 int target_step(struct target *target,
366 int current, uint32_t address, int handle_breakpoints);
367 /**
368 * Run an algorithm on the @a target given.
369 *
370 * This routine is a wrapper for target->type->run_algorithm.
371 */
372 int target_run_algorithm(struct target *target,
373 int num_mem_params, struct mem_param *mem_params,
374 int num_reg_params, struct reg_param *reg_param,
375 uint32_t entry_point, uint32_t exit_point,
376 int timeout_ms, void *arch_info);
377
378 /**
379 * Read @a count items of @a size bytes from the memory of @a target at
380 * the @a address given.
381 *
382 * This routine is a wrapper for target->type->read_memory.
383 */
384 int target_read_memory(struct target *target,
385 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
386 /**
387 * Write @a count items of @a size bytes to the memory of @a target at
388 * the @a address given.
389 *
390 * This routine is wrapper for target->type->write_memory.
391 */
392 int target_write_memory(struct target *target,
393 uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
394
395 /**
396 * Write @a count items of 4 bytes to the memory of @a target at
397 * the @a address given. Because it operates only on whole words,
398 * this should be faster than target_write_memory().
399 *
400 * This routine is wrapper for target->type->bulk_write_memory.
401 */
402 int target_bulk_write_memory(struct target *target,
403 uint32_t address, uint32_t count, uint8_t *buffer);
404
405 /*
406 * Write to target memory using the virtual address.
407 *
408 * Note that this fn is used to implement software breakpoints. Targets
409 * can implement support for software breakpoints to memory marked as read
410 * only by making this fn write to ram even if it is read only(MMU or
411 * MPUs).
412 *
413 * It is sufficient to implement for writing a single word(16 or 32 in
414 * ARM32/16 bit case) to write the breakpoint to ram.
415 *
416 * The target should also take care of "other things" to make sure that
417 * software breakpoints can be written using this function. E.g.
418 * when there is a separate instruction and data cache, this fn must
419 * make sure that the instruction cache is synced up to the potential
420 * code change that can happen as a result of the memory write(typically
421 * by invalidating the cache).
422 *
423 * The high level wrapper fn in target.c will break down this memory write
424 * request to multiple write requests to the target driver to e.g. guarantee
425 * that writing 4 bytes to an aligned address happens with a single 32 bit
426 * write operation, thus making this fn suitable to e.g. write to special
427 * peripheral registers which do not support byte operations.
428 */
429 int target_write_buffer(struct target *target,
430 uint32_t address, uint32_t size, uint8_t *buffer);
431 int target_read_buffer(struct target *target,
432 uint32_t address, uint32_t size, uint8_t *buffer);
433 int target_checksum_memory(struct target *target,
434 uint32_t address, uint32_t size, uint32_t* crc);
435 int target_blank_check_memory(struct target *target,
436 uint32_t address, uint32_t size, uint32_t* blank);
437 int target_wait_state(struct target *target, enum target_state state, int ms);
438
439 /** Return the *name* of this targets current state */
440 const char *target_state_name( struct target *target );
441
442 /* DANGER!!!!!
443 *
444 * if "area" passed in to target_alloc_working_area() points to a memory
445 * location that goes out of scope (e.g. a pointer on the stack), then
446 * the caller of target_alloc_working_area() is responsible for invoking
447 * target_free_working_area() before "area" goes out of scope.
448 *
449 * target_free_all_working_areas() will NULL out the "area" pointer
450 * upon resuming or resetting the CPU.
451 *
452 */
453 int target_alloc_working_area(struct target *target,
454 uint32_t size, struct working_area **area);
455 int target_free_working_area(struct target *target, struct working_area *area);
456 int target_free_working_area_restore(struct target *target,
457 struct working_area *area, int restore);
458 void target_free_all_working_areas(struct target *target);
459 void target_free_all_working_areas_restore(struct target *target, int restore);
460
461 extern struct target *all_targets;
462
463 extern struct target_event_callback *target_event_callbacks;
464 extern struct target_timer_callback *target_timer_callbacks;
465
466 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer);
467 uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer);
468 uint8_t target_buffer_get_u8 (struct target *target, const uint8_t *buffer);
469 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value);
470 void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value);
471 void target_buffer_set_u8 (struct target *target, uint8_t *buffer, uint8_t value);
472
473 int target_read_u32(struct target *target, uint32_t address, uint32_t *value);
474 int target_read_u16(struct target *target, uint32_t address, uint16_t *value);
475 int target_read_u8(struct target *target, uint32_t address, uint8_t *value);
476 int target_write_u32(struct target *target, uint32_t address, uint32_t value);
477 int target_write_u16(struct target *target, uint32_t address, uint16_t value);
478 int target_write_u8(struct target *target, uint32_t address, uint8_t value);
479
480 /* Issues USER() statements with target state information */
481 int target_arch_state(struct target *target);
482
483 void target_handle_event(struct target *t, enum target_event e);
484 void target_all_handle_event(enum target_event e);
485
486 #define ERROR_TARGET_INVALID (-300)
487 #define ERROR_TARGET_INIT_FAILED (-301)
488 #define ERROR_TARGET_TIMEOUT (-302)
489 #define ERROR_TARGET_NOT_HALTED (-304)
490 #define ERROR_TARGET_FAILURE (-305)
491 #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
492 #define ERROR_TARGET_DATA_ABORT (-307)
493 #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
494 #define ERROR_TARGET_TRANSLATION_FAULT (-309)
495 #define ERROR_TARGET_NOT_RUNNING (-310)
496 #define ERROR_TARGET_NOT_EXAMINED (-311)
497
498 extern const Jim_Nvp nvp_error_target[];
499
500 const char *target_strerror_safe(int err);
501
502 #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)