1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "embeddedice.h"
30 #include "arm7_9_common.h"
35 #include "binarybuffer.h"
42 bitfield_desc_t embeddedice_comms_ctrl_bitfield_desc
[] =
50 int embeddedice_reg_arch_info
[] =
53 0x8, 0x9, 0xa, 0xb, 0xc, 0xd,
54 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
58 char* embeddedice_reg_list
[] =
70 "watch 0 control value",
71 "watch 0 control mask",
77 "watch 1 control value",
78 "watch 1 control mask",
83 int embeddedice_reg_arch_type
= -1;
85 int embeddedice_get_reg(reg_t
*reg
);
86 int embeddedice_set_reg(reg_t
*reg
, u32 value
);
87 int embeddedice_set_reg_w_exec(reg_t
*reg
, u8
*buf
);
89 int embeddedice_write_reg(reg_t
*reg
, u32 value
);
90 int embeddedice_read_reg(reg_t
*reg
);
92 reg_cache_t
* embeddedice_build_reg_cache(target_t
*target
, arm7_9_common_t
*arm7_9
)
95 reg_cache_t
*reg_cache
= malloc(sizeof(reg_cache_t
));
96 reg_t
*reg_list
= NULL
;
97 embeddedice_reg_t
*arch_info
= NULL
;
98 arm_jtag_t
*jtag_info
= &arm7_9
->jtag_info
;
101 int eice_version
= 0;
103 /* register a register arch-type for EmbeddedICE registers only once */
104 if (embeddedice_reg_arch_type
== -1)
105 embeddedice_reg_arch_type
= register_reg_arch_type(embeddedice_get_reg
, embeddedice_set_reg_w_exec
);
107 if (arm7_9
->has_vector_catch
)
112 /* the actual registers are kept in two arrays */
113 reg_list
= calloc(num_regs
, sizeof(reg_t
));
114 arch_info
= calloc(num_regs
, sizeof(embeddedice_reg_t
));
116 /* fill in values for the reg cache */
117 reg_cache
->name
= "EmbeddedICE registers";
118 reg_cache
->next
= NULL
;
119 reg_cache
->reg_list
= reg_list
;
120 reg_cache
->num_regs
= num_regs
;
122 /* set up registers */
123 for (i
= 0; i
< num_regs
; i
++)
125 reg_list
[i
].name
= embeddedice_reg_list
[i
];
126 reg_list
[i
].size
= 32;
127 reg_list
[i
].dirty
= 0;
128 reg_list
[i
].valid
= 0;
129 reg_list
[i
].bitfield_desc
= NULL
;
130 reg_list
[i
].num_bitfields
= 0;
131 reg_list
[i
].value
= calloc(1, 4);
132 reg_list
[i
].arch_info
= &arch_info
[i
];
133 reg_list
[i
].arch_type
= embeddedice_reg_arch_type
;
134 arch_info
[i
].addr
= embeddedice_reg_arch_info
[i
];
135 arch_info
[i
].jtag_info
= jtag_info
;
138 /* identify EmbeddedICE version by reading DCC control register */
139 embeddedice_read_reg(®_list
[EICE_COMMS_CTRL
]);
140 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
142 for (i
= 0; i
< num_regs
; i
++)
144 free(reg_list
[i
].value
);
151 eice_version
= buf_get_u32(reg_list
[EICE_COMMS_CTRL
].value
, 28, 4);
153 switch (eice_version
)
156 reg_list
[EICE_DBG_CTRL
].size
= 3;
157 reg_list
[EICE_DBG_STAT
].size
= 5;
160 reg_list
[EICE_DBG_CTRL
].size
= 4;
161 reg_list
[EICE_DBG_STAT
].size
= 5;
162 arm7_9
->has_single_step
= 1;
165 LOG_ERROR("EmbeddedICE version 3 detected, EmbeddedICE handling might be broken");
166 reg_list
[EICE_DBG_CTRL
].size
= 6;
167 reg_list
[EICE_DBG_STAT
].size
= 5;
168 arm7_9
->has_single_step
= 1;
169 arm7_9
->has_monitor_mode
= 1;
172 reg_list
[EICE_DBG_CTRL
].size
= 6;
173 reg_list
[EICE_DBG_STAT
].size
= 5;
174 arm7_9
->has_monitor_mode
= 1;
177 reg_list
[EICE_DBG_CTRL
].size
= 6;
178 reg_list
[EICE_DBG_STAT
].size
= 5;
179 arm7_9
->has_single_step
= 1;
180 arm7_9
->has_monitor_mode
= 1;
183 reg_list
[EICE_DBG_CTRL
].size
= 6;
184 reg_list
[EICE_DBG_STAT
].size
= 10;
185 arm7_9
->has_monitor_mode
= 1;
188 LOG_WARNING("EmbeddedICE version 7 detected, EmbeddedICE handling might be broken");
189 reg_list
[EICE_DBG_CTRL
].size
= 6;
190 reg_list
[EICE_DBG_STAT
].size
= 5;
191 arm7_9
->has_monitor_mode
= 1;
194 LOG_ERROR("unknown EmbeddedICE version (comms ctrl: 0x%8.8x)", buf_get_u32(reg_list
[EICE_COMMS_CTRL
].value
, 0, 32));
200 int embeddedice_setup(target_t
*target
)
203 armv4_5_common_t
*armv4_5
= target
->arch_info
;
204 arm7_9_common_t
*arm7_9
= armv4_5
->arch_info
;
206 /* explicitly disable monitor mode */
207 if (arm7_9
->has_monitor_mode
)
209 reg_t
*dbg_ctrl
= &arm7_9
->eice_cache
->reg_list
[EICE_DBG_CTRL
];
211 embeddedice_read_reg(dbg_ctrl
);
212 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
214 buf_set_u32(dbg_ctrl
->value
, 4, 1, 0);
215 embeddedice_set_reg_w_exec(dbg_ctrl
, dbg_ctrl
->value
);
217 return jtag_execute_queue();
220 int embeddedice_get_reg(reg_t
*reg
)
222 if (embeddedice_read_reg(reg
) != ERROR_OK
)
224 LOG_ERROR("BUG: error scheduling EmbeddedICE register read");
228 if (jtag_execute_queue() != ERROR_OK
)
230 LOG_ERROR("register read failed");
236 int embeddedice_read_reg_w_check(reg_t
*reg
, u8
* check_value
, u8
* check_mask
)
238 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
239 u8 reg_addr
= ice_reg
->addr
& 0x1f;
240 scan_field_t fields
[3];
244 jtag_add_end_state(TAP_RTI
);
245 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
247 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
, NULL
);
249 fields
[0].device
= ice_reg
->jtag_info
->chain_pos
;
250 fields
[0].num_bits
= 32;
251 fields
[0].out_value
= reg
->value
;
252 fields
[0].out_mask
= NULL
;
253 fields
[0].in_value
= NULL
;
254 fields
[0].in_check_value
= NULL
;
255 fields
[0].in_check_mask
= NULL
;
256 fields
[0].in_handler
= NULL
;
257 fields
[0].in_handler_priv
= NULL
;
259 fields
[1].device
= ice_reg
->jtag_info
->chain_pos
;
260 fields
[1].num_bits
= 5;
261 fields
[1].out_value
= field1_out
;
262 buf_set_u32(fields
[1].out_value
, 0, 5, reg_addr
);
263 fields
[1].out_mask
= NULL
;
264 fields
[1].in_value
= NULL
;
265 fields
[1].in_check_value
= NULL
;
266 fields
[1].in_check_mask
= NULL
;
267 fields
[1].in_handler
= NULL
;
268 fields
[1].in_handler_priv
= NULL
;
270 fields
[2].device
= ice_reg
->jtag_info
->chain_pos
;
271 fields
[2].num_bits
= 1;
272 fields
[2].out_value
= field2_out
;
273 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
274 fields
[2].out_mask
= NULL
;
275 fields
[2].in_value
= NULL
;
276 fields
[2].in_check_value
= NULL
;
277 fields
[2].in_check_mask
= NULL
;
278 fields
[2].in_handler
= NULL
;
279 fields
[2].in_handler_priv
= NULL
;
281 jtag_add_dr_scan(3, fields
, -1);
283 fields
[0].in_value
= reg
->value
;
284 jtag_set_check_value(fields
+0, check_value
, check_mask
, NULL
);
286 /* when reading the DCC data register, leaving the address field set to
287 * EICE_COMMS_DATA would read the register twice
288 * reading the control register is safe
290 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
292 jtag_add_dr_scan(3, fields
, -1);
297 /* receive <size> words of 32 bit from the DCC
298 * we pretend the target is always going to be fast enough
299 * (relative to the JTAG clock), so we don't need to handshake
301 int embeddedice_receive(arm_jtag_t
*jtag_info
, u32
*data
, u32 size
)
303 scan_field_t fields
[3];
307 jtag_add_end_state(TAP_RTI
);
308 arm_jtag_scann(jtag_info
, 0x2);
309 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
311 fields
[0].device
= jtag_info
->chain_pos
;
312 fields
[0].num_bits
= 32;
313 fields
[0].out_value
= NULL
;
314 fields
[0].out_mask
= NULL
;
315 fields
[0].in_value
= NULL
;
316 fields
[0].in_check_value
= NULL
;
317 fields
[0].in_check_mask
= NULL
;
318 fields
[0].in_handler
= NULL
;
319 fields
[0].in_handler_priv
= NULL
;
321 fields
[1].device
= jtag_info
->chain_pos
;
322 fields
[1].num_bits
= 5;
323 fields
[1].out_value
= field1_out
;
324 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_DATA
]);
325 fields
[1].out_mask
= NULL
;
326 fields
[1].in_value
= NULL
;
327 fields
[1].in_check_value
= NULL
;
328 fields
[1].in_check_mask
= NULL
;
329 fields
[1].in_handler
= NULL
;
330 fields
[1].in_handler_priv
= NULL
;
332 fields
[2].device
= jtag_info
->chain_pos
;
333 fields
[2].num_bits
= 1;
334 fields
[2].out_value
= field2_out
;
335 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
336 fields
[2].out_mask
= NULL
;
337 fields
[2].in_value
= NULL
;
338 fields
[2].in_check_value
= NULL
;
339 fields
[2].in_check_mask
= NULL
;
340 fields
[2].in_handler
= NULL
;
341 fields
[2].in_handler_priv
= NULL
;
343 jtag_add_dr_scan(3, fields
, -1);
347 /* when reading the last item, set the register address to the DCC control reg,
348 * to avoid reading additional data from the DCC data reg
351 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
353 fields
[0].in_handler
= arm_jtag_buf_to_u32
;
354 fields
[0].in_handler_priv
= data
;
355 jtag_add_dr_scan(3, fields
, -1);
361 return jtag_execute_queue();
364 int embeddedice_read_reg(reg_t
*reg
)
366 return embeddedice_read_reg_w_check(reg
, NULL
, NULL
);
369 int embeddedice_set_reg(reg_t
*reg
, u32 value
)
371 if (embeddedice_write_reg(reg
, value
) != ERROR_OK
)
373 LOG_ERROR("BUG: error scheduling EmbeddedICE register write");
377 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
384 int embeddedice_set_reg_w_exec(reg_t
*reg
, u8
*buf
)
386 embeddedice_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
388 if (jtag_execute_queue() != ERROR_OK
)
390 LOG_ERROR("register write failed");
396 int embeddedice_write_reg(reg_t
*reg
, u32 value
)
398 embeddedice_reg_t
*ice_reg
= reg
->arch_info
;
400 LOG_DEBUG("%i: 0x%8.8x", ice_reg
->addr
, value
);
402 jtag_add_end_state(TAP_RTI
);
403 arm_jtag_scann(ice_reg
->jtag_info
, 0x2);
405 arm_jtag_set_instr(ice_reg
->jtag_info
, ice_reg
->jtag_info
->intest_instr
, NULL
);
407 u8 reg_addr
= ice_reg
->addr
& 0x1f;
408 embeddedice_write_reg_inner(ice_reg
->jtag_info
->chain_pos
, reg_addr
, value
);
413 int embeddedice_store_reg(reg_t
*reg
)
415 return embeddedice_write_reg(reg
, buf_get_u32(reg
->value
, 0, reg
->size
));
418 /* send <size> words of 32 bit to the DCC
419 * we pretend the target is always going to be fast enough
420 * (relative to the JTAG clock), so we don't need to handshake
422 int embeddedice_send(arm_jtag_t
*jtag_info
, u32
*data
, u32 size
)
424 scan_field_t fields
[3];
429 jtag_add_end_state(TAP_RTI
);
430 arm_jtag_scann(jtag_info
, 0x2);
431 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
433 fields
[0].device
= jtag_info
->chain_pos
;
434 fields
[0].num_bits
= 32;
435 fields
[0].out_value
= field0_out
;
436 fields
[0].out_mask
= NULL
;
437 fields
[0].in_value
= NULL
;
438 fields
[0].in_check_value
= NULL
;
439 fields
[0].in_check_mask
= NULL
;
440 fields
[0].in_handler
= NULL
;
441 fields
[0].in_handler_priv
= NULL
;
443 fields
[1].device
= jtag_info
->chain_pos
;
444 fields
[1].num_bits
= 5;
445 fields
[1].out_value
= field1_out
;
446 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_DATA
]);
447 fields
[1].out_mask
= NULL
;
448 fields
[1].in_value
= NULL
;
449 fields
[1].in_check_value
= NULL
;
450 fields
[1].in_check_mask
= NULL
;
451 fields
[1].in_handler
= NULL
;
452 fields
[1].in_handler_priv
= NULL
;
454 fields
[2].device
= jtag_info
->chain_pos
;
455 fields
[2].num_bits
= 1;
456 fields
[2].out_value
= field2_out
;
457 buf_set_u32(fields
[2].out_value
, 0, 1, 1);
458 fields
[2].out_mask
= NULL
;
459 fields
[2].in_value
= NULL
;
460 fields
[2].in_check_value
= NULL
;
461 fields
[2].in_check_mask
= NULL
;
462 fields
[2].in_handler
= NULL
;
463 fields
[2].in_handler_priv
= NULL
;
467 buf_set_u32(fields
[0].out_value
, 0, 32, *data
);
468 jtag_add_dr_scan(3, fields
, -1);
474 /* call to jtag_execute_queue() intentionally omitted */
478 /* wait for DCC control register R/W handshake bit to become active
480 int embeddedice_handshake(arm_jtag_t
*jtag_info
, int hsbit
, u32 timeout
)
482 scan_field_t fields
[3];
491 if (hsbit
== EICE_COMM_CTRL_WBIT
)
493 else if (hsbit
== EICE_COMM_CTRL_RBIT
)
496 return ERROR_INVALID_ARGUMENTS
;
498 jtag_add_end_state(TAP_RTI
);
499 arm_jtag_scann(jtag_info
, 0x2);
500 arm_jtag_set_instr(jtag_info
, jtag_info
->intest_instr
, NULL
);
502 fields
[0].device
= jtag_info
->chain_pos
;
503 fields
[0].num_bits
= 32;
504 fields
[0].out_value
= NULL
;
505 fields
[0].out_mask
= NULL
;
506 fields
[0].in_value
= field0_in
;
507 fields
[0].in_check_value
= NULL
;
508 fields
[0].in_check_mask
= NULL
;
509 fields
[0].in_handler
= NULL
;
510 fields
[0].in_handler_priv
= NULL
;
512 fields
[1].device
= jtag_info
->chain_pos
;
513 fields
[1].num_bits
= 5;
514 fields
[1].out_value
= field1_out
;
515 buf_set_u32(fields
[1].out_value
, 0, 5, embeddedice_reg_arch_info
[EICE_COMMS_CTRL
]);
516 fields
[1].out_mask
= NULL
;
517 fields
[1].in_value
= NULL
;
518 fields
[1].in_check_value
= NULL
;
519 fields
[1].in_check_mask
= NULL
;
520 fields
[1].in_handler
= NULL
;
521 fields
[1].in_handler_priv
= NULL
;
523 fields
[2].device
= jtag_info
->chain_pos
;
524 fields
[2].num_bits
= 1;
525 fields
[2].out_value
= field2_out
;
526 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
527 fields
[2].out_mask
= NULL
;
528 fields
[2].in_value
= NULL
;
529 fields
[2].in_check_value
= NULL
;
530 fields
[2].in_check_mask
= NULL
;
531 fields
[2].in_handler
= NULL
;
532 fields
[2].in_handler_priv
= NULL
;
534 jtag_add_dr_scan(3, fields
, -1);
535 gettimeofday(&lap
, NULL
);
538 jtag_add_dr_scan(3, fields
, -1);
539 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
542 if (buf_get_u32(field0_in
, hsbit
, 1) == hsact
)
545 gettimeofday(&now
, NULL
);
547 while ((now
.tv_sec
-lap
.tv_sec
)*1000 + (now
.tv_usec
-lap
.tv_usec
)/1000 <= timeout
);
549 return ERROR_TARGET_TIMEOUT
;
552 /* this is the inner loop of the open loop DCC write of data to target */
553 void MINIDRIVER(embeddedice_write_dcc
)(int chain_pos
, int reg_addr
, u8
*buffer
, int little
, int count
)
556 for (i
= 0; i
< count
; i
++)
558 embeddedice_write_reg_inner(chain_pos
, reg_addr
, fast_target_buffer_get_u32(buffer
, little
));
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)