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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
26 #include "arm_disassembler.h"
28 #include "etm_dummy.h"
30 #if BUILD_OOCD_TRACE == 1
31 #include "oocd_trace.h"
36 * ARM "Embedded Trace Macrocell" (ETM) support -- direct JTAG access.
38 * ETM modules collect instruction and/or data trace information, compress
39 * it, and transfer it to a debugging host through either a (buffered) trace
40 * port (often a 38-pin Mictor connector) or an Embedded Trace Buffer (ETB).
42 * There are several generations of these modules. Original versions have
43 * JTAG access through a dedicated scan chain. Recent versions have added
44 * access via coprocessor instructions, memory addressing, and the ARM Debug
45 * Interface v5 (ADIv5); and phased out direct JTAG access.
47 * This code supports up to the ETMv1.3 architecture, as seen in ETM9 and
48 * most common ARM9 systems. Note: "CoreSight ETM9" implements ETMv3.2,
49 * implying non-JTAG connectivity options.
51 * Relevant documentation includes:
52 * ARM DDI 0157G ... ETM9 (r2p2) Technical Reference Manual
53 * ARM DDI 0315B ... CoreSight ETM9 (r0p1) Technical Reference Manual
54 * ARM IHI 0014O ... Embedded Trace Macrocell, Architecture Specification
65 uint8_t size
; /* low-N of 32 bits */
66 uint8_t mode
; /* RO, WO, RW */
67 uint8_t bcd_vers
; /* 1.0, 2.0, etc */
72 * Registers 0..0x7f are JTAG-addressable using scanchain 6.
73 * (Or on some processors, through coprocessor operations.)
74 * Newer versions of ETM make some W/O registers R/W, and
75 * provide definitions for some previously-unused bits.
78 /* core registers used to version/configure the ETM */
79 static const struct etm_reg_info etm_core
[] = {
80 /* NOTE: we "know" the order here ... */
81 { ETM_CONFIG
, 32, RO
, 0x10, "ETM_config", },
82 { ETM_ID
, 32, RO
, 0x20, "ETM_id", },
85 /* basic registers that are always there given the right ETM version */
86 static const struct etm_reg_info etm_basic
[] = {
87 /* ETM Trace Registers */
88 { ETM_CTRL
, 32, RW
, 0x10, "ETM_ctrl", },
89 { ETM_TRIG_EVENT
, 17, WO
, 0x10, "ETM_trig_event", },
90 { ETM_ASIC_CTRL
, 8, WO
, 0x10, "ETM_asic_ctrl", },
91 { ETM_STATUS
, 3, RO
, 0x11, "ETM_status", },
92 { ETM_SYS_CONFIG
, 9, RO
, 0x12, "ETM_sys_config", },
94 /* TraceEnable configuration */
95 { ETM_TRACE_RESOURCE_CTRL
, 32, WO
, 0x12, "ETM_trace_resource_ctrl", },
96 { ETM_TRACE_EN_CTRL2
, 16, WO
, 0x12, "ETM_trace_en_ctrl2", },
97 { ETM_TRACE_EN_EVENT
, 17, WO
, 0x10, "ETM_trace_en_event", },
98 { ETM_TRACE_EN_CTRL1
, 26, WO
, 0x10, "ETM_trace_en_ctrl1", },
100 /* ViewData configuration (data trace) */
101 { ETM_VIEWDATA_EVENT
, 17, WO
, 0x10, "ETM_viewdata_event", },
102 { ETM_VIEWDATA_CTRL1
, 32, WO
, 0x10, "ETM_viewdata_ctrl1", },
103 { ETM_VIEWDATA_CTRL2
, 32, WO
, 0x10, "ETM_viewdata_ctrl2", },
104 { ETM_VIEWDATA_CTRL3
, 17, WO
, 0x10, "ETM_viewdata_ctrl3", },
106 /* REVISIT exclude VIEWDATA_CTRL2 when it's not there */
108 { 0x78, 12, WO
, 0x20, "ETM_sync_freq", },
109 { 0x7a, 22, RO
, 0x31, "ETM_config_code_ext", },
110 { 0x7b, 32, WO
, 0x31, "ETM_ext_input_select", },
111 { 0x7c, 32, WO
, 0x34, "ETM_trace_start_stop", },
112 { 0x7d, 8, WO
, 0x34, "ETM_behavior_control", },
115 static const struct etm_reg_info etm_fifofull
[] = {
116 /* FIFOFULL configuration */
117 { ETM_FIFOFULL_REGION
, 25, WO
, 0x10, "ETM_fifofull_region", },
118 { ETM_FIFOFULL_LEVEL
, 8, WO
, 0x10, "ETM_fifofull_level", },
121 static const struct etm_reg_info etm_addr_comp
[] = {
122 /* Address comparator register pairs */
123 #define ADDR_COMPARATOR(i) \
124 { ETM_ADDR_COMPARATOR_VALUE + (i) - 1, 32, WO, 0x10, \
125 "ETM_addr_" #i "_comparator_value", }, \
126 { ETM_ADDR_ACCESS_TYPE + (i) - 1, 7, WO, 0x10, \
127 "ETM_addr_" #i "_access_type", }
146 #undef ADDR_COMPARATOR
149 static const struct etm_reg_info etm_data_comp
[] = {
150 /* Data Value Comparators (NOTE: odd addresses are reserved) */
151 #define DATA_COMPARATOR(i) \
152 { ETM_DATA_COMPARATOR_VALUE + 2*(i) - 1, 32, WO, 0x10, \
153 "ETM_data_" #i "_comparator_value", }, \
154 { ETM_DATA_COMPARATOR_MASK + 2*(i) - 1, 32, WO, 0x10, \
155 "ETM_data_" #i "_comparator_mask", }
165 #undef DATA_COMPARATOR
168 static const struct etm_reg_info etm_counters
[] = {
169 #define ETM_COUNTER(i) \
170 { ETM_COUNTER_RELOAD_VALUE + (i) - 1, 16, WO, 0x10, \
171 "ETM_counter_" #i "_reload_value", }, \
172 { ETM_COUNTER_ENABLE + (i) - 1, 18, WO, 0x10, \
173 "ETM_counter_" #i "_enable", }, \
174 { ETM_COUNTER_RELOAD_EVENT + (i) - 1, 17, WO, 0x10, \
175 "ETM_counter_" #i "_reload_event", }, \
176 { ETM_COUNTER_VALUE + (i) - 1, 16, RO, 0x10, \
177 "ETM_counter_" #i "_value", }
186 static const struct etm_reg_info etm_sequencer
[] = {
188 { ETM_SEQUENCER_EVENT + (i), 17, WO, 0x10, \
189 "ETM_sequencer_event" #i, }
190 ETM_SEQ(0), /* 1->2 */
191 ETM_SEQ(1), /* 2->1 */
192 ETM_SEQ(2), /* 2->3 */
193 ETM_SEQ(3), /* 3->1 */
194 ETM_SEQ(4), /* 3->2 */
195 ETM_SEQ(5), /* 1->3 */
198 { ETM_SEQUENCER_STATE
, 2, RO
, 0x10, "ETM_sequencer_state", },
201 static const struct etm_reg_info etm_outputs
[] = {
202 #define ETM_OUTPUT(i) \
203 { ETM_EXTERNAL_OUTPUT + (i) - 1, 17, WO, 0x10, \
204 "ETM_external_output" #i, }
215 /* registers from 0x6c..0x7f were added after ETMv1.3 */
217 /* Context ID Comparators */
218 { 0x6c, 32, RO
, 0x20, "ETM_contextid_comparator_value1", }
219 { 0x6d, 32, RO
, 0x20, "ETM_contextid_comparator_value2", }
220 { 0x6e, 32, RO
, 0x20, "ETM_contextid_comparator_value3", }
221 { 0x6f, 32, RO
, 0x20, "ETM_contextid_comparator_mask", }
224 static int etm_get_reg(struct reg
*reg
);
225 static int etm_read_reg_w_check(struct reg
*reg
,
226 uint8_t *check_value
, uint8_t *check_mask
);
227 static int etm_register_user_commands(struct command_context
*cmd_ctx
);
228 static int etm_set_reg_w_exec(struct reg
*reg
, uint8_t *buf
);
229 static int etm_write_reg(struct reg
*reg
, uint32_t value
);
231 static const struct reg_arch_type etm_scan6_type
= {
233 .set
= etm_set_reg_w_exec
,
236 /* Look up register by ID ... most ETM instances only
237 * support a subset of the possible registers.
239 static struct reg
*etm_reg_lookup(struct etm_context
*etm_ctx
, unsigned id
)
241 struct reg_cache
*cache
= etm_ctx
->reg_cache
;
244 for (i
= 0; i
< cache
->num_regs
; i
++) {
245 struct etm_reg
*reg
= cache
->reg_list
[i
].arch_info
;
247 if (reg
->reg_info
->addr
== id
)
248 return &cache
->reg_list
[i
];
251 /* caller asking for nonexistent register is a bug!
252 * REVISIT say which of the N targets was involved */
253 LOG_ERROR("ETM: register 0x%02x not available", id
);
257 static void etm_reg_add(unsigned bcd_vers
, struct arm_jtag
*jtag_info
,
258 struct reg_cache
*cache
, struct etm_reg
*ereg
,
259 const struct etm_reg_info
*r
, unsigned nreg
)
261 struct reg
*reg
= cache
->reg_list
;
263 reg
+= cache
->num_regs
;
264 ereg
+= cache
->num_regs
;
266 /* add up to "nreg" registers from "r", if supported by this
267 * version of the ETM, to the specified cache.
269 for (; nreg
--; r
++) {
270 /* No more registers to add */
272 LOG_ERROR("etm_reg_add is requested to add non-existing registers, ETM config might be bogus");
276 /* this ETM may be too old to have some registers */
277 if (r
->bcd_vers
> bcd_vers
)
282 reg
->value
= &ereg
->value
;
283 reg
->arch_info
= ereg
;
284 reg
->type
= &etm_scan6_type
;
289 ereg
->jtag_info
= jtag_info
;
294 struct reg_cache
*etm_build_reg_cache(struct target
*target
,
295 struct arm_jtag
*jtag_info
, struct etm_context
*etm_ctx
)
297 struct reg_cache
*reg_cache
= malloc(sizeof(struct reg_cache
));
298 struct reg
*reg_list
= NULL
;
299 struct etm_reg
*arch_info
= NULL
;
300 unsigned bcd_vers
, config
;
302 /* the actual registers are kept in two arrays */
303 reg_list
= calloc(128, sizeof(struct reg
));
304 arch_info
= calloc(128, sizeof(struct etm_reg
));
306 if (reg_cache
== NULL
|| reg_list
== NULL
|| arch_info
== NULL
) {
307 LOG_ERROR("No memory");
311 /* fill in values for the reg cache */
312 reg_cache
->name
= "etm registers";
313 reg_cache
->next
= NULL
;
314 reg_cache
->reg_list
= reg_list
;
315 reg_cache
->num_regs
= 0;
317 /* add ETM_CONFIG, then parse its values to see
318 * which other registers exist in this ETM
320 etm_reg_add(0x10, jtag_info
, reg_cache
, arch_info
,
323 etm_get_reg(reg_list
);
324 etm_ctx
->config
= buf_get_u32(arch_info
->value
, 0, 32);
325 config
= etm_ctx
->config
;
327 /* figure ETM version then add base registers */
328 if (config
& (1 << 31)) {
329 LOG_WARNING("ETMv2+ support is incomplete");
331 /* REVISIT more registers may exist; they may now be
332 * readable; more register bits have defined meanings;
333 * don't presume trace start/stop support is present;
334 * and include any context ID comparator registers.
336 etm_reg_add(0x20, jtag_info
, reg_cache
, arch_info
,
338 etm_get_reg(reg_list
+ 1);
339 etm_ctx
->id
= buf_get_u32(
340 arch_info
[1].value
, 0, 32);
341 LOG_DEBUG("ETM ID: %08x", (unsigned) etm_ctx
->id
);
342 bcd_vers
= 0x10 + (((etm_ctx
->id
) >> 4) & 0xff);
345 switch (config
>> 28) {
362 LOG_WARNING("Bad ETMv1 protocol %d", config
>> 28);
366 etm_ctx
->bcd_vers
= bcd_vers
;
367 LOG_INFO("ETM v%d.%d", bcd_vers
>> 4, bcd_vers
& 0xf);
369 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
370 etm_basic
, ARRAY_SIZE(etm_basic
));
372 /* address and data comparators; counters; outputs */
373 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
374 etm_addr_comp
, 4 * (0x0f & (config
>> 0)));
375 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
376 etm_data_comp
, 2 * (0x0f & (config
>> 4)));
377 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
378 etm_counters
, 4 * (0x07 & (config
>> 13)));
379 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
380 etm_outputs
, (0x07 & (config
>> 20)));
382 /* FIFOFULL presence is optional
383 * REVISIT for ETMv1.2 and later, don't bother adding this
384 * unless ETM_SYS_CONFIG says it's also *supported* ...
386 if (config
& (1 << 23))
387 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
388 etm_fifofull
, ARRAY_SIZE(etm_fifofull
));
390 /* sequencer is optional (for state-dependant triggering) */
391 if (config
& (1 << 16))
392 etm_reg_add(bcd_vers
, jtag_info
, reg_cache
, arch_info
,
393 etm_sequencer
, ARRAY_SIZE(etm_sequencer
));
395 /* REVISIT could realloc and likely save half the memory
396 * in the two chunks we allocated...
399 /* the ETM might have an ETB connected */
400 if (strcmp(etm_ctx
->capture_driver
->name
, "etb") == 0) {
401 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
404 LOG_ERROR("etb selected as etm capture driver, but no ETB configured");
408 reg_cache
->next
= etb_build_reg_cache(etb
);
410 etb
->reg_cache
= reg_cache
->next
;
413 etm_ctx
->reg_cache
= reg_cache
;
423 static int etm_read_reg(struct reg
*reg
)
425 return etm_read_reg_w_check(reg
, NULL
, NULL
);
428 static int etm_store_reg(struct reg
*reg
)
430 return etm_write_reg(reg
, buf_get_u32(reg
->value
, 0, reg
->size
));
433 int etm_setup(struct target
*target
)
436 uint32_t etm_ctrl_value
;
437 struct arm
*arm
= target_to_arm(target
);
438 struct etm_context
*etm_ctx
= arm
->etm
;
439 struct reg
*etm_ctrl_reg
;
441 etm_ctrl_reg
= etm_reg_lookup(etm_ctx
, ETM_CTRL
);
445 /* initialize some ETM control register settings */
446 etm_get_reg(etm_ctrl_reg
);
447 etm_ctrl_value
= buf_get_u32(etm_ctrl_reg
->value
, 0, 32);
449 /* clear the ETM powerdown bit (0) */
450 etm_ctrl_value
&= ~ETM_CTRL_POWERDOWN
;
452 /* configure port width (21,6:4), mode (13,17:16) and
453 * for older modules clocking (13)
455 etm_ctrl_value
= (etm_ctrl_value
456 & ~ETM_PORT_WIDTH_MASK
457 & ~ETM_PORT_MODE_MASK
459 & ~ETM_PORT_CLOCK_MASK
)
462 buf_set_u32(etm_ctrl_reg
->value
, 0, 32, etm_ctrl_value
);
463 etm_store_reg(etm_ctrl_reg
);
465 etm_ctx
->control
= etm_ctrl_value
;
467 retval
= jtag_execute_queue();
468 if (retval
!= ERROR_OK
)
471 /* REVISIT for ETMv3.0 and later, read ETM_sys_config to
472 * verify that those width and mode settings are OK ...
475 retval
= etm_ctx
->capture_driver
->init(etm_ctx
);
476 if (retval
!= ERROR_OK
) {
477 LOG_ERROR("ETM capture driver initialization failed");
483 static int etm_get_reg(struct reg
*reg
)
487 retval
= etm_read_reg(reg
);
488 if (retval
!= ERROR_OK
) {
489 LOG_ERROR("BUG: error scheduling etm register read");
493 retval
= jtag_execute_queue();
494 if (retval
!= ERROR_OK
) {
495 LOG_ERROR("register read failed");
502 static int etm_read_reg_w_check(struct reg
*reg
,
503 uint8_t *check_value
, uint8_t *check_mask
)
505 struct etm_reg
*etm_reg
= reg
->arch_info
;
507 const struct etm_reg_info
*r
= etm_reg
->reg_info
;
508 uint8_t reg_addr
= r
->addr
& 0x7f;
509 struct scan_field fields
[3];
512 if (etm_reg
->reg_info
->mode
== WO
) {
513 LOG_ERROR("BUG: can't read write-only register %s", r
->name
);
514 return ERROR_COMMAND_SYNTAX_ERROR
;
517 LOG_DEBUG("%s (%u)", r
->name
, reg_addr
);
519 retval
= arm_jtag_scann(etm_reg
->jtag_info
, 0x6, TAP_IDLE
);
520 if (retval
!= ERROR_OK
)
522 retval
= arm_jtag_set_instr(etm_reg
->jtag_info
->tap
,
523 etm_reg
->jtag_info
->intest_instr
,
526 if (retval
!= ERROR_OK
)
529 fields
[0].num_bits
= 32;
530 fields
[0].out_value
= reg
->value
;
531 fields
[0].in_value
= NULL
;
532 fields
[0].check_value
= NULL
;
533 fields
[0].check_mask
= NULL
;
535 fields
[1].num_bits
= 7;
537 fields
[1].out_value
= &temp1
;
538 buf_set_u32(&temp1
, 0, 7, reg_addr
);
539 fields
[1].in_value
= NULL
;
540 fields
[1].check_value
= NULL
;
541 fields
[1].check_mask
= NULL
;
543 fields
[2].num_bits
= 1;
545 fields
[2].out_value
= &temp2
;
546 buf_set_u32(&temp2
, 0, 1, 0);
547 fields
[2].in_value
= NULL
;
548 fields
[2].check_value
= NULL
;
549 fields
[2].check_mask
= NULL
;
551 jtag_add_dr_scan(etm_reg
->jtag_info
->tap
, 3, fields
, TAP_IDLE
);
553 fields
[0].in_value
= reg
->value
;
554 fields
[0].check_value
= check_value
;
555 fields
[0].check_mask
= check_mask
;
557 jtag_add_dr_scan_check(etm_reg
->jtag_info
->tap
, 3, fields
, TAP_IDLE
);
562 static int etm_set_reg(struct reg
*reg
, uint32_t value
)
564 int retval
= etm_write_reg(reg
, value
);
565 if (retval
!= ERROR_OK
) {
566 LOG_ERROR("BUG: error scheduling etm register write");
570 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
577 static int etm_set_reg_w_exec(struct reg
*reg
, uint8_t *buf
)
581 etm_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
583 retval
= jtag_execute_queue();
584 if (retval
!= ERROR_OK
) {
585 LOG_ERROR("register write failed");
591 static int etm_write_reg(struct reg
*reg
, uint32_t value
)
593 struct etm_reg
*etm_reg
= reg
->arch_info
;
594 const struct etm_reg_info
*r
= etm_reg
->reg_info
;
595 uint8_t reg_addr
= r
->addr
& 0x7f;
596 struct scan_field fields
[3];
599 if (etm_reg
->reg_info
->mode
== RO
) {
600 LOG_ERROR("BUG: can't write read--only register %s", r
->name
);
601 return ERROR_COMMAND_SYNTAX_ERROR
;
604 LOG_DEBUG("%s (%u): 0x%8.8" PRIx32
"", r
->name
, reg_addr
, value
);
606 retval
= arm_jtag_scann(etm_reg
->jtag_info
, 0x6, TAP_IDLE
);
607 if (retval
!= ERROR_OK
)
609 retval
= arm_jtag_set_instr(etm_reg
->jtag_info
->tap
,
610 etm_reg
->jtag_info
->intest_instr
,
613 if (retval
!= ERROR_OK
)
616 fields
[0].num_bits
= 32;
618 fields
[0].out_value
= tmp1
;
619 buf_set_u32(tmp1
, 0, 32, value
);
620 fields
[0].in_value
= NULL
;
622 fields
[1].num_bits
= 7;
624 fields
[1].out_value
= &tmp2
;
625 buf_set_u32(&tmp2
, 0, 7, reg_addr
);
626 fields
[1].in_value
= NULL
;
628 fields
[2].num_bits
= 1;
630 fields
[2].out_value
= &tmp3
;
631 buf_set_u32(&tmp3
, 0, 1, 1);
632 fields
[2].in_value
= NULL
;
634 jtag_add_dr_scan(etm_reg
->jtag_info
->tap
, 3, fields
, TAP_IDLE
);
640 /* ETM trace analysis functionality */
642 static struct etm_capture_driver
*etm_capture_drivers
[] = {
644 &etm_dummy_capture_driver
,
645 #if BUILD_OOCD_TRACE == 1
646 &oocd_trace_capture_driver
,
651 static int etm_read_instruction(struct etm_context
*ctx
, struct arm_instruction
*instruction
)
660 return ERROR_TRACE_IMAGE_UNAVAILABLE
;
662 /* search for the section the current instruction belongs to */
663 for (i
= 0; i
< ctx
->image
->num_sections
; i
++) {
664 if ((ctx
->image
->sections
[i
].base_address
<= ctx
->current_pc
) &&
665 (ctx
->image
->sections
[i
].base_address
+ ctx
->image
->sections
[i
].size
>
673 /* current instruction couldn't be found in the image */
674 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
677 if (ctx
->core_state
== ARM_STATE_ARM
) {
679 retval
= image_read_section(ctx
->image
, section
,
681 ctx
->image
->sections
[section
].base_address
,
683 if (retval
!= ERROR_OK
) {
684 LOG_ERROR("error while reading instruction");
685 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
687 opcode
= target_buffer_get_u32(ctx
->target
, buf
);
688 arm_evaluate_opcode(opcode
, ctx
->current_pc
, instruction
);
689 } else if (ctx
->core_state
== ARM_STATE_THUMB
) {
691 retval
= image_read_section(ctx
->image
, section
,
693 ctx
->image
->sections
[section
].base_address
,
695 if (retval
!= ERROR_OK
) {
696 LOG_ERROR("error while reading instruction");
697 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE
;
699 opcode
= target_buffer_get_u16(ctx
->target
, buf
);
700 thumb_evaluate_opcode(opcode
, ctx
->current_pc
, instruction
);
701 } else if (ctx
->core_state
== ARM_STATE_JAZELLE
) {
702 LOG_ERROR("BUG: tracing of jazelle code not supported");
705 LOG_ERROR("BUG: unknown core state encountered");
712 static int etmv1_next_packet(struct etm_context
*ctx
, uint8_t *packet
, int apo
)
714 while (ctx
->data_index
< ctx
->trace_depth
) {
715 /* if the caller specified an address packet offset, skip until the
716 * we reach the n-th cycle marked with tracesync */
718 if (ctx
->trace_data
[ctx
->data_index
].flags
& ETMV1_TRACESYNC_CYCLE
)
728 /* no tracedata output during a TD cycle
729 * or in a trigger cycle */
730 if ((ctx
->trace_data
[ctx
->data_index
].pipestat
== STAT_TD
)
731 || (ctx
->trace_data
[ctx
->data_index
].flags
& ETMV1_TRIGGER_CYCLE
)) {
737 /* FIXME there are more port widths than these... */
738 if ((ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_16BIT
) {
739 if (ctx
->data_half
== 0) {
740 *packet
= ctx
->trace_data
[ctx
->data_index
].packet
& 0xff;
743 *packet
= (ctx
->trace_data
[ctx
->data_index
].packet
& 0xff00) >> 8;
747 } else if ((ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_8BIT
) {
748 *packet
= ctx
->trace_data
[ctx
->data_index
].packet
& 0xff;
751 /* on a 4-bit port, a packet will be output during two consecutive cycles */
752 if (ctx
->data_index
> (ctx
->trace_depth
- 2))
755 *packet
= ctx
->trace_data
[ctx
->data_index
].packet
& 0xf;
756 *packet
|= (ctx
->trace_data
[ctx
->data_index
+ 1].packet
& 0xf) << 4;
757 ctx
->data_index
+= 2;
766 static int etmv1_branch_address(struct etm_context
*ctx
)
774 /* quit analysis if less than two cycles are left in the trace
775 * because we can't extract the APO */
776 if (ctx
->data_index
> (ctx
->trace_depth
- 2))
779 /* a BE could be output during an APO cycle, skip the current
780 * and continue with the new one */
781 if (ctx
->trace_data
[ctx
->pipe_index
+ 1].pipestat
& 0x4)
783 if (ctx
->trace_data
[ctx
->pipe_index
+ 2].pipestat
& 0x4)
786 /* address packet offset encoded in the next two cycles' pipestat bits */
787 apo
= ctx
->trace_data
[ctx
->pipe_index
+ 1].pipestat
& 0x3;
788 apo
|= (ctx
->trace_data
[ctx
->pipe_index
+ 2].pipestat
& 0x3) << 2;
790 /* count number of tracesync cycles between current pipe_index and data_index
791 * i.e. the number of tracesyncs that data_index already passed by
792 * to subtract them from the APO */
793 for (i
= ctx
->pipe_index
; i
< ctx
->data_index
; i
++) {
794 if (ctx
->trace_data
[ctx
->pipe_index
+ 1].pipestat
& ETMV1_TRACESYNC_CYCLE
)
798 /* extract up to four 7-bit packets */
800 retval
= etmv1_next_packet(ctx
, &packet
, (shift
== 0) ? apo
+ 1 : 0);
803 ctx
->last_branch
&= ~(0x7f << shift
);
804 ctx
->last_branch
|= (packet
& 0x7f) << shift
;
806 } while ((packet
& 0x80) && (shift
< 28));
808 /* one last packet holding 4 bits of the address, plus the branch reason code */
809 if ((shift
== 28) && (packet
& 0x80)) {
810 retval
= etmv1_next_packet(ctx
, &packet
, 0);
813 ctx
->last_branch
&= 0x0fffffff;
814 ctx
->last_branch
|= (packet
& 0x0f) << 28;
815 ctx
->last_branch_reason
= (packet
& 0x70) >> 4;
818 ctx
->last_branch_reason
= 0;
823 /* if a full address was output, we might have branched into Jazelle state */
824 if ((shift
== 32) && (packet
& 0x80))
825 ctx
->core_state
= ARM_STATE_JAZELLE
;
827 /* if we didn't branch into Jazelle state, the current processor state is
828 * encoded in bit 0 of the branch target address */
829 if (ctx
->last_branch
& 0x1) {
830 ctx
->core_state
= ARM_STATE_THUMB
;
831 ctx
->last_branch
&= ~0x1;
833 ctx
->core_state
= ARM_STATE_ARM
;
834 ctx
->last_branch
&= ~0x3;
841 static int etmv1_data(struct etm_context
*ctx
, int size
, uint32_t *data
)
847 for (j
= 0; j
< size
; j
++) {
848 retval
= etmv1_next_packet(ctx
, &buf
[j
], 0);
854 LOG_ERROR("TODO: add support for 64-bit values");
856 } else if (size
== 4)
857 *data
= target_buffer_get_u32(ctx
->target
, buf
);
859 *data
= target_buffer_get_u16(ctx
->target
, buf
);
868 static int etmv1_analyze_trace(struct etm_context
*ctx
, struct command_invocation
*cmd
)
871 struct arm_instruction instruction
;
873 /* read the trace data if it wasn't read already */
874 if (ctx
->trace_depth
== 0)
875 ctx
->capture_driver
->read_trace(ctx
);
877 if (ctx
->trace_depth
== 0) {
878 command_print(cmd
, "Trace is empty.");
882 /* start at the beginning of the captured trace */
887 /* neither the PC nor the data pointer are valid */
891 while (ctx
->pipe_index
< ctx
->trace_depth
) {
892 uint8_t pipestat
= ctx
->trace_data
[ctx
->pipe_index
].pipestat
;
893 uint32_t next_pc
= ctx
->current_pc
;
894 uint32_t old_data_index
= ctx
->data_index
;
895 uint32_t old_data_half
= ctx
->data_half
;
896 uint32_t old_index
= ctx
->pipe_index
;
897 uint32_t last_instruction
= ctx
->last_instruction
;
899 int current_pc_ok
= ctx
->pc_ok
;
901 if (ctx
->trace_data
[ctx
->pipe_index
].flags
& ETMV1_TRIGGER_CYCLE
)
902 command_print(cmd
, "--- trigger ---");
904 /* instructions execute in IE/D or BE/D cycles */
905 if ((pipestat
== STAT_IE
) || (pipestat
== STAT_ID
))
906 ctx
->last_instruction
= ctx
->pipe_index
;
908 /* if we don't have a valid pc skip until we reach an indirect branch */
909 if ((!ctx
->pc_ok
) && (pipestat
!= STAT_BE
)) {
914 /* any indirect branch could have interrupted instruction flow
915 * - the branch reason code could indicate a trace discontinuity
916 * - a branch to the exception vectors indicates an exception
918 if ((pipestat
== STAT_BE
) || (pipestat
== STAT_BD
)) {
919 /* backup current data index, to be able to consume the branch address
920 * before examining data address and values
922 old_data_index
= ctx
->data_index
;
923 old_data_half
= ctx
->data_half
;
925 ctx
->last_instruction
= ctx
->pipe_index
;
927 retval
= etmv1_branch_address(ctx
);
929 /* negative return value from etmv1_branch_address means we ran out of packets,
930 * quit analysing the trace */
934 /* a positive return values means the current branch was abandoned,
935 * and a new branch was encountered in cycle ctx->pipe_index + retval;
938 "abandoned branch encountered, correctness of analysis uncertain");
939 ctx
->pipe_index
+= retval
;
943 /* skip over APO cycles */
944 ctx
->pipe_index
+= 2;
946 switch (ctx
->last_branch_reason
) {
947 case 0x0: /* normal PC change */
948 next_pc
= ctx
->last_branch
;
950 case 0x1: /* tracing enabled */
952 "--- tracing enabled at 0x%8.8" PRIx32
" ---",
954 ctx
->current_pc
= ctx
->last_branch
;
958 case 0x2: /* trace restarted after FIFO overflow */
960 "--- trace restarted after FIFO overflow at 0x%8.8" PRIx32
" ---",
962 ctx
->current_pc
= ctx
->last_branch
;
966 case 0x3: /* exit from debug state */
968 "--- exit from debug state at 0x%8.8" PRIx32
" ---",
970 ctx
->current_pc
= ctx
->last_branch
;
974 case 0x4: /* periodic synchronization point */
975 next_pc
= ctx
->last_branch
;
976 /* if we had no valid PC prior to this synchronization point,
977 * we have to move on with the next trace cycle
979 if (!current_pc_ok
) {
981 "--- periodic synchronization point at 0x%8.8" PRIx32
" ---",
983 ctx
->current_pc
= next_pc
;
988 default: /* reserved */
990 "BUG: branch reason code 0x%" PRIx32
" is reserved",
991 ctx
->last_branch_reason
);
995 /* if we got here the branch was a normal PC change
996 * (or a periodic synchronization point, which means the same for that matter)
997 * if we didn't acquire a complete PC continue with the next cycle
1002 /* indirect branch to the exception vector means an exception occurred */
1003 if ((ctx
->last_branch
<= 0x20)
1004 || ((ctx
->last_branch
>= 0xffff0000) &&
1005 (ctx
->last_branch
<= 0xffff0020))) {
1006 if ((ctx
->last_branch
& 0xff) == 0x10)
1007 command_print(cmd
, "data abort");
1010 "exception vector 0x%2.2" PRIx32
"",
1012 ctx
->current_pc
= ctx
->last_branch
;
1019 /* an instruction was executed (or not, depending on the condition flags)
1020 * retrieve it from the image for displaying */
1021 if (ctx
->pc_ok
&& (pipestat
!= STAT_WT
) && (pipestat
!= STAT_TD
) &&
1022 !(((pipestat
== STAT_BE
) || (pipestat
== STAT_BD
)) &&
1023 ((ctx
->last_branch_reason
!= 0x0) && (ctx
->last_branch_reason
!= 0x4)))) {
1024 retval
= etm_read_instruction(ctx
, &instruction
);
1025 if (retval
!= ERROR_OK
) {
1026 /* can't continue tracing with no image available */
1027 if (retval
== ERROR_TRACE_IMAGE_UNAVAILABLE
)
1029 else if (retval
== ERROR_TRACE_INSTRUCTION_UNAVAILABLE
) {
1030 /* TODO: handle incomplete images
1031 * for now we just quit the analysis*/
1036 cycles
= old_index
- last_instruction
;
1039 if ((pipestat
== STAT_ID
) || (pipestat
== STAT_BD
)) {
1040 uint32_t new_data_index
= ctx
->data_index
;
1041 uint32_t new_data_half
= ctx
->data_half
;
1043 /* in case of a branch with data, the branch target address was consumed before
1044 * we temporarily go back to the saved data index */
1045 if (pipestat
== STAT_BD
) {
1046 ctx
->data_index
= old_data_index
;
1047 ctx
->data_half
= old_data_half
;
1050 if (ctx
->control
& ETM_CTRL_TRACE_ADDR
) {
1055 retval
= etmv1_next_packet(ctx
, &packet
, 0);
1057 return ERROR_ETM_ANALYSIS_FAILED
;
1058 ctx
->last_ptr
&= ~(0x7f << shift
);
1059 ctx
->last_ptr
|= (packet
& 0x7f) << shift
;
1061 } while ((packet
& 0x80) && (shift
< 32));
1068 "address: 0x%8.8" PRIx32
"",
1072 if (ctx
->control
& ETM_CTRL_TRACE_DATA
) {
1073 if ((instruction
.type
== ARM_LDM
) ||
1074 (instruction
.type
== ARM_STM
)) {
1076 for (i
= 0; i
< 16; i
++) {
1077 if (instruction
.info
.load_store_multiple
.
1078 register_list
& (1 << i
)) {
1080 if (etmv1_data(ctx
, 4, &data
) != 0)
1081 return ERROR_ETM_ANALYSIS_FAILED
;
1083 "data: 0x%8.8" PRIx32
"",
1087 } else if ((instruction
.type
>= ARM_LDR
) &&
1088 (instruction
.type
<= ARM_STRH
)) {
1090 if (etmv1_data(ctx
, arm_access_size(&instruction
),
1092 return ERROR_ETM_ANALYSIS_FAILED
;
1093 command_print(cmd
, "data: 0x%8.8" PRIx32
"", data
);
1097 /* restore data index after consuming BD address and data */
1098 if (pipestat
== STAT_BD
) {
1099 ctx
->data_index
= new_data_index
;
1100 ctx
->data_half
= new_data_half
;
1105 if ((pipestat
== STAT_IE
) || (pipestat
== STAT_ID
)) {
1106 if (((instruction
.type
== ARM_B
) ||
1107 (instruction
.type
== ARM_BL
) ||
1108 (instruction
.type
== ARM_BLX
)) &&
1109 (instruction
.info
.b_bl_bx_blx
.target_address
!= 0xffffffff))
1110 next_pc
= instruction
.info
.b_bl_bx_blx
.target_address
;
1112 next_pc
+= (ctx
->core_state
== ARM_STATE_ARM
) ? 4 : 2;
1113 } else if (pipestat
== STAT_IN
)
1114 next_pc
+= (ctx
->core_state
== ARM_STATE_ARM
) ? 4 : 2;
1116 if ((pipestat
!= STAT_TD
) && (pipestat
!= STAT_WT
)) {
1117 char cycles_text
[32] = "";
1119 /* if the trace was captured with cycle accurate tracing enabled,
1120 * output the number of cycles since the last executed instruction
1122 if (ctx
->control
& ETM_CTRL_CYCLE_ACCURATE
) {
1123 snprintf(cycles_text
, 32, " (%i %s)",
1125 (cycles
== 1) ? "cycle" : "cycles");
1128 command_print(cmd
, "%s%s%s",
1130 (pipestat
== STAT_IN
) ? " (not executed)" : "",
1133 ctx
->current_pc
= next_pc
;
1135 /* packets for an instruction don't start on or before the preceding
1136 * functional pipestat (i.e. other than WT or TD)
1138 if (ctx
->data_index
<= ctx
->pipe_index
) {
1139 ctx
->data_index
= ctx
->pipe_index
+ 1;
1144 ctx
->pipe_index
+= 1;
1150 static COMMAND_HELPER(handle_etm_tracemode_command_update
,
1155 /* what parts of data access are traced? */
1156 if (strcmp(CMD_ARGV
[0], "none") == 0)
1158 else if (strcmp(CMD_ARGV
[0], "data") == 0)
1159 tracemode
= ETM_CTRL_TRACE_DATA
;
1160 else if (strcmp(CMD_ARGV
[0], "address") == 0)
1161 tracemode
= ETM_CTRL_TRACE_ADDR
;
1162 else if (strcmp(CMD_ARGV
[0], "all") == 0)
1163 tracemode
= ETM_CTRL_TRACE_DATA
| ETM_CTRL_TRACE_ADDR
;
1165 command_print(CMD
, "invalid option '%s'", CMD_ARGV
[0]);
1166 return ERROR_COMMAND_SYNTAX_ERROR
;
1170 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[1], context_id
);
1171 switch (context_id
) {
1173 tracemode
|= ETM_CTRL_CONTEXTID_NONE
;
1176 tracemode
|= ETM_CTRL_CONTEXTID_8
;
1179 tracemode
|= ETM_CTRL_CONTEXTID_16
;
1182 tracemode
|= ETM_CTRL_CONTEXTID_32
;
1185 command_print(CMD
, "invalid option '%s'", CMD_ARGV
[1]);
1186 return ERROR_COMMAND_SYNTAX_ERROR
;
1189 bool etmv1_cycle_accurate
;
1190 COMMAND_PARSE_ENABLE(CMD_ARGV
[2], etmv1_cycle_accurate
);
1191 if (etmv1_cycle_accurate
)
1192 tracemode
|= ETM_CTRL_CYCLE_ACCURATE
;
1194 bool etmv1_branch_output
;
1195 COMMAND_PARSE_ENABLE(CMD_ARGV
[3], etmv1_branch_output
);
1196 if (etmv1_branch_output
)
1197 tracemode
|= ETM_CTRL_BRANCH_OUTPUT
;
1200 * - CPRT tracing (coprocessor register transfers)
1201 * - debug request (causes debug entry on trigger)
1202 * - stall on FIFOFULL (preventing tracedata loss)
1209 COMMAND_HANDLER(handle_etm_tracemode_command
)
1211 struct target
*target
= get_current_target(CMD_CTX
);
1212 struct arm
*arm
= target_to_arm(target
);
1213 struct etm_context
*etm
;
1216 command_print(CMD
, "ETM: current target isn't an ARM");
1222 command_print(CMD
, "current target doesn't have an ETM configured");
1226 uint32_t tracemode
= etm
->control
;
1232 CALL_COMMAND_HANDLER(handle_etm_tracemode_command_update
,
1236 return ERROR_COMMAND_SYNTAX_ERROR
;
1240 * todo: fail if parameters were invalid for this hardware,
1241 * or couldn't be written; display actual hardware state...
1244 command_print(CMD
, "current tracemode configuration:");
1246 switch (tracemode
& ETM_CTRL_TRACE_MASK
) {
1248 command_print(CMD
, "data tracing: none");
1250 case ETM_CTRL_TRACE_DATA
:
1251 command_print(CMD
, "data tracing: data only");
1253 case ETM_CTRL_TRACE_ADDR
:
1254 command_print(CMD
, "data tracing: address only");
1256 case ETM_CTRL_TRACE_DATA
| ETM_CTRL_TRACE_ADDR
:
1257 command_print(CMD
, "data tracing: address and data");
1261 switch (tracemode
& ETM_CTRL_CONTEXTID_MASK
) {
1262 case ETM_CTRL_CONTEXTID_NONE
:
1263 command_print(CMD
, "contextid tracing: none");
1265 case ETM_CTRL_CONTEXTID_8
:
1266 command_print(CMD
, "contextid tracing: 8 bit");
1268 case ETM_CTRL_CONTEXTID_16
:
1269 command_print(CMD
, "contextid tracing: 16 bit");
1271 case ETM_CTRL_CONTEXTID_32
:
1272 command_print(CMD
, "contextid tracing: 32 bit");
1276 if (tracemode
& ETM_CTRL_CYCLE_ACCURATE
)
1277 command_print(CMD
, "cycle-accurate tracing enabled");
1279 command_print(CMD
, "cycle-accurate tracing disabled");
1281 if (tracemode
& ETM_CTRL_BRANCH_OUTPUT
)
1282 command_print(CMD
, "full branch address output enabled");
1284 command_print(CMD
, "full branch address output disabled");
1286 #define TRACEMODE_MASK ( \
1287 ETM_CTRL_CONTEXTID_MASK \
1288 | ETM_CTRL_BRANCH_OUTPUT \
1289 | ETM_CTRL_CYCLE_ACCURATE \
1290 | ETM_CTRL_TRACE_MASK \
1293 /* only update ETM_CTRL register if tracemode changed */
1294 if ((etm
->control
& TRACEMODE_MASK
) != tracemode
) {
1295 struct reg
*etm_ctrl_reg
;
1297 etm_ctrl_reg
= etm_reg_lookup(etm
, ETM_CTRL
);
1301 etm
->control
&= ~TRACEMODE_MASK
;
1302 etm
->control
|= tracemode
& TRACEMODE_MASK
;
1304 buf_set_u32(etm_ctrl_reg
->value
, 0, 32, etm
->control
);
1305 etm_store_reg(etm_ctrl_reg
);
1307 /* invalidate old trace data */
1308 etm
->capture_status
= TRACE_IDLE
;
1309 if (etm
->trace_depth
> 0) {
1310 free(etm
->trace_data
);
1311 etm
->trace_data
= NULL
;
1313 etm
->trace_depth
= 0;
1316 #undef TRACEMODE_MASK
1321 COMMAND_HANDLER(handle_etm_config_command
)
1323 struct target
*target
;
1325 uint32_t portmode
= 0x0;
1326 struct etm_context
*etm_ctx
;
1330 return ERROR_COMMAND_SYNTAX_ERROR
;
1332 target
= get_target(CMD_ARGV
[0]);
1334 LOG_ERROR("target '%s' not defined", CMD_ARGV
[0]);
1338 arm
= target_to_arm(target
);
1340 command_print(CMD
, "target '%s' is '%s'; not an ARM",
1341 target_name(target
),
1342 target_type_name(target
));
1346 /* FIXME for ETMv3.0 and above -- and we don't yet know what ETM
1347 * version we'll be using!! -- so we can't know how to validate
1348 * params yet. "etm config" should likely be *AFTER* hookup...
1350 * - Many more widths might be supported ... and we can easily
1351 * check whether our setting "took".
1353 * - The "clock" and "mode" bits are interpreted differently.
1354 * See ARM IHI 0014O table 2-17 for the old behaviour, and
1355 * table 2-18 for the new. With ETB it's best to specify
1359 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[1], port_width
);
1360 switch (port_width
) {
1361 /* before ETMv3.0 */
1363 portmode
|= ETM_PORT_4BIT
;
1366 portmode
|= ETM_PORT_8BIT
;
1369 portmode
|= ETM_PORT_16BIT
;
1371 /* ETMv3.0 and later*/
1373 portmode
|= ETM_PORT_24BIT
;
1376 portmode
|= ETM_PORT_32BIT
;
1379 portmode
|= ETM_PORT_48BIT
;
1382 portmode
|= ETM_PORT_64BIT
;
1385 portmode
|= ETM_PORT_1BIT
;
1388 portmode
|= ETM_PORT_2BIT
;
1392 "unsupported ETM port width '%s'", CMD_ARGV
[1]);
1396 if (strcmp("normal", CMD_ARGV
[2]) == 0)
1397 portmode
|= ETM_PORT_NORMAL
;
1398 else if (strcmp("multiplexed", CMD_ARGV
[2]) == 0)
1399 portmode
|= ETM_PORT_MUXED
;
1400 else if (strcmp("demultiplexed", CMD_ARGV
[2]) == 0)
1401 portmode
|= ETM_PORT_DEMUXED
;
1404 "unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'",
1409 if (strcmp("half", CMD_ARGV
[3]) == 0)
1410 portmode
|= ETM_PORT_HALF_CLOCK
;
1411 else if (strcmp("full", CMD_ARGV
[3]) == 0)
1412 portmode
|= ETM_PORT_FULL_CLOCK
;
1415 "unsupported ETM port clocking '%s', must be 'full' or 'half'",
1420 etm_ctx
= calloc(1, sizeof(struct etm_context
));
1422 LOG_DEBUG("out of memory");
1426 for (i
= 0; etm_capture_drivers
[i
]; i
++) {
1427 if (strcmp(CMD_ARGV
[4], etm_capture_drivers
[i
]->name
) == 0) {
1428 int retval
= register_commands(CMD_CTX
, NULL
,
1429 etm_capture_drivers
[i
]->commands
);
1430 if (ERROR_OK
!= retval
) {
1435 etm_ctx
->capture_driver
= etm_capture_drivers
[i
];
1441 if (!etm_capture_drivers
[i
]) {
1442 /* no supported capture driver found, don't register an ETM */
1444 LOG_ERROR("trace capture driver '%s' not found", CMD_ARGV
[4]);
1448 etm_ctx
->target
= target
;
1449 etm_ctx
->trace_data
= NULL
;
1450 etm_ctx
->control
= portmode
;
1451 etm_ctx
->core_state
= ARM_STATE_ARM
;
1455 return etm_register_user_commands(CMD_CTX
);
1458 COMMAND_HANDLER(handle_etm_info_command
)
1460 struct target
*target
;
1462 struct etm_context
*etm
;
1463 struct reg
*etm_sys_config_reg
;
1467 target
= get_current_target(CMD_CTX
);
1468 arm
= target_to_arm(target
);
1470 command_print(CMD
, "ETM: current target isn't an ARM");
1476 command_print(CMD
, "current target doesn't have an ETM configured");
1480 command_print(CMD
, "ETM v%d.%d",
1481 etm
->bcd_vers
>> 4, etm
->bcd_vers
& 0xf);
1482 command_print(CMD
, "pairs of address comparators: %i",
1483 (int) (etm
->config
>> 0) & 0x0f);
1484 command_print(CMD
, "data comparators: %i",
1485 (int) (etm
->config
>> 4) & 0x0f);
1486 command_print(CMD
, "memory map decoders: %i",
1487 (int) (etm
->config
>> 8) & 0x1f);
1488 command_print(CMD
, "number of counters: %i",
1489 (int) (etm
->config
>> 13) & 0x07);
1490 command_print(CMD
, "sequencer %spresent",
1491 (int) (etm
->config
& (1 << 16)) ? "" : "not ");
1492 command_print(CMD
, "number of ext. inputs: %i",
1493 (int) (etm
->config
>> 17) & 0x07);
1494 command_print(CMD
, "number of ext. outputs: %i",
1495 (int) (etm
->config
>> 20) & 0x07);
1496 command_print(CMD
, "FIFO full %spresent",
1497 (int) (etm
->config
& (1 << 23)) ? "" : "not ");
1498 if (etm
->bcd_vers
< 0x20)
1499 command_print(CMD
, "protocol version: %i",
1500 (int) (etm
->config
>> 28) & 0x07);
1503 "coprocessor and memory access %ssupported",
1504 (etm
->config
& (1 << 26)) ? "" : "not ");
1505 command_print(CMD
, "trace start/stop %spresent",
1506 (etm
->config
& (1 << 26)) ? "" : "not ");
1507 command_print(CMD
, "number of context comparators: %i",
1508 (int) (etm
->config
>> 24) & 0x03);
1511 /* SYS_CONFIG isn't present before ETMv1.2 */
1512 etm_sys_config_reg
= etm_reg_lookup(etm
, ETM_SYS_CONFIG
);
1513 if (!etm_sys_config_reg
)
1516 etm_get_reg(etm_sys_config_reg
);
1517 config
= buf_get_u32(etm_sys_config_reg
->value
, 0, 32);
1519 LOG_DEBUG("ETM SYS CONFIG %08x", (unsigned) config
);
1521 max_port_size
= config
& 0x7;
1522 if (etm
->bcd_vers
>= 0x30)
1523 max_port_size
|= (config
>> 6) & 0x08;
1524 switch (max_port_size
) {
1525 /* before ETMv3.0 */
1535 /* ETMv3.0 and later*/
1555 LOG_ERROR("Illegal max_port_size");
1558 command_print(CMD
, "max. port size: %i", max_port_size
);
1560 if (etm
->bcd_vers
< 0x30) {
1561 command_print(CMD
, "half-rate clocking %ssupported",
1562 (config
& (1 << 3)) ? "" : "not ");
1563 command_print(CMD
, "full-rate clocking %ssupported",
1564 (config
& (1 << 4)) ? "" : "not ");
1565 command_print(CMD
, "normal trace format %ssupported",
1566 (config
& (1 << 5)) ? "" : "not ");
1567 command_print(CMD
, "multiplex trace format %ssupported",
1568 (config
& (1 << 6)) ? "" : "not ");
1569 command_print(CMD
, "demultiplex trace format %ssupported",
1570 (config
& (1 << 7)) ? "" : "not ");
1572 /* REVISIT show which size and format are selected ... */
1573 command_print(CMD
, "current port size %ssupported",
1574 (config
& (1 << 10)) ? "" : "not ");
1575 command_print(CMD
, "current trace format %ssupported",
1576 (config
& (1 << 11)) ? "" : "not ");
1578 if (etm
->bcd_vers
>= 0x21)
1579 command_print(CMD
, "fetch comparisons %ssupported",
1580 (config
& (1 << 17)) ? "not " : "");
1581 command_print(CMD
, "FIFO full %ssupported",
1582 (config
& (1 << 8)) ? "" : "not ");
1587 COMMAND_HANDLER(handle_etm_status_command
)
1589 struct target
*target
;
1591 struct etm_context
*etm
;
1592 trace_status_t trace_status
;
1594 target
= get_current_target(CMD_CTX
);
1595 arm
= target_to_arm(target
);
1597 command_print(CMD
, "ETM: current target isn't an ARM");
1603 command_print(CMD
, "current target doesn't have an ETM configured");
1608 if (etm
->bcd_vers
>= 0x11) {
1611 reg
= etm_reg_lookup(etm
, ETM_STATUS
);
1614 if (etm_get_reg(reg
) == ERROR_OK
) {
1615 unsigned s
= buf_get_u32(reg
->value
, 0, reg
->size
);
1617 command_print(CMD
, "etm: %s%s%s%s",
1618 /* bit(1) == progbit */
1619 (etm
->bcd_vers
>= 0x12)
1621 ? "disabled" : "enabled")
1623 ((s
& (1 << 3)) && etm
->bcd_vers
>= 0x31)
1624 ? " triggered" : "",
1625 ((s
& (1 << 2)) && etm
->bcd_vers
>= 0x12)
1626 ? " start/stop" : "",
1627 ((s
& (1 << 0)) && etm
->bcd_vers
>= 0x11)
1628 ? " untraced-overflow" : "");
1629 } /* else ignore and try showing trace port status */
1632 /* Trace Port Driver status */
1633 trace_status
= etm
->capture_driver
->status(etm
);
1634 if (trace_status
== TRACE_IDLE
)
1635 command_print(CMD
, "%s: idle", etm
->capture_driver
->name
);
1637 static char *completed
= " completed";
1638 static char *running
= " is running";
1639 static char *overflowed
= ", overflowed";
1640 static char *triggered
= ", triggered";
1642 command_print(CMD
, "%s: trace collection%s%s%s",
1643 etm
->capture_driver
->name
,
1644 (trace_status
& TRACE_RUNNING
) ? running
: completed
,
1645 (trace_status
& TRACE_OVERFLOWED
) ? overflowed
: "",
1646 (trace_status
& TRACE_TRIGGERED
) ? triggered
: "");
1648 if (etm
->trace_depth
> 0) {
1649 command_print(CMD
, "%i frames of trace data read",
1650 (int)(etm
->trace_depth
));
1657 COMMAND_HANDLER(handle_etm_image_command
)
1659 struct target
*target
;
1661 struct etm_context
*etm_ctx
;
1664 return ERROR_COMMAND_SYNTAX_ERROR
;
1666 target
= get_current_target(CMD_CTX
);
1667 arm
= target_to_arm(target
);
1669 command_print(CMD
, "ETM: current target isn't an ARM");
1675 command_print(CMD
, "current target doesn't have an ETM configured");
1679 if (etm_ctx
->image
) {
1680 image_close(etm_ctx
->image
);
1681 free(etm_ctx
->image
);
1682 command_print(CMD
, "previously loaded image found and closed");
1685 etm_ctx
->image
= malloc(sizeof(struct image
));
1686 etm_ctx
->image
->base_address_set
= 0;
1687 etm_ctx
->image
->start_address_set
= 0;
1689 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1690 if (CMD_ARGC
>= 2) {
1691 etm_ctx
->image
->base_address_set
= 1;
1692 COMMAND_PARSE_NUMBER(llong
, CMD_ARGV
[1], etm_ctx
->image
->base_address
);
1694 etm_ctx
->image
->base_address_set
= 0;
1696 if (image_open(etm_ctx
->image
, CMD_ARGV
[0],
1697 (CMD_ARGC
>= 3) ? CMD_ARGV
[2] : NULL
) != ERROR_OK
) {
1698 free(etm_ctx
->image
);
1699 etm_ctx
->image
= NULL
;
1706 COMMAND_HANDLER(handle_etm_dump_command
)
1708 struct fileio
*file
;
1709 struct target
*target
;
1711 struct etm_context
*etm_ctx
;
1715 return ERROR_COMMAND_SYNTAX_ERROR
;
1717 target
= get_current_target(CMD_CTX
);
1718 arm
= target_to_arm(target
);
1720 command_print(CMD
, "ETM: current target isn't an ARM");
1726 command_print(CMD
, "current target doesn't have an ETM configured");
1730 if (etm_ctx
->capture_driver
->status
== TRACE_IDLE
) {
1731 command_print(CMD
, "trace capture wasn't enabled, no trace data captured");
1735 if (etm_ctx
->capture_driver
->status(etm_ctx
) & TRACE_RUNNING
) {
1736 /* TODO: if on-the-fly capture is to be supported, this needs to be changed */
1737 command_print(CMD
, "trace capture not completed");
1741 /* read the trace data if it wasn't read already */
1742 if (etm_ctx
->trace_depth
== 0)
1743 etm_ctx
->capture_driver
->read_trace(etm_ctx
);
1745 if (fileio_open(&file
, CMD_ARGV
[0], FILEIO_WRITE
, FILEIO_BINARY
) != ERROR_OK
)
1748 fileio_write_u32(file
, etm_ctx
->capture_status
);
1749 fileio_write_u32(file
, etm_ctx
->control
);
1750 fileio_write_u32(file
, etm_ctx
->trace_depth
);
1752 for (i
= 0; i
< etm_ctx
->trace_depth
; i
++) {
1753 fileio_write_u32(file
, etm_ctx
->trace_data
[i
].pipestat
);
1754 fileio_write_u32(file
, etm_ctx
->trace_data
[i
].packet
);
1755 fileio_write_u32(file
, etm_ctx
->trace_data
[i
].flags
);
1763 COMMAND_HANDLER(handle_etm_load_command
)
1765 struct fileio
*file
;
1766 struct target
*target
;
1768 struct etm_context
*etm_ctx
;
1772 return ERROR_COMMAND_SYNTAX_ERROR
;
1774 target
= get_current_target(CMD_CTX
);
1775 arm
= target_to_arm(target
);
1777 command_print(CMD
, "ETM: current target isn't an ARM");
1783 command_print(CMD
, "current target doesn't have an ETM configured");
1787 if (etm_ctx
->capture_driver
->status(etm_ctx
) & TRACE_RUNNING
) {
1788 command_print(CMD
, "trace capture running, stop first");
1792 if (fileio_open(&file
, CMD_ARGV
[0], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
1796 int retval
= fileio_size(file
, &filesize
);
1797 if (retval
!= ERROR_OK
) {
1803 command_print(CMD
, "size isn't a multiple of 4, no valid trace data");
1808 if (etm_ctx
->trace_depth
> 0) {
1809 free(etm_ctx
->trace_data
);
1810 etm_ctx
->trace_data
= NULL
;
1815 fileio_read_u32(file
, &tmp
); etm_ctx
->capture_status
= tmp
;
1816 fileio_read_u32(file
, &tmp
); etm_ctx
->control
= tmp
;
1817 fileio_read_u32(file
, &etm_ctx
->trace_depth
);
1819 etm_ctx
->trace_data
= malloc(sizeof(struct etmv1_trace_data
) * etm_ctx
->trace_depth
);
1820 if (etm_ctx
->trace_data
== NULL
) {
1821 command_print(CMD
, "not enough memory to perform operation");
1826 for (i
= 0; i
< etm_ctx
->trace_depth
; i
++) {
1827 uint32_t pipestat
, packet
, flags
;
1828 fileio_read_u32(file
, &pipestat
);
1829 fileio_read_u32(file
, &packet
);
1830 fileio_read_u32(file
, &flags
);
1831 etm_ctx
->trace_data
[i
].pipestat
= pipestat
& 0xff;
1832 etm_ctx
->trace_data
[i
].packet
= packet
& 0xffff;
1833 etm_ctx
->trace_data
[i
].flags
= flags
;
1841 COMMAND_HANDLER(handle_etm_start_command
)
1843 struct target
*target
;
1845 struct etm_context
*etm_ctx
;
1846 struct reg
*etm_ctrl_reg
;
1848 target
= get_current_target(CMD_CTX
);
1849 arm
= target_to_arm(target
);
1851 command_print(CMD
, "ETM: current target isn't an ARM");
1857 command_print(CMD
, "current target doesn't have an ETM configured");
1861 /* invalidate old tracing data */
1862 etm_ctx
->capture_status
= TRACE_IDLE
;
1863 if (etm_ctx
->trace_depth
> 0) {
1864 free(etm_ctx
->trace_data
);
1865 etm_ctx
->trace_data
= NULL
;
1867 etm_ctx
->trace_depth
= 0;
1869 etm_ctrl_reg
= etm_reg_lookup(etm_ctx
, ETM_CTRL
);
1873 etm_get_reg(etm_ctrl_reg
);
1875 /* Clear programming bit (10), set port selection bit (11) */
1876 buf_set_u32(etm_ctrl_reg
->value
, 10, 2, 0x2);
1878 etm_store_reg(etm_ctrl_reg
);
1879 jtag_execute_queue();
1881 etm_ctx
->capture_driver
->start_capture(etm_ctx
);
1886 COMMAND_HANDLER(handle_etm_stop_command
)
1888 struct target
*target
;
1890 struct etm_context
*etm_ctx
;
1891 struct reg
*etm_ctrl_reg
;
1893 target
= get_current_target(CMD_CTX
);
1894 arm
= target_to_arm(target
);
1896 command_print(CMD
, "ETM: current target isn't an ARM");
1902 command_print(CMD
, "current target doesn't have an ETM configured");
1906 etm_ctrl_reg
= etm_reg_lookup(etm_ctx
, ETM_CTRL
);
1910 etm_get_reg(etm_ctrl_reg
);
1912 /* Set programming bit (10), clear port selection bit (11) */
1913 buf_set_u32(etm_ctrl_reg
->value
, 10, 2, 0x1);
1915 etm_store_reg(etm_ctrl_reg
);
1916 jtag_execute_queue();
1918 etm_ctx
->capture_driver
->stop_capture(etm_ctx
);
1923 COMMAND_HANDLER(handle_etm_trigger_debug_command
)
1925 struct target
*target
;
1927 struct etm_context
*etm
;
1929 target
= get_current_target(CMD_CTX
);
1930 arm
= target_to_arm(target
);
1932 command_print(CMD
, "ETM: %s isn't an ARM",
1933 target_name(target
));
1939 command_print(CMD
, "ETM: no ETM configured for %s",
1940 target_name(target
));
1944 if (CMD_ARGC
== 1) {
1945 struct reg
*etm_ctrl_reg
;
1948 etm_ctrl_reg
= etm_reg_lookup(etm
, ETM_CTRL
);
1952 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], dbgrq
);
1954 etm
->control
|= ETM_CTRL_DBGRQ
;
1956 etm
->control
&= ~ETM_CTRL_DBGRQ
;
1958 /* etm->control will be written to hardware
1959 * the next time an "etm start" is issued.
1961 buf_set_u32(etm_ctrl_reg
->value
, 0, 32, etm
->control
);
1964 command_print(CMD
, "ETM: %s debug halt",
1965 (etm
->control
& ETM_CTRL_DBGRQ
)
1967 : "does not trigger");
1971 COMMAND_HANDLER(handle_etm_analyze_command
)
1973 struct target
*target
;
1975 struct etm_context
*etm_ctx
;
1978 target
= get_current_target(CMD_CTX
);
1979 arm
= target_to_arm(target
);
1981 command_print(CMD
, "ETM: current target isn't an ARM");
1987 command_print(CMD
, "current target doesn't have an ETM configured");
1991 retval
= etmv1_analyze_trace(etm_ctx
, CMD
);
1992 if (retval
!= ERROR_OK
) {
1993 /* FIX! error should be reported inside etmv1_analyze_trace() */
1995 case ERROR_ETM_ANALYSIS_FAILED
:
1997 "further analysis failed (corrupted trace data or just end of data");
1999 case ERROR_TRACE_INSTRUCTION_UNAVAILABLE
:
2001 "no instruction for current address available, analysis aborted");
2003 case ERROR_TRACE_IMAGE_UNAVAILABLE
:
2004 command_print(CMD
, "no image available for trace analysis");
2007 command_print(CMD
, "unknown error");
2014 static const struct command_registration etm_config_command_handlers
[] = {
2016 /* NOTE: with ADIv5, ETMs are accessed by DAP operations,
2017 * possibly over SWD, not JTAG scanchain 6 of 'target'.
2019 * Also, these parameters don't match ETM v3+ modules...
2022 .handler
= handle_etm_config_command
,
2023 .mode
= COMMAND_CONFIG
,
2024 .help
= "Set up ETM output port.",
2025 .usage
= "target port_width port_mode clocking capture_driver",
2027 COMMAND_REGISTRATION_DONE
2029 const struct command_registration etm_command_handlers
[] = {
2032 .mode
= COMMAND_ANY
,
2033 .help
= "Embedded Trace Macrocell command group",
2035 .chain
= etm_config_command_handlers
,
2037 COMMAND_REGISTRATION_DONE
2040 static const struct command_registration etm_exec_command_handlers
[] = {
2042 .name
= "tracemode",
2043 .handler
= handle_etm_tracemode_command
,
2044 .mode
= COMMAND_EXEC
,
2045 .help
= "configure/display trace mode",
2046 .usage
= "('none'|'data'|'address'|'all') "
2048 "['enable'|'disable'] "
2049 "['enable'|'disable']",
2053 .handler
= handle_etm_info_command
,
2054 .mode
= COMMAND_EXEC
,
2056 .help
= "display info about the current target's ETM",
2060 .handler
= handle_etm_status_command
,
2061 .mode
= COMMAND_EXEC
,
2063 .help
= "display current target's ETM status",
2067 .handler
= handle_etm_start_command
,
2068 .mode
= COMMAND_EXEC
,
2070 .help
= "start ETM trace collection",
2074 .handler
= handle_etm_stop_command
,
2075 .mode
= COMMAND_EXEC
,
2077 .help
= "stop ETM trace collection",
2080 .name
= "trigger_debug",
2081 .handler
= handle_etm_trigger_debug_command
,
2082 .mode
= COMMAND_EXEC
,
2083 .help
= "enable/disable debug entry on trigger",
2084 .usage
= "['enable'|'disable']",
2088 .handler
= handle_etm_analyze_command
,
2089 .mode
= COMMAND_EXEC
,
2091 .help
= "analyze collected ETM trace",
2095 .handler
= handle_etm_image_command
,
2096 .mode
= COMMAND_EXEC
,
2097 .help
= "load image from file with optional offset",
2098 .usage
= "<file> [base address] [type]",
2102 .handler
= handle_etm_dump_command
,
2103 .mode
= COMMAND_EXEC
,
2104 .help
= "dump captured trace data to file",
2105 .usage
= "filename",
2109 .handler
= handle_etm_load_command
,
2110 .mode
= COMMAND_EXEC
,
2112 .help
= "load trace data for analysis <file>",
2114 COMMAND_REGISTRATION_DONE
2117 static int etm_register_user_commands(struct command_context
*cmd_ctx
)
2119 struct command
*etm_cmd
= command_find_in_context(cmd_ctx
, "etm");
2120 return register_commands(cmd_ctx
, etm_cmd
, etm_exec_command_handlers
);
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)