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