target: Remove read_memory_imp
[openocd.git] / src / target / target_type.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 * 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
27 #ifndef TARGET_TYPE_H
28 #define TARGET_TYPE_H
29
30 #include <jim-nvp.h>
31
32 struct target;
33
34 /**
35 * This holds methods shared between all instances of a given target
36 * type. For example, all Cortex-M3 targets on a scan chain share
37 * the same method table.
38 */
39 struct target_type {
40 /**
41 * Name of this type of target. Do @b not access this
42 * field directly, use target_type_name() instead.
43 */
44 const char *name;
45 const char *deprecated_name;
46
47 /* poll current target status */
48 int (*poll)(struct target *target);
49 /* Invoked only from target_arch_state().
50 * Issue USER() w/architecture specific status. */
51 int (*arch_state)(struct target *target);
52
53 /* target request support */
54 int (*target_request_data)(struct target *target, uint32_t size, uint8_t *buffer);
55
56 /* halt will log a warning, but return ERROR_OK if the target is already halted. */
57 int (*halt)(struct target *target);
58 int (*resume)(struct target *target, int current, uint32_t address,
59 int handle_breakpoints, int debug_execution);
60 int (*step)(struct target *target, int current, uint32_t address,
61 int handle_breakpoints);
62
63 /* target reset control. assert reset can be invoked when OpenOCD and
64 * the target is out of sync.
65 *
66 * A typical example is that the target was power cycled while OpenOCD
67 * thought the target was halted or running.
68 *
69 * assert_reset() can therefore make no assumptions whatsoever about the
70 * state of the target
71 *
72 * Before assert_reset() for the target is invoked, a TRST/tms and
73 * chain validation is executed. TRST should not be asserted
74 * during target assert unless there is no way around it due to
75 * the way reset's are configured.
76 *
77 */
78 int (*assert_reset)(struct target *target);
79 /**
80 * The implementation is responsible for polling the
81 * target such that target->state reflects the
82 * state correctly.
83 *
84 * Otherwise the following would fail, as there will not
85 * be any "poll" invoked inbetween the "reset run" and
86 * "halt".
87 *
88 * reset run; halt
89 */
90 int (*deassert_reset)(struct target *target);
91 int (*soft_reset_halt)(struct target *target);
92
93 /**
94 * Target register access for GDB. Do @b not call this function
95 * directly, use target_get_gdb_reg_list() instead.
96 *
97 * Danger! this function will succeed even if the target is running
98 * and return a register list with dummy values.
99 *
100 * The reason is that GDB connection will fail without a valid register
101 * list, however it is after GDB is connected that monitor commands can
102 * be run to properly initialize the target
103 */
104 int (*get_gdb_reg_list)(struct target *target, struct reg **reg_list[], int *reg_list_size);
105
106 /* target memory access
107 * size: 1 = byte (8bit), 2 = half-word (16bit), 4 = word (32bit)
108 * count: number of items of <size>
109 */
110
111 /**
112 * Target memory read callback. Do @b not call this function
113 * directly, use target_read_memory() instead.
114 */
115 int (*read_memory)(struct target *target, uint32_t address,
116 uint32_t size, uint32_t count, uint8_t *buffer);
117 /**
118 * Target memory write callback. Do @b not call this function
119 * directly, use target_write_memory() instead.
120 */
121 int (*write_memory)(struct target *target, uint32_t address,
122 uint32_t size, uint32_t count, const uint8_t *buffer);
123
124 /* Default implementation will do some fancy alignment to improve performance, target can override */
125 int (*read_buffer)(struct target *target, uint32_t address,
126 uint32_t size, uint8_t *buffer);
127
128 /* Default implementation will do some fancy alignment to improve performance, target can override */
129 int (*write_buffer)(struct target *target, uint32_t address,
130 uint32_t size, const uint8_t *buffer);
131
132 /**
133 * Write target memory in multiples of 4 bytes, optimized for
134 * writing large quantities of data. Do @b not call this
135 * function directly, use target_bulk_write_memory() instead.
136 */
137 int (*bulk_write_memory)(struct target *target, uint32_t address,
138 uint32_t count, const uint8_t *buffer);
139
140 int (*checksum_memory)(struct target *target, uint32_t address,
141 uint32_t count, uint32_t *checksum);
142 int (*blank_check_memory)(struct target *target, uint32_t address,
143 uint32_t count, uint32_t *blank);
144
145 /*
146 * target break-/watchpoint control
147 * rw: 0 = write, 1 = read, 2 = access
148 *
149 * Target must be halted while this is invoked as this
150 * will actually set up breakpoints on target.
151 *
152 * The breakpoint hardware will be set up upon adding the
153 * first breakpoint.
154 *
155 * Upon GDB connection all breakpoints/watchpoints are cleared.
156 */
157 int (*add_breakpoint)(struct target *target, struct breakpoint *breakpoint);
158 int (*add_context_breakpoint)(struct target *target, struct breakpoint *breakpoint);
159 int (*add_hybrid_breakpoint)(struct target *target, struct breakpoint *breakpoint);
160
161 /* remove breakpoint. hw will only be updated if the target
162 * is currently halted.
163 * However, this method can be invoked on unresponsive targets.
164 */
165 int (*remove_breakpoint)(struct target *target, struct breakpoint *breakpoint);
166
167 /* add watchpoint ... see add_breakpoint() comment above. */
168 int (*add_watchpoint)(struct target *target, struct watchpoint *watchpoint);
169
170 /* remove watchpoint. hw will only be updated if the target
171 * is currently halted.
172 * However, this method can be invoked on unresponsive targets.
173 */
174 int (*remove_watchpoint)(struct target *target, struct watchpoint *watchpoint);
175
176 /**
177 * Target algorithm support. Do @b not call this method directly,
178 * use target_run_algorithm() instead.
179 */
180 int (*run_algorithm)(struct target *target, int num_mem_params,
181 struct mem_param *mem_params, int num_reg_params,
182 struct reg_param *reg_param, uint32_t entry_point,
183 uint32_t exit_point, int timeout_ms, void *arch_info);
184 int (*start_algorithm)(struct target *target, int num_mem_params,
185 struct mem_param *mem_params, int num_reg_params,
186 struct reg_param *reg_param, uint32_t entry_point,
187 uint32_t exit_point, void *arch_info);
188 int (*wait_algorithm)(struct target *target, int num_mem_params,
189 struct mem_param *mem_params, int num_reg_params,
190 struct reg_param *reg_param, uint32_t exit_point,
191 int timeout_ms, void *arch_info);
192
193 const struct command_registration *commands;
194
195 /* called when target is created */
196 int (*target_create)(struct target *target, Jim_Interp *interp);
197
198 /* called for various config parameters */
199 /* returns JIM_CONTINUE - if option not understood */
200 /* otherwise: JIM_OK, or JIM_ERR, */
201 int (*target_jim_configure)(struct target *target, Jim_GetOptInfo *goi);
202
203 /* target commands specifically handled by the target */
204 /* returns JIM_OK, or JIM_ERR, or JIM_CONTINUE - if option not understood */
205 int (*target_jim_commands)(struct target *target, Jim_GetOptInfo *goi);
206
207 /**
208 * This method is used to perform target setup that requires
209 * JTAG access.
210 *
211 * This may be called multiple times. It is called after the
212 * scan chain is initially validated, or later after the target
213 * is enabled by a JRC. It may also be called during some
214 * parts of the reset sequence.
215 *
216 * For one-time initialization tasks, use target_was_examined()
217 * and target_set_examined(). For example, probe the hardware
218 * before setting up chip-specific state, and then set that
219 * flag so you don't do that again.
220 */
221 int (*examine)(struct target *target);
222
223 /* Set up structures for target.
224 *
225 * It is illegal to talk to the target at this stage as this fn is invoked
226 * before the JTAG chain has been examined/verified
227 * */
228 int (*init_target)(struct command_context *cmd_ctx, struct target *target);
229
230 /* translate from virtual to physical address. Default implementation is successful
231 * no-op(i.e. virtual==physical).
232 */
233 int (*virt2phys)(struct target *target, uint32_t address, uint32_t *physical);
234
235 /* read directly from physical memory. caches are bypassed and untouched.
236 *
237 * If the target does not support disabling caches, leaving them untouched,
238 * then minimally the actual physical memory location will be read even
239 * if cache states are unchanged, flushed, etc.
240 *
241 * Default implementation is to call read_memory.
242 */
243 int (*read_phys_memory)(struct target *target, uint32_t phys_address,
244 uint32_t size, uint32_t count, uint8_t *buffer);
245
246 /*
247 * same as read_phys_memory, except that it writes...
248 */
249 int (*write_phys_memory)(struct target *target, uint32_t phys_address,
250 uint32_t size, uint32_t count, const uint8_t *buffer);
251
252 int (*mmu)(struct target *target, int *enabled);
253
254 /* after reset is complete, the target can check if things are properly set up.
255 *
256 * This can be used to check if e.g. DCC memory writes have been enabled for
257 * arm7/9 targets, which they really should except in the most contrived
258 * circumstances.
259 */
260 int (*check_reset)(struct target *target);
261 };
262
263 #endif /* TARGET_TYPE_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)