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