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