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%8.8x)", buf_get_u32(reg_list
[EICE_COMMS_CTRL
].value
, 0, 32));
184 /* explicitly disable monitor mode */
185 if (arm7_9
->has_monitor_mode
)
187 embeddedice_read_reg(®_list
[EICE_DBG_CTRL
]);
188 jtag_execute_queue();
189 buf_set_u32(reg_list
[EICE_DBG_CTRL
].value
, 4, 1, 0);
190 embeddedice_set_reg_w_exec(®_list
[EICE_DBG_CTRL
], reg_list
[EICE_DBG_CTRL
].value
);
196 int embeddedice_get_reg(reg_t
*reg
)
198 if (embeddedice_read_reg(reg
) != ERROR_OK
)
200 ERROR("BUG: error scheduling EmbeddedICE register read");
204 if (jtag_execute_queue() != ERROR_OK
)
206 ERROR("register read failed");
212 int embeddedice_read_reg_w_check(reg_t
*reg
, u8
* check_value
, u8
* check_mask
)
214 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
215 u8 reg_addr
= ice_reg
->addr
& 0x1f;
216 scan_field_t fields
[3];
220 DEBUG("%i", ice_reg
->addr
);
222 jtag_add_end_state(TAP_RTI
);
223 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
225 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
, NULL
);
227 fields
[0].device
= ice_reg
->jtag_info
->chain_pos
;
228 fields
[0].num_bits
= 32;
229 fields
[0].out_value
= reg
->value
;
230 fields
[0].out_mask
= NULL
;
231 fields
[0].in_value
= NULL
;
232 fields
[0].in_check_value
= NULL
;
233 fields
[0].in_check_mask
= NULL
;
234 fields
[0].in_handler
= NULL
;
235 fields
[0].in_handler_priv
= NULL
;
237 fields
[1].device
= ice_reg
->jtag_info
->chain_pos
;
238 fields
[1].num_bits
= 5;
239 fields
[1].out_value
= field1_out
;
240 buf_set_u32(fields
[1].out_value
, 0, 5, reg_addr
);
241 fields
[1].out_mask
= NULL
;
242 fields
[1].in_value
= NULL
;
243 fields
[1].in_check_value
= NULL
;
244 fields
[1].in_check_mask
= NULL
;
245 fields
[1].in_handler
= NULL
;
246 fields
[1].in_handler_priv
= NULL
;
248 fields
[2].device
= ice_reg
->jtag_info
->chain_pos
;
249 fields
[2].num_bits
= 1;
250 fields
[2].out_value
= field2_out
;
251 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
252 fields
[2].out_mask
= NULL
;
253 fields
[2].in_value
= NULL
;
254 fields
[2].in_check_value
= NULL
;
255 fields
[2].in_check_mask
= NULL
;
256 fields
[2].in_handler
= NULL
;
257 fields
[2].in_handler_priv
= NULL
;
259 jtag_add_dr_scan(3, fields
, -1, NULL
);
261 fields
[0].in_value
= reg
->value
;
262 jtag_set_check_value(fields
+0, check_value
, check_mask
, NULL
);
264 /* when reading the DCC data register, leaving the address field set to
265 * EICE_COMMS_DATA would read the register twice
266 * reading the control register is safe
268 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
270 jtag_add_dr_scan(3, fields
, -1, NULL
);
275 /* receive <size> words of 32 bit from the DCC
276 * we pretend the target is always going to be fast enough
277 * (relative to the JTAG clock), so we don't need to handshake
279 int embeddedice_receive(arm_jtag_t
*jtag_info
, u32
*data
, u32 size
)
281 scan_field_t fields
[3];
285 jtag_add_end_state(TAP_RTI
);
286 arm_jtag_scann(jtag_info
, 0x2);
287 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
289 fields
[0].device
= jtag_info
->chain_pos
;
290 fields
[0].num_bits
= 32;
291 fields
[0].out_value
= NULL
;
292 fields
[0].out_mask
= NULL
;
293 fields
[0].in_value
= NULL
;
294 fields
[0].in_check_value
= NULL
;
295 fields
[0].in_check_mask
= NULL
;
296 fields
[0].in_handler
= NULL
;
297 fields
[0].in_handler_priv
= NULL
;
299 fields
[1].device
= jtag_info
->chain_pos
;
300 fields
[1].num_bits
= 5;
301 fields
[1].out_value
= field1_out
;
302 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_DATA
]);
303 fields
[1].out_mask
= NULL
;
304 fields
[1].in_value
= NULL
;
305 fields
[1].in_check_value
= NULL
;
306 fields
[1].in_check_mask
= NULL
;
307 fields
[1].in_handler
= NULL
;
308 fields
[1].in_handler_priv
= NULL
;
310 fields
[2].device
= jtag_info
->chain_pos
;
311 fields
[2].num_bits
= 1;
312 fields
[2].out_value
= field2_out
;
313 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
314 fields
[2].out_mask
= NULL
;
315 fields
[2].in_value
= NULL
;
316 fields
[2].in_check_value
= NULL
;
317 fields
[2].in_check_mask
= NULL
;
318 fields
[2].in_handler
= NULL
;
319 fields
[2].in_handler_priv
= NULL
;
321 jtag_add_dr_scan(3, fields
, -1, NULL
);
325 /* when reading the last item, set the register address to the DCC control reg,
326 * to avoid reading additional data from the DCC data reg
329 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
331 fields
[0].in_handler
= arm_jtag_buf_to_u32
;
332 fields
[0].in_handler_priv
= data
;
333 jtag_add_dr_scan(3, fields
, -1, NULL
);
339 return jtag_execute_queue();
342 int embeddedice_read_reg(reg_t
*reg
)
344 return embeddedice_read_reg_w_check(reg
, NULL
, NULL
);
347 int embeddedice_set_reg(reg_t
*reg
, u32 value
)
349 if (embeddedice_write_reg(reg
, value
) != ERROR_OK
)
351 ERROR("BUG: error scheduling EmbeddedICE register write");
355 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
362 int embeddedice_set_reg_w_exec(reg_t
*reg
, u8
*buf
)
364 embeddedice_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
366 if (jtag_execute_queue() != ERROR_OK
)
368 ERROR("register write failed");
374 int embeddedice_write_reg(reg_t
*reg
, u32 value
)
376 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
377 u8 reg_addr
= ice_reg
->addr
& 0x1f;
378 scan_field_t fields
[3];
383 DEBUG("%i: 0x%8.8x", ice_reg
->addr
, value
);
385 jtag_add_end_state(TAP_RTI
);
386 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
388 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
, NULL
);
390 fields
[0].device
= ice_reg
->jtag_info
->chain_pos
;
391 fields
[0].num_bits
= 32;
392 fields
[0].out_value
= field0_out
;
393 buf_set_u32(fields
[0].out_value
, 0, 32, value
);
394 fields
[0].out_mask
= NULL
;
395 fields
[0].in_value
= NULL
;
396 fields
[0].in_check_value
= NULL
;
397 fields
[0].in_check_mask
= NULL
;
398 fields
[0].in_handler
= NULL
;
399 fields
[0].in_handler_priv
= NULL
;
401 fields
[1].device
= ice_reg
->jtag_info
->chain_pos
;
402 fields
[1].num_bits
= 5;
403 fields
[1].out_value
= field1_out
;
404 buf_set_u32(fields
[1].out_value
, 0, 5, reg_addr
);
405 fields
[1].out_mask
= NULL
;
406 fields
[1].in_value
= NULL
;
407 fields
[1].in_check_value
= NULL
;
408 fields
[1].in_check_mask
= NULL
;
409 fields
[1].in_handler
= NULL
;
410 fields
[1].in_handler_priv
= NULL
;
412 fields
[2].device
= ice_reg
->jtag_info
->chain_pos
;
413 fields
[2].num_bits
= 1;
414 fields
[2].out_value
= field2_out
;
415 buf_set_u32(fields
[2].out_value
, 0, 1, 1);
416 fields
[2].out_mask
= NULL
;
417 fields
[2].in_value
= NULL
;
418 fields
[2].in_check_value
= NULL
;
419 fields
[2].in_check_mask
= NULL
;
420 fields
[2].in_handler
= NULL
;
421 fields
[2].in_handler_priv
= NULL
;
423 jtag_add_dr_scan(3, fields
, -1, NULL
);
428 int embeddedice_store_reg(reg_t
*reg
)
430 return embeddedice_write_reg(reg
, buf_get_u32(reg
->value
, 0, reg
->size
));
433 /* send <size> words of 32 bit to the DCC
434 * we pretend the target is always going to be fast enough
435 * (relative to the JTAG clock), so we don't need to handshake
437 int embeddedice_send(arm_jtag_t
*jtag_info
, u32
*data
, u32 size
)
439 scan_field_t fields
[3];
444 jtag_add_end_state(TAP_RTI
);
445 arm_jtag_scann(jtag_info
, 0x2);
446 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
448 fields
[0].device
= jtag_info
->chain_pos
;
449 fields
[0].num_bits
= 32;
450 fields
[0].out_value
= field0_out
;
451 fields
[0].out_mask
= NULL
;
452 fields
[0].in_value
= NULL
;
453 fields
[0].in_check_value
= NULL
;
454 fields
[0].in_check_mask
= NULL
;
455 fields
[0].in_handler
= NULL
;
456 fields
[0].in_handler_priv
= NULL
;
458 fields
[1].device
= jtag_info
->chain_pos
;
459 fields
[1].num_bits
= 5;
460 fields
[1].out_value
= field1_out
;
461 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_DATA
]);
462 fields
[1].out_mask
= NULL
;
463 fields
[1].in_value
= NULL
;
464 fields
[1].in_check_value
= NULL
;
465 fields
[1].in_check_mask
= NULL
;
466 fields
[1].in_handler
= NULL
;
467 fields
[1].in_handler_priv
= NULL
;
469 fields
[2].device
= jtag_info
->chain_pos
;
470 fields
[2].num_bits
= 1;
471 fields
[2].out_value
= field2_out
;
472 buf_set_u32(fields
[2].out_value
, 0, 1, 1);
473 fields
[2].out_mask
= NULL
;
474 fields
[2].in_value
= NULL
;
475 fields
[2].in_check_value
= NULL
;
476 fields
[2].in_check_mask
= NULL
;
477 fields
[2].in_handler
= NULL
;
478 fields
[2].in_handler_priv
= NULL
;
482 buf_set_u32(fields
[0].out_value
, 0, 32, *data
);
483 jtag_add_dr_scan(3, fields
, -1, NULL
);
489 /* call to jtag_execute_queue() intentionally omitted */
493 /* wait for DCC control register R/W handshake bit to become active
495 int embeddedice_handshake(arm_jtag_t
*jtag_info
, int hsbit
, u32 timeout
)
497 scan_field_t fields
[3];
506 if (hsbit
== EICE_COMM_CTRL_WBIT
)
508 else if (hsbit
== EICE_COMM_CTRL_RBIT
)
511 return ERROR_INVALID_ARGUMENTS
;
513 jtag_add_end_state(TAP_RTI
);
514 arm_jtag_scann(jtag_info
, 0x2);
515 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
517 fields
[0].device
= jtag_info
->chain_pos
;
518 fields
[0].num_bits
= 32;
519 fields
[0].out_value
= NULL
;
520 fields
[0].out_mask
= NULL
;
521 fields
[0].in_value
= field0_in
;
522 fields
[0].in_check_value
= NULL
;
523 fields
[0].in_check_mask
= NULL
;
524 fields
[0].in_handler
= NULL
;
525 fields
[0].in_handler_priv
= NULL
;
527 fields
[1].device
= jtag_info
->chain_pos
;
528 fields
[1].num_bits
= 5;
529 fields
[1].out_value
= field1_out
;
530 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
531 fields
[1].out_mask
= NULL
;
532 fields
[1].in_value
= NULL
;
533 fields
[1].in_check_value
= NULL
;
534 fields
[1].in_check_mask
= NULL
;
535 fields
[1].in_handler
= NULL
;
536 fields
[1].in_handler_priv
= NULL
;
538 fields
[2].device
= jtag_info
->chain_pos
;
539 fields
[2].num_bits
= 1;
540 fields
[2].out_value
= field2_out
;
541 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
542 fields
[2].out_mask
= NULL
;
543 fields
[2].in_value
= NULL
;
544 fields
[2].in_check_value
= NULL
;
545 fields
[2].in_check_mask
= NULL
;
546 fields
[2].in_handler
= NULL
;
547 fields
[2].in_handler_priv
= NULL
;
549 jtag_add_dr_scan(3, fields
, -1, NULL
);
550 gettimeofday(&lap
, NULL
);
553 jtag_add_dr_scan(3, fields
, -1, NULL
);
554 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
557 if (buf_get_u32(field0_in
, hsbit
, 1) == hsact
)
560 gettimeofday(&now
, NULL
);
562 while ((now
.tv_sec
-lap
.tv_sec
)*1000 + (now
.tv_usec
-lap
.tv_usec
)/1000 <= timeout
);
564 return ERROR_TARGET_TIMEOUT
;
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)