1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "embeddedice.h"
27 #include "arm7_9_common.h"
32 #include "binarybuffer.h"
39 bitfield_desc_t embeddedice_comms_ctrl_bitfield_desc
[] =
47 int embeddedice_reg_arch_info
[] =
50 0x8, 0x9, 0xa, 0xb, 0xc, 0xd,
51 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
55 char* embeddedice_reg_list
[] =
67 "watch 0 control value",
68 "watch 0 control mask",
74 "watch 1 control value",
75 "watch 1 control mask",
80 int embeddedice_reg_arch_type
= -1;
82 int embeddedice_get_reg(reg_t
*reg
);
83 int embeddedice_set_reg(reg_t
*reg
, u32 value
);
84 int embeddedice_set_reg_w_exec(reg_t
*reg
, u8
*buf
);
86 int embeddedice_write_reg(reg_t
*reg
, u32 value
);
87 int embeddedice_read_reg(reg_t
*reg
);
89 reg_cache_t
* embeddedice_build_reg_cache(target_t
*target
, arm7_9_common_t
*arm7_9
)
91 reg_cache_t
*reg_cache
= malloc(sizeof(reg_cache_t
));
92 reg_t
*reg_list
= NULL
;
93 embeddedice_reg_t
*arch_info
= NULL
;
94 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
99 /* register a register arch-type for EmbeddedICE registers only once */
100 if (embeddedice_reg_arch_type
== -1)
101 embeddedice_reg_arch_type
= register_reg_arch_type(embeddedice_get_reg
, embeddedice_set_reg_w_exec
);
103 if (arm7_9
->has_vector_catch
)
108 /* the actual registers are kept in two arrays */
109 reg_list
= calloc(num_regs
, sizeof(reg_t
));
110 arch_info
= calloc(num_regs
, sizeof(embeddedice_reg_t
));
112 /* fill in values for the reg cache */
113 reg_cache
->name
= "EmbeddedICE registers";
114 reg_cache
->next
= NULL
;
115 reg_cache
->reg_list
= reg_list
;
116 reg_cache
->num_regs
= num_regs
;
118 /* set up registers */
119 for (i
= 0; i
< num_regs
; i
++)
121 reg_list
[i
].name
= embeddedice_reg_list
[i
];
122 reg_list
[i
].size
= 32;
123 reg_list
[i
].dirty
= 0;
124 reg_list
[i
].valid
= 0;
125 reg_list
[i
].bitfield_desc
= NULL
;
126 reg_list
[i
].num_bitfields
= 0;
127 reg_list
[i
].value
= calloc(1, 4);
128 reg_list
[i
].arch_info
= &arch_info
[i
];
129 reg_list
[i
].arch_type
= embeddedice_reg_arch_type
;
130 arch_info
[i
].addr
= embeddedice_reg_arch_info
[i
];
131 arch_info
[i
].jtag_info
= jtag_info
;
134 /* identify EmbeddedICE version by reading DCC control register */
135 embeddedice_read_reg(®_list
[EICE_COMMS_CTRL
]);
136 jtag_execute_queue();
138 eice_version
= buf_get_u32(reg_list
[EICE_COMMS_CTRL
].value
, 28, 4);
140 switch (eice_version
)
143 reg_list
[EICE_DBG_CTRL
].size
= 3;
144 reg_list
[EICE_DBG_STAT
].size
= 5;
147 reg_list
[EICE_DBG_CTRL
].size
= 4;
148 reg_list
[EICE_DBG_STAT
].size
= 5;
149 arm7_9
->has_single_step
= 1;
152 ERROR("EmbeddedICE version 3 detected, EmbeddedICE handling might be broken");
153 reg_list
[EICE_DBG_CTRL
].size
= 6;
154 reg_list
[EICE_DBG_STAT
].size
= 5;
155 arm7_9
->has_single_step
= 1;
156 arm7_9
->has_monitor_mode
= 1;
159 reg_list
[EICE_DBG_CTRL
].size
= 6;
160 reg_list
[EICE_DBG_STAT
].size
= 5;
161 arm7_9
->has_monitor_mode
= 1;
164 reg_list
[EICE_DBG_CTRL
].size
= 6;
165 reg_list
[EICE_DBG_STAT
].size
= 5;
166 arm7_9
->has_single_step
= 1;
167 arm7_9
->has_monitor_mode
= 1;
170 reg_list
[EICE_DBG_CTRL
].size
= 6;
171 reg_list
[EICE_DBG_STAT
].size
= 10;
172 arm7_9
->has_monitor_mode
= 1;
175 WARNING("EmbeddedICE version 7 detected, EmbeddedICE handling might be broken");
176 reg_list
[EICE_DBG_CTRL
].size
= 6;
177 reg_list
[EICE_DBG_STAT
].size
= 5;
178 arm7_9
->has_monitor_mode
= 1;
181 ERROR("unknown EmbeddedICE version (comms ctrl: 0x%4.4x)", buf_get_u32(reg_list
[EICE_COMMS_CTRL
].value
, 0, 32));
187 int embeddedice_get_reg(reg_t
*reg
)
189 if (embeddedice_read_reg(reg
) != ERROR_OK
)
191 ERROR("BUG: error scheduling EmbeddedICE register read");
195 if (jtag_execute_queue() != ERROR_OK
)
197 ERROR("register read failed");
203 int embeddedice_read_reg_w_check(reg_t
*reg
, u8
* check_value
, u8
* check_mask
)
205 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
206 u8 reg_addr
= ice_reg
->addr
& 0x1f;
207 scan_field_t fields
[3];
209 DEBUG("%i", ice_reg
->addr
);
211 jtag_add_end_state(TAP_RTI
);
212 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
213 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
);
215 fields
[0].device
= ice_reg
->jtag_info
->chain_pos
;
216 fields
[0].num_bits
= 32;
217 fields
[0].out_value
= reg
->value
;
218 fields
[0].out_mask
= NULL
;
219 fields
[0].in_value
= NULL
;
220 fields
[0].in_check_value
= NULL
;
221 fields
[0].in_check_mask
= NULL
;
222 fields
[0].in_handler
= NULL
;
223 fields
[0].in_handler_priv
= NULL
;
225 fields
[1].device
= ice_reg
->jtag_info
->chain_pos
;
226 fields
[1].num_bits
= 5;
227 fields
[1].out_value
= malloc(1);
228 buf_set_u32(fields
[1].out_value
, 0, 5, reg_addr
);
229 fields
[1].out_mask
= NULL
;
230 fields
[1].in_value
= NULL
;
231 fields
[1].in_check_value
= NULL
;
232 fields
[1].in_check_mask
= NULL
;
233 fields
[1].in_handler
= NULL
;
234 fields
[1].in_handler_priv
= NULL
;
236 fields
[2].device
= ice_reg
->jtag_info
->chain_pos
;
237 fields
[2].num_bits
= 1;
238 fields
[2].out_value
= malloc(1);
239 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
240 fields
[2].out_mask
= NULL
;
241 fields
[2].in_value
= NULL
;
242 fields
[2].in_check_value
= NULL
;
243 fields
[2].in_check_mask
= NULL
;
244 fields
[2].in_handler
= NULL
;
245 fields
[2].in_handler_priv
= NULL
;
247 jtag_add_dr_scan(3, fields
, -1);
249 fields
[0].in_value
= reg
->value
;
250 fields
[0].in_check_value
= check_value
;
251 fields
[0].in_check_mask
= check_mask
;
253 /* when reading the DCC data register, leaving the address field set to
254 * EICE_COMMS_DATA would read the register twice
255 * reading the control register is safe
257 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
259 jtag_add_dr_scan(3, fields
, -1);
261 free(fields
[1].out_value
);
262 free(fields
[2].out_value
);
267 int embeddedice_read_reg(reg_t
*reg
)
269 return embeddedice_read_reg_w_check(reg
, NULL
, NULL
);
272 int embeddedice_set_reg(reg_t
*reg
, u32 value
)
274 if (embeddedice_write_reg(reg
, value
) != ERROR_OK
)
276 ERROR("BUG: error scheduling EmbeddedICE register write");
280 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
287 int embeddedice_set_reg_w_exec(reg_t
*reg
, u8
*buf
)
289 embeddedice_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
291 if (jtag_execute_queue() != ERROR_OK
)
293 ERROR("register write failed");
299 int embeddedice_write_reg(reg_t
*reg
, u32 value
)
301 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
302 u8 reg_addr
= ice_reg
->addr
& 0x1f;
303 scan_field_t fields
[3];
305 DEBUG("%i: 0x%8.8x", ice_reg
->addr
, value
);
307 jtag_add_end_state(TAP_RTI
);
308 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
309 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
);
311 fields
[0].device
= ice_reg
->jtag_info
->chain_pos
;
312 fields
[0].num_bits
= 32;
313 fields
[0].out_value
= malloc(4);
314 buf_set_u32(fields
[0].out_value
, 0, 32, value
);
315 fields
[0].out_mask
= NULL
;
316 fields
[0].in_value
= NULL
;
317 fields
[0].in_check_value
= NULL
;
318 fields
[0].in_check_mask
= NULL
;
319 fields
[0].in_handler
= NULL
;
320 fields
[0].in_handler_priv
= NULL
;
322 fields
[1].device
= ice_reg
->jtag_info
->chain_pos
;
323 fields
[1].num_bits
= 5;
324 fields
[1].out_value
= malloc(1);
325 buf_set_u32(fields
[1].out_value
, 0, 5, reg_addr
);
326 fields
[1].out_mask
= NULL
;
327 fields
[1].in_value
= NULL
;
328 fields
[1].in_check_value
= NULL
;
329 fields
[1].in_check_mask
= NULL
;
330 fields
[1].in_handler
= NULL
;
331 fields
[1].in_handler_priv
= NULL
;
333 fields
[2].device
= ice_reg
->jtag_info
->chain_pos
;
334 fields
[2].num_bits
= 1;
335 fields
[2].out_value
= malloc(1);
336 buf_set_u32(fields
[2].out_value
, 0, 1, 1);
337 fields
[2].out_mask
= NULL
;
338 fields
[2].in_value
= NULL
;
339 fields
[2].in_check_value
= NULL
;
340 fields
[2].in_check_mask
= NULL
;
341 fields
[2].in_handler
= NULL
;
342 fields
[2].in_handler_priv
= NULL
;
344 jtag_add_dr_scan(3, fields
, -1);
346 free(fields
[0].out_value
);
347 free(fields
[1].out_value
);
348 free(fields
[2].out_value
);
353 int embeddedice_store_reg(reg_t
*reg
)
355 return embeddedice_write_reg(reg
, buf_get_u32(reg
->value
, 0, reg
->size
));
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)