Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- calculate cycles since last executed instruction when cycle-accurate tracing is...
[openocd.git] / src / target / etm.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
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. *
9 * *
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. *
14 * *
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 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <string.h>
25
26 #include "etm.h"
27 #include "etb.h"
28
29 #include "armv4_5.h"
30 #include "arm7_9_common.h"
31 #include "arm_disassembler.h"
32 #include "arm_simulator.h"
33
34 #include "log.h"
35 #include "arm_jtag.h"
36 #include "types.h"
37 #include "binarybuffer.h"
38 #include "target.h"
39 #include "register.h"
40 #include "jtag.h"
41 #include "fileio.h"
42
43 #include <stdlib.h>
44
45 /* ETM register access functionality
46 *
47 */
48
49 bitfield_desc_t etm_comms_ctrl_bitfield_desc[] =
50 {
51 {"R", 1},
52 {"W", 1},
53 {"reserved", 26},
54 {"version", 4}
55 };
56
57 int etm_reg_arch_info[] =
58 {
59 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
60 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
61 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
62 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
63 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
64 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
65 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
66 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
67 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
68 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
69 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
70 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
71 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67,
72 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
73 };
74
75 int etm_reg_arch_size_info[] =
76 {
77 32, 32, 17, 8, 3, 9, 32, 16,
78 17, 26, 25, 8, 17, 32, 32, 17,
79 32, 32, 32, 32, 32, 32, 32, 32,
80 32, 32, 32, 32, 32, 32, 32, 32,
81 7, 7, 7, 7, 7, 7, 7, 7,
82 7, 7, 7, 7, 7, 7, 7, 7,
83 32, 32, 32, 32, 32, 32, 32, 32,
84 32, 32, 32, 32, 32, 32, 32, 32,
85 32, 32, 32, 32, 32, 32, 32, 32,
86 32, 32, 32, 32, 32, 32, 32, 32,
87 16, 16, 16, 16, 18, 18, 18, 18,
88 17, 17, 17, 17, 16, 16, 16, 16,
89 17, 17, 17, 17, 17, 17, 2,
90 17, 17, 17, 17, 32, 32, 32, 32
91 };
92
93 char* etm_reg_list[] =
94 {
95 "ETM_CTRL",
96 "ETM_CONFIG",
97 "ETM_TRIG_EVENT",
98 "ETM_MMD_CTRL",
99 "ETM_STATUS",
100 "ETM_SYS_CONFIG",
101 "ETM_TRACE_RESOURCE_CTRL",
102 "ETM_TRACE_EN_CTRL2",
103 "ETM_TRACE_EN_EVENT",
104 "ETM_TRACE_EN_CTRL1",
105 "ETM_FIFOFULL_REGION",
106 "ETM_FIFOFULL_LEVEL",
107 "ETM_VIEWDATA_EVENT",
108 "ETM_VIEWDATA_CTRL1",
109 "ETM_VIEWDATA_CTRL2",
110 "ETM_VIEWDATA_CTRL3",
111 "ETM_ADDR_COMPARATOR_VALUE1",
112 "ETM_ADDR_COMPARATOR_VALUE2",
113 "ETM_ADDR_COMPARATOR_VALUE3",
114 "ETM_ADDR_COMPARATOR_VALUE4",
115 "ETM_ADDR_COMPARATOR_VALUE5",
116 "ETM_ADDR_COMPARATOR_VALUE6",
117 "ETM_ADDR_COMPARATOR_VALUE7",
118 "ETM_ADDR_COMPARATOR_VALUE8",
119 "ETM_ADDR_COMPARATOR_VALUE9",
120 "ETM_ADDR_COMPARATOR_VALUE10",
121 "ETM_ADDR_COMPARATOR_VALUE11",
122 "ETM_ADDR_COMPARATOR_VALUE12",
123 "ETM_ADDR_COMPARATOR_VALUE13",
124 "ETM_ADDR_COMPARATOR_VALUE14",
125 "ETM_ADDR_COMPARATOR_VALUE15",
126 "ETM_ADDR_COMPARATOR_VALUE16",
127 "ETM_ADDR_ACCESS_TYPE1",
128 "ETM_ADDR_ACCESS_TYPE2",
129 "ETM_ADDR_ACCESS_TYPE3",
130 "ETM_ADDR_ACCESS_TYPE4",
131 "ETM_ADDR_ACCESS_TYPE5",
132 "ETM_ADDR_ACCESS_TYPE6",
133 "ETM_ADDR_ACCESS_TYPE7",
134 "ETM_ADDR_ACCESS_TYPE8",
135 "ETM_ADDR_ACCESS_TYPE9",
136 "ETM_ADDR_ACCESS_TYPE10",
137 "ETM_ADDR_ACCESS_TYPE11",
138 "ETM_ADDR_ACCESS_TYPE12",
139 "ETM_ADDR_ACCESS_TYPE13",
140 "ETM_ADDR_ACCESS_TYPE14",
141 "ETM_ADDR_ACCESS_TYPE15",
142 "ETM_ADDR_ACCESS_TYPE16",
143 "ETM_DATA_COMPARATOR_VALUE1",
144 "ETM_DATA_COMPARATOR_VALUE2",
145 "ETM_DATA_COMPARATOR_VALUE3",
146 "ETM_DATA_COMPARATOR_VALUE4",
147 "ETM_DATA_COMPARATOR_VALUE5",
148 "ETM_DATA_COMPARATOR_VALUE6",
149 "ETM_DATA_COMPARATOR_VALUE7",
150 "ETM_DATA_COMPARATOR_VALUE8",
151 "ETM_DATA_COMPARATOR_VALUE9",
152 "ETM_DATA_COMPARATOR_VALUE10",
153 "ETM_DATA_COMPARATOR_VALUE11",
154 "ETM_DATA_COMPARATOR_VALUE12",
155 "ETM_DATA_COMPARATOR_VALUE13",
156 "ETM_DATA_COMPARATOR_VALUE14",
157 "ETM_DATA_COMPARATOR_VALUE15",
158 "ETM_DATA_COMPARATOR_VALUE16",
159 "ETM_DATA_COMPARATOR_MASK1",
160 "ETM_DATA_COMPARATOR_MASK2",
161 "ETM_DATA_COMPARATOR_MASK3",
162 "ETM_DATA_COMPARATOR_MASK4",
163 "ETM_DATA_COMPARATOR_MASK5",
164 "ETM_DATA_COMPARATOR_MASK6",
165 "ETM_DATA_COMPARATOR_MASK7",
166 "ETM_DATA_COMPARATOR_MASK8",
167 "ETM_DATA_COMPARATOR_MASK9",
168 "ETM_DATA_COMPARATOR_MASK10",
169 "ETM_DATA_COMPARATOR_MASK11",
170 "ETM_DATA_COMPARATOR_MASK12",
171 "ETM_DATA_COMPARATOR_MASK13",
172 "ETM_DATA_COMPARATOR_MASK14",
173 "ETM_DATA_COMPARATOR_MASK15",
174 "ETM_DATA_COMPARATOR_MASK16",
175 "ETM_COUNTER_INITAL_VALUE1",
176 "ETM_COUNTER_INITAL_VALUE2",
177 "ETM_COUNTER_INITAL_VALUE3",
178 "ETM_COUNTER_INITAL_VALUE4",
179 "ETM_COUNTER_ENABLE1",
180 "ETM_COUNTER_ENABLE2",
181 "ETM_COUNTER_ENABLE3",
182 "ETM_COUNTER_ENABLE4",
183 "ETM_COUNTER_RELOAD_VALUE1",
184 "ETM_COUNTER_RELOAD_VALUE2",
185 "ETM_COUNTER_RELOAD_VALUE3",
186 "ETM_COUNTER_RELOAD_VALUE4",
187 "ETM_COUNTER_VALUE1",
188 "ETM_COUNTER_VALUE2",
189 "ETM_COUNTER_VALUE3",
190 "ETM_COUNTER_VALUE4",
191 "ETM_SEQUENCER_CTRL1",
192 "ETM_SEQUENCER_CTRL2",
193 "ETM_SEQUENCER_CTRL3",
194 "ETM_SEQUENCER_CTRL4",
195 "ETM_SEQUENCER_CTRL5",
196 "ETM_SEQUENCER_CTRL6",
197 "ETM_SEQUENCER_STATE",
198 "ETM_EXTERNAL_OUTPUT1",
199 "ETM_EXTERNAL_OUTPUT2",
200 "ETM_EXTERNAL_OUTPUT3",
201 "ETM_EXTERNAL_OUTPUT4",
202 "ETM_CONTEXTID_COMPARATOR_VALUE1",
203 "ETM_CONTEXTID_COMPARATOR_VALUE2",
204 "ETM_CONTEXTID_COMPARATOR_VALUE3",
205 "ETM_CONTEXTID_COMPARATOR_MASK"
206 };
207
208 int etm_reg_arch_type = -1;
209
210 int etm_get_reg(reg_t *reg);
211 int etm_set_reg(reg_t *reg, u32 value);
212 int etm_set_reg_w_exec(reg_t *reg, u8 *buf);
213
214 int etm_write_reg(reg_t *reg, u32 value);
215 int etm_read_reg(reg_t *reg);
216
217 command_t *etm_cmd = NULL;
218
219 reg_cache_t* etm_build_reg_cache(target_t *target, arm_jtag_t *jtag_info, etm_context_t *etm_ctx)
220 {
221 reg_cache_t *reg_cache = malloc(sizeof(reg_cache_t));
222 reg_t *reg_list = NULL;
223 etm_reg_t *arch_info = NULL;
224 int num_regs = sizeof(etm_reg_arch_info)/sizeof(int);
225 int i;
226 u32 etm_ctrl_value;
227
228 /* register a register arch-type for etm registers only once */
229 if (etm_reg_arch_type == -1)
230 etm_reg_arch_type = register_reg_arch_type(etm_get_reg, etm_set_reg_w_exec);
231
232 /* the actual registers are kept in two arrays */
233 reg_list = calloc(num_regs, sizeof(reg_t));
234 arch_info = calloc(num_regs, sizeof(etm_reg_t));
235
236 /* fill in values for the reg cache */
237 reg_cache->name = "etm registers";
238 reg_cache->next = NULL;
239 reg_cache->reg_list = reg_list;
240 reg_cache->num_regs = num_regs;
241
242 /* set up registers */
243 for (i = 0; i < num_regs; i++)
244 {
245 reg_list[i].name = etm_reg_list[i];
246 reg_list[i].size = 32;
247 reg_list[i].dirty = 0;
248 reg_list[i].valid = 0;
249 reg_list[i].bitfield_desc = NULL;
250 reg_list[i].num_bitfields = 0;
251 reg_list[i].value = calloc(1, 4);
252 reg_list[i].arch_info = &arch_info[i];
253 reg_list[i].arch_type = etm_reg_arch_type;
254 reg_list[i].size = etm_reg_arch_size_info[i];
255 arch_info[i].addr = etm_reg_arch_info[i];
256 arch_info[i].jtag_info = jtag_info;
257 }
258
259 /* initialize some ETM control register settings */
260 etm_get_reg(&reg_list[ETM_CTRL]);
261 etm_ctrl_value = buf_get_u32(reg_list[ETM_CTRL].value, 0, reg_list[ETM_CTRL].size);
262
263 /* clear the ETM powerdown bit (0) */
264 etm_ctrl_value &= ~0x1;
265
266 /* configure port width (6:4), mode (17:16) and clocking (13) */
267 etm_ctrl_value = (etm_ctrl_value &
268 ~ETM_PORT_WIDTH_MASK & ~ETM_PORT_MODE_MASK & ~ETM_PORT_CLOCK_MASK)
269 | etm_ctx->portmode;
270
271 buf_set_u32(reg_list[ETM_CTRL].value, 0, reg_list[ETM_CTRL].size, etm_ctrl_value);
272 etm_store_reg(&reg_list[ETM_CTRL]);
273
274 /* the ETM might have an ETB connected */
275 if (strcmp(etm_ctx->capture_driver->name, "etb") == 0)
276 {
277 etb_t *etb = etm_ctx->capture_driver_priv;
278
279 if (!etb)
280 {
281 ERROR("etb selected as etm capture driver, but no ETB configured");
282 return ERROR_OK;
283 }
284
285 reg_cache->next = etb_build_reg_cache(etb);
286
287 etb->reg_cache = reg_cache->next;
288 }
289
290 if (etm_ctx->capture_driver->init(etm_ctx) != ERROR_OK)
291 {
292 ERROR("ETM capture driver initialization failed");
293 exit(-1);
294 }
295
296 return reg_cache;
297 }
298
299 int etm_get_reg(reg_t *reg)
300 {
301 if (etm_read_reg(reg) != ERROR_OK)
302 {
303 ERROR("BUG: error scheduling etm register read");
304 exit(-1);
305 }
306
307 if (jtag_execute_queue() != ERROR_OK)
308 {
309 ERROR("register read failed");
310 }
311
312 return ERROR_OK;
313 }
314
315 int etm_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask)
316 {
317 etm_reg_t *etm_reg = reg->arch_info;
318 u8 reg_addr = etm_reg->addr & 0x7f;
319 scan_field_t fields[3];
320
321 DEBUG("%i", etm_reg->addr);
322
323 jtag_add_end_state(TAP_RTI);
324 arm_jtag_scann(etm_reg->jtag_info, 0x6);
325 arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr, NULL);
326
327 fields[0].device = etm_reg->jtag_info->chain_pos;
328 fields[0].num_bits = 32;
329 fields[0].out_value = reg->value;
330 fields[0].out_mask = NULL;
331 fields[0].in_value = NULL;
332 fields[0].in_check_value = NULL;
333 fields[0].in_check_mask = NULL;
334 fields[0].in_handler = NULL;
335 fields[0].in_handler_priv = NULL;
336
337 fields[1].device = etm_reg->jtag_info->chain_pos;
338 fields[1].num_bits = 7;
339 fields[1].out_value = malloc(1);
340 buf_set_u32(fields[1].out_value, 0, 7, reg_addr);
341 fields[1].out_mask = NULL;
342 fields[1].in_value = NULL;
343 fields[1].in_check_value = NULL;
344 fields[1].in_check_mask = NULL;
345 fields[1].in_handler = NULL;
346 fields[1].in_handler_priv = NULL;
347
348 fields[2].device = etm_reg->jtag_info->chain_pos;
349 fields[2].num_bits = 1;
350 fields[2].out_value = malloc(1);
351 buf_set_u32(fields[2].out_value, 0, 1, 0);
352 fields[2].out_mask = NULL;
353 fields[2].in_value = NULL;
354 fields[2].in_check_value = NULL;
355 fields[2].in_check_mask = NULL;
356 fields[2].in_handler = NULL;
357 fields[2].in_handler_priv = NULL;
358
359 jtag_add_dr_scan(3, fields, -1, NULL);
360
361 fields[0].in_value = reg->value;
362 fields[0].in_check_value = check_value;
363 fields[0].in_check_mask = check_mask;
364
365 jtag_add_dr_scan(3, fields, -1, NULL);
366
367 free(fields[1].out_value);
368 free(fields[2].out_value);
369
370 return ERROR_OK;
371 }
372
373 int etm_read_reg(reg_t *reg)
374 {
375 return etm_read_reg_w_check(reg, NULL, NULL);
376 }
377
378 int etm_set_reg(reg_t *reg, u32 value)
379 {
380 if (etm_write_reg(reg, value) != ERROR_OK)
381 {
382 ERROR("BUG: error scheduling etm register write");
383 exit(-1);
384 }
385
386 buf_set_u32(reg->value, 0, reg->size, value);
387 reg->valid = 1;
388 reg->dirty = 0;
389
390 return ERROR_OK;
391 }
392
393 int etm_set_reg_w_exec(reg_t *reg, u8 *buf)
394 {
395 etm_set_reg(reg, buf_get_u32(buf, 0, reg->size));
396
397 if (jtag_execute_queue() != ERROR_OK)
398 {
399 ERROR("register write failed");
400 exit(-1);
401 }
402 return ERROR_OK;
403 }
404
405 int etm_write_reg(reg_t *reg, u32 value)
406 {
407 etm_reg_t *etm_reg = reg->arch_info;
408 u8 reg_addr = etm_reg->addr & 0x7f;
409 scan_field_t fields[3];
410
411 DEBUG("%i: 0x%8.8x", etm_reg->addr, value);
412
413 jtag_add_end_state(TAP_RTI);
414 arm_jtag_scann(etm_reg->jtag_info, 0x6);
415 arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr, NULL);
416
417 fields[0].device = etm_reg->jtag_info->chain_pos;
418 fields[0].num_bits = 32;
419 fields[0].out_value = malloc(4);
420 buf_set_u32(fields[0].out_value, 0, 32, value);
421 fields[0].out_mask = NULL;
422 fields[0].in_value = NULL;
423 fields[0].in_check_value = NULL;
424 fields[0].in_check_mask = NULL;
425 fields[0].in_handler = NULL;
426 fields[0].in_handler_priv = NULL;
427
428 fields[1].device = etm_reg->jtag_info->chain_pos;
429 fields[1].num_bits = 7;
430 fields[1].out_value = malloc(1);
431 buf_set_u32(fields[1].out_value, 0, 7, reg_addr);
432 fields[1].out_mask = NULL;
433 fields[1].in_value = NULL;
434 fields[1].in_check_value = NULL;
435 fields[1].in_check_mask = NULL;
436 fields[1].in_handler = NULL;
437 fields[1].in_handler_priv = NULL;
438
439 fields[2].device = etm_reg->jtag_info->chain_pos;
440 fields[2].num_bits = 1;
441 fields[2].out_value = malloc(1);
442 buf_set_u32(fields[2].out_value, 0, 1, 1);
443 fields[2].out_mask = NULL;
444 fields[2].in_value = NULL;
445 fields[2].in_check_value = NULL;
446 fields[2].in_check_mask = NULL;
447 fields[2].in_handler = NULL;
448 fields[2].in_handler_priv = NULL;
449
450 jtag_add_dr_scan(3, fields, -1, NULL);
451
452 free(fields[0].out_value);
453 free(fields[1].out_value);
454 free(fields[2].out_value);
455
456 return ERROR_OK;
457 }
458
459 int etm_store_reg(reg_t *reg)
460 {
461 return etm_write_reg(reg, buf_get_u32(reg->value, 0, reg->size));
462 }
463
464 /* ETM trace analysis functionality
465 *
466 */
467 extern etm_capture_driver_t etb_capture_driver;
468 extern etm_capture_driver_t etm_dummy_capture_driver;
469 #if BUILD_OOCD_TRACE == 1
470 extern etm_capture_driver_t oocd_trace_capture_driver;
471 #endif
472
473 etm_capture_driver_t *etm_capture_drivers[] =
474 {
475 &etb_capture_driver,
476 &etm_dummy_capture_driver,
477 #if BUILD_OOCD_TRACE == 1
478 &oocd_trace_capture_driver,
479 #endif
480 NULL
481 };
482
483 char *etmv1v1_branch_reason_strings[] =
484 {
485 "normal PC change",
486 "tracing enabled",
487 "trace restarted after overflow",
488 "exit from debug",
489 "periodic synchronization",
490 "reserved",
491 "reserved",
492 "reserved",
493 };
494
495 int etm_read_instruction(etm_context_t *ctx, arm_instruction_t *instruction)
496 {
497 int i;
498 int section = -1;
499 u32 size_read;
500 u32 opcode;
501 int retval;
502
503 if (!ctx->image)
504 return ERROR_TRACE_IMAGE_UNAVAILABLE;
505
506 /* search for the section the current instruction belongs to */
507 for (i = 0; i < ctx->image->num_sections; i++)
508 {
509 if ((ctx->image->sections[i].base_address <= ctx->current_pc) &&
510 (ctx->image->sections[i].base_address + ctx->image->sections[i].size > ctx->current_pc))
511 {
512 section = i;
513 break;
514 }
515 }
516
517 if (section == -1)
518 {
519 /* current instruction couldn't be found in the image */
520 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
521 }
522
523 if (ctx->core_state == ARMV4_5_STATE_ARM)
524 {
525 u8 buf[4];
526 if ((retval = image_read_section(ctx->image, section,
527 ctx->current_pc - ctx->image->sections[section].base_address,
528 4, buf, &size_read)) != ERROR_OK)
529 {
530 ERROR("error while reading instruction: %i", retval);
531 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
532 }
533 opcode = target_buffer_get_u32(ctx->target, buf);
534 arm_evaluate_opcode(opcode, ctx->current_pc, instruction);
535 }
536 else if (ctx->core_state == ARMV4_5_STATE_THUMB)
537 {
538 u8 buf[2];
539 if ((retval = image_read_section(ctx->image, section,
540 ctx->current_pc - ctx->image->sections[section].base_address,
541 2, buf, &size_read)) != ERROR_OK)
542 {
543 ERROR("error while reading instruction: %i", retval);
544 return ERROR_TRACE_INSTRUCTION_UNAVAILABLE;
545 }
546 opcode = target_buffer_get_u16(ctx->target, buf);
547 thumb_evaluate_opcode(opcode, ctx->current_pc, instruction);
548 }
549 else if (ctx->core_state == ARMV4_5_STATE_JAZELLE)
550 {
551 ERROR("BUG: tracing of jazelle code not supported");
552 exit(-1);
553 }
554 else
555 {
556 ERROR("BUG: unknown core state encountered");
557 exit(-1);
558 }
559
560 return ERROR_OK;
561 }
562
563 int etmv1_next_packet(etm_context_t *ctx, u8 *packet, int apo)
564 {
565 while (ctx->data_index < ctx->trace_depth)
566 {
567 /* if the caller specified an address packet offset, skip until the
568 * we reach the n-th cycle marked with tracesync */
569 if (apo > 0)
570 {
571 if (ctx->trace_data[ctx->data_index].flags & ETMV1_TRACESYNC_CYCLE)
572 apo--;
573
574 if (apo > 0)
575 {
576 ctx->data_index++;
577 ctx->data_half = 0;
578 }
579 continue;
580 }
581
582 /* no tracedata output during a TD cycle
583 * or in a trigger cycle */
584 if ((ctx->trace_data[ctx->data_index].pipestat == STAT_TD)
585 || (ctx->trace_data[ctx->data_index].flags & ETMV1_TRIGGER_CYCLE))
586 {
587 ctx->data_index++;
588 ctx->data_half = 0;
589 continue;
590 }
591
592 if ((ctx->portmode & ETM_PORT_WIDTH_MASK) == ETM_PORT_16BIT)
593 {
594 if (ctx->data_half == 0)
595 {
596 *packet = ctx->trace_data[ctx->data_index].packet & 0xff;
597 ctx->data_half = 1;
598 }
599 else
600 {
601 *packet = (ctx->trace_data[ctx->data_index].packet & 0xff00) >> 8;
602 ctx->data_half = 0;
603 ctx->data_index++;
604 }
605 }
606 else if ((ctx->portmode & ETM_PORT_WIDTH_MASK) == ETM_PORT_8BIT)
607 {
608 *packet = ctx->trace_data[ctx->data_index].packet & 0xff;
609 ctx->data_index++;
610 }
611 else
612 {
613 /* on a 4-bit port, a packet will be output during two consecutive cycles */
614 if (ctx->data_index > (ctx->trace_depth - 2))
615 return -1;
616
617 *packet = ctx->trace_data[ctx->data_index].packet & 0xf;
618 *packet |= (ctx->trace_data[ctx->data_index + 1].packet & 0xf) << 4;
619 ctx->data_index += 2;
620 }
621
622 return 0;
623 }
624
625 return -1;
626 }
627
628 int etmv1_branch_address(etm_context_t *ctx)
629 {
630 int retval;
631 u8 packet;
632 int shift = 0;
633 int apo;
634 int i;
635
636 /* quit analysis if less than two cycles are left in the trace
637 * because we can't extract the APO */
638 if (ctx->data_index > (ctx->trace_depth - 2))
639 return -1;
640
641 /* a BE could be output during an APO cycle, skip the current
642 * and continue with the new one */
643 if (ctx->trace_data[ctx->pipe_index + 1].pipestat & 0x4)
644 return 1;
645 if (ctx->trace_data[ctx->pipe_index + 2].pipestat & 0x4)
646 return 2;
647
648 /* address packet offset encoded in the next two cycles' pipestat bits */
649 apo = ctx->trace_data[ctx->pipe_index + 1].pipestat & 0x3;
650 apo |= (ctx->trace_data[ctx->pipe_index + 2].pipestat & 0x3) << 2;
651
652 /* count number of tracesync cycles between current pipe_index and data_index
653 * i.e. the number of tracesyncs that data_index already passed by
654 * to subtract them from the APO */
655 for (i = ctx->pipe_index; i < ctx->data_index; i++)
656 {
657 if (ctx->trace_data[ctx->pipe_index + 1].pipestat & ETMV1_TRACESYNC_CYCLE)
658 apo--;
659 }
660
661 /* extract up to four 7-bit packets */
662 do {
663 if ((retval = etmv1_next_packet(ctx, &packet, (shift == 0) ? apo + 1 : 0)) != 0)
664 return -1;
665 ctx->last_branch &= ~(0x7f << shift);
666 ctx->last_branch |= (packet & 0x7f) << shift;
667 shift += 7;
668 } while ((packet & 0x80) && (shift < 28));
669
670 /* one last packet holding 4 bits of the address, plus the branch reason code */
671 if ((shift == 28) && (packet & 0x80))
672 {
673 if ((retval = etmv1_next_packet(ctx, &packet, 0)) != 0)
674 return -1;
675 ctx->last_branch &= 0x0fffffff;
676 ctx->last_branch |= (packet & 0x0f) << 28;
677 ctx->last_branch_reason = (packet & 0x70) >> 4;
678 shift += 4;
679 }
680 else
681 {
682 ctx->last_branch_reason = 0;
683 }
684
685 if (shift == 32)
686 {
687 ctx->pc_ok = 1;
688 }
689
690 /* if a full address was output, we might have branched into Jazelle state */
691 if ((shift == 32) && (packet & 0x80))
692 {
693 ctx->core_state = ARMV4_5_STATE_JAZELLE;
694 }
695 else
696 {
697 /* if we didn't branch into Jazelle state, the current processor state is
698 * encoded in bit 0 of the branch target address */
699 if (ctx->last_branch & 0x1)
700 {
701 ctx->core_state = ARMV4_5_STATE_THUMB;
702 ctx->last_branch &= ~0x1;
703 }
704 else
705 {
706 ctx->core_state = ARMV4_5_STATE_ARM;
707 ctx->last_branch &= ~0x3;
708 }
709 }
710
711 return 0;
712 }
713
714 int etmv1_data(etm_context_t *ctx, int size, u32 *data)
715 {
716 int j;
717 u8 buf[4];
718 int retval;
719
720 for (j = 0; j < size; j++)
721 {
722 if ((retval = etmv1_next_packet(ctx, &buf[j], 0)) != 0)
723 return -1;
724 }
725
726 if (size == 8)
727 ERROR("TODO: add support for 64-bit values");
728 else if (size == 4)
729 *data = target_buffer_get_u32(ctx->target, buf);
730 else if (size == 2)
731 *data = target_buffer_get_u16(ctx->target, buf);
732 else if (size == 1)
733 *data = buf[0];
734
735 return 0;
736 }
737
738 int etmv1_analyze_trace(etm_context_t *ctx, struct command_context_s *cmd_ctx)
739 {
740 int retval;
741 arm_instruction_t instruction;
742
743 /* read the trace data if it wasn't read already */
744 if (ctx->trace_depth == 0)
745 ctx->capture_driver->read_trace(ctx);
746
747 /* start at the beginning of the captured trace */
748 ctx->pipe_index = 0;
749 ctx->data_index = 0;
750 ctx->data_half = 0;
751
752 /* neither the PC nor the data pointer are valid */
753 ctx->pc_ok = 0;
754 ctx->ptr_ok = 0;
755
756 while (ctx->pipe_index < ctx->trace_depth)
757 {
758 u8 pipestat = ctx->trace_data[ctx->pipe_index].pipestat;
759 u32 next_pc = ctx->current_pc;
760 u32 old_data_index = ctx->data_index;
761 u32 old_data_half = ctx->data_half;
762 u32 old_index = ctx->pipe_index;
763 u32 cycles = 0;
764
765 if (ctx->trace_data[ctx->pipe_index].flags & ETMV1_TRIGGER_CYCLE)
766 {
767 command_print(cmd_ctx, "--- trigger ---");
768 }
769
770 /* if we don't have a valid pc skip until we reach an indirect branch */
771 if ((!ctx->pc_ok) && (pipestat != STAT_BE))
772 {
773 if (pipestat == STAT_IE)
774 ctx->last_instruction = ctx->pipe_index;
775 ctx->pipe_index++;
776 continue;
777 }
778
779 /* any indirect branch could have interrupted instruction flow
780 * - the branch reason code could indicate a trace discontinuity
781 * - a branch to the exception vectors indicates an exception
782 */
783 if ((pipestat == STAT_BE) || (pipestat == STAT_BD))
784 {
785 /* backup current data index, to be able to consume the branch address
786 * before examining data address and values
787 */
788 old_data_index = ctx->data_index;
789 old_data_half = ctx->data_half;
790
791 if ((retval = etmv1_branch_address(ctx)) != 0)
792 {
793 /* negative return value from etmv1_branch_address means we ran out of packets,
794 * quit analysing the trace */
795 if (retval < 0)
796 break;
797
798 /* a positive return values means the current branch was abandoned,
799 * and a new branch was encountered in cycle ctx->pipe_index + retval;
800 */
801 WARNING("abandoned branch encountered, correctnes of analysis uncertain");
802 ctx->pipe_index += retval;
803 continue;
804 }
805
806 /* skip over APO cycles */
807 ctx->pipe_index += 2;
808
809 switch (ctx->last_branch_reason)
810 {
811 case 0x0: /* normal PC change */
812 next_pc = ctx->last_branch;
813 ctx->last_instruction = old_index;
814 break;
815 case 0x1: /* tracing enabled */
816 command_print(cmd_ctx, "--- tracing enabled at 0x%8.8x ---", ctx->last_branch);
817 ctx->current_pc = ctx->last_branch;
818 ctx->pipe_index++;
819 ctx->last_instruction = old_index;
820 continue;
821 break;
822 case 0x2: /* trace restarted after FIFO overflow */
823 command_print(cmd_ctx, "--- trace restarted after FIFO overflow at 0x%8.8x ---", ctx->last_branch);
824 ctx->current_pc = ctx->last_branch;
825 ctx->pipe_index++;
826 ctx->last_instruction = old_index;
827 continue;
828 break;
829 case 0x3: /* exit from debug state */
830 command_print(cmd_ctx, "--- exit from debug state at 0x%8.8x ---", ctx->last_branch);
831 ctx->current_pc = ctx->last_branch;
832 ctx->pipe_index++;
833 ctx->last_instruction = old_index;
834 continue;
835 break;
836 case 0x4: /* periodic synchronization point */
837 next_pc = ctx->last_branch;
838 ctx->last_instruction = old_index;
839 break;
840 default: /* reserved */
841 ERROR("BUG: branch reason code 0x%x is reserved", ctx->last_branch_reason);
842 exit(-1);
843 break;
844 }
845
846 /* if we got here the branch was a normal PC change
847 * (or a periodic synchronization point, which means the same for that matter)
848 * if we didn't accquire a complete PC continue with the next cycle
849 */
850 if (!ctx->pc_ok)
851 continue;
852
853 /* indirect branch to the exception vector means an exception occured */
854 if (((ctx->last_branch >= 0x0) && (ctx->last_branch <= 0x20))
855 || ((ctx->last_branch >= 0xffff0000) && (ctx->last_branch <= 0xffff0020)))
856 {
857 ctx->last_instruction = old_index;
858
859 if ((ctx->last_branch & 0xff) == 0x10)
860 {
861 command_print(cmd_ctx, "data abort");
862 }
863 else
864 {
865 command_print(cmd_ctx, "exception vector 0x%2.2x", ctx->last_branch);
866 ctx->current_pc = ctx->last_branch;
867 ctx->pipe_index++;
868 continue;
869 }
870 }
871 }
872
873 /* an instruction was executed (or not, depending on the condition flags)
874 * retrieve it from the image for displaying */
875 if (ctx->pc_ok && (pipestat != STAT_WT) && (pipestat != STAT_TD) &&
876 !(((pipestat == STAT_BE) || (pipestat == STAT_BD)) &&
877 ((ctx->last_branch_reason != 0x0) && (ctx->last_branch_reason != 0x4))))
878 {
879 if ((retval = etm_read_instruction(ctx, &instruction)) != ERROR_OK)
880 {
881 /* can't continue tracing with no image available */
882 if (retval == ERROR_TRACE_IMAGE_UNAVAILABLE)
883 {
884 return retval;
885 }
886 else if (retval == ERROR_TRACE_INSTRUCTION_UNAVAILABLE)
887 {
888 /* TODO: handle incomplete images */
889 }
890 }
891
892 cycles = old_index - ctx->last_instruction;
893 ctx->last_instruction = old_index;
894 }
895
896 if ((pipestat == STAT_ID) || (pipestat == STAT_BD))
897 {
898 u32 new_data_index = ctx->data_index;
899 u32 new_data_half = ctx->data_half;
900
901 /* in case of a branch with data, the branch target address was consumed before
902 * we temporarily go back to the saved data index */
903 if (pipestat == STAT_BD)
904 {
905 ctx->data_index = old_data_index;
906 ctx->data_half = old_data_half;
907 }
908
909 if (ctx->tracemode & ETMV1_TRACE_ADDR)
910 {
911 u8 packet;
912 int shift = 0;
913
914 do {
915 if ((retval = etmv1_next_packet(ctx, &packet, 0)) != 0)
916 return -1;
917 ctx->last_ptr &= ~(0x7f << shift);
918 ctx->last_ptr |= (packet & 0x7f) << shift;
919 shift += 7;
920 } while ((packet & 0x80) && (shift < 32));
921
922 if (shift >= 32)
923 ctx->ptr_ok = 1;
924
925 if (ctx->ptr_ok)
926 {
927 command_print(cmd_ctx, "address: 0x%8.8x", ctx->last_ptr);
928 }
929 }
930
931 if (ctx->tracemode & ETMV1_TRACE_DATA)
932 {
933 if ((instruction.type == ARM_LDM) || (instruction.type == ARM_STM))
934 {
935 int i;
936 for (i = 0; i < 16; i++)
937 {
938 if (instruction.info.load_store_multiple.register_list & (1 << i))
939 {
940 u32 data;
941 if (etmv1_data(ctx, 4, &data) != 0)
942 return -1;
943 command_print(cmd_ctx, "data: 0x%8.8x", data);
944 }
945 }
946 }
947 else if ((instruction.type >= ARM_LDR) && (instruction.type <= ARM_STRH))
948 {
949 u32 data;
950 if (etmv1_data(ctx, arm_access_size(&instruction), &data) != 0)
951 return -1;
952 command_print(cmd_ctx, "data: 0x%8.8x", data);
953 }
954 }
955
956 /* restore data index after consuming BD address and data */
957 if (pipestat == STAT_BD)
958 {
959 ctx->data_index = new_data_index;
960 ctx->data_half = new_data_half;
961 }
962 }
963
964 /* adjust PC */
965 if ((pipestat == STAT_IE) || (pipestat == STAT_ID))
966 {
967 if (((instruction.type == ARM_B) ||
968 (instruction.type == ARM_BL) ||
969 (instruction.type == ARM_BLX)) &&
970 (instruction.info.b_bl_bx_blx.target_address != -1))
971 {
972 next_pc = instruction.info.b_bl_bx_blx.target_address;
973 }
974 else
975 {
976 next_pc += (ctx->core_state == ARMV4_5_STATE_ARM) ? 4 : 2;
977 }
978 }
979 else if (pipestat == STAT_IN)
980 {
981 next_pc += (ctx->core_state == ARMV4_5_STATE_ARM) ? 4 : 2;
982 }
983
984 if ((pipestat != STAT_TD) && (pipestat != STAT_WT))
985 {
986 char cycles_text[32] = "";
987
988 /* if the trace was captured with cycle accurate tracing enabled,
989 * output the number of cycles since the last executed instruction
990 */
991 if (ctx->tracemode & ETMV1_CYCLE_ACCURATE)
992 {
993 snprintf(cycles_text, 32, " (%i %s)",
994 cycles,
995 (cycles == 1) ? "cycle" : "cycles");
996 }
997
998 command_print(cmd_ctx, "%s%s%s",
999 instruction.text,
1000 (pipestat == STAT_IN) ? " (not executed)" : "",
1001 cycles_text);
1002
1003 ctx->current_pc = next_pc;
1004
1005 /* packets for an instruction don't start on or before the preceding
1006 * functional pipestat (i.e. other than WT or TD)
1007 */
1008 if (ctx->data_index <= ctx->pipe_index)
1009 {
1010 ctx->data_index = ctx->pipe_index + 1;
1011 ctx->data_half = 0;
1012 }
1013 }
1014
1015 ctx->pipe_index += 1;
1016 }
1017
1018 return ERROR_OK;
1019 }
1020
1021 int handle_etm_tracemode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1022 {
1023 target_t *target;
1024 armv4_5_common_t *armv4_5;
1025 arm7_9_common_t *arm7_9;
1026 etmv1_tracemode_t tracemode;
1027
1028 target = get_current_target(cmd_ctx);
1029
1030 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1031 {
1032 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1033 return ERROR_OK;
1034 }
1035
1036 if (!arm7_9->etm_ctx)
1037 {
1038 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1039 return ERROR_OK;
1040 }
1041
1042 tracemode = arm7_9->etm_ctx->tracemode;
1043
1044 if (argc == 4)
1045 {
1046 if (strcmp(args[0], "none") == 0)
1047 {
1048 tracemode = ETMV1_TRACE_NONE;
1049 }
1050 else if (strcmp(args[0], "data") == 0)
1051 {
1052 tracemode = ETMV1_TRACE_DATA;
1053 }
1054 else if (strcmp(args[0], "address") == 0)
1055 {
1056 tracemode = ETMV1_TRACE_ADDR;
1057 }
1058 else if (strcmp(args[0], "all") == 0)
1059 {
1060 tracemode = ETMV1_TRACE_DATA | ETMV1_TRACE_ADDR;
1061 }
1062 else
1063 {
1064 command_print(cmd_ctx, "invalid option '%s'", args[0]);
1065 return ERROR_OK;
1066 }
1067
1068 switch (strtol(args[1], NULL, 0))
1069 {
1070 case 0:
1071 tracemode |= ETMV1_CONTEXTID_NONE;
1072 break;
1073 case 8:
1074 tracemode |= ETMV1_CONTEXTID_8;
1075 break;
1076 case 16:
1077 tracemode |= ETMV1_CONTEXTID_16;
1078 break;
1079 case 32:
1080 tracemode |= ETMV1_CONTEXTID_32;
1081 break;
1082 default:
1083 command_print(cmd_ctx, "invalid option '%s'", args[1]);
1084 return ERROR_OK;
1085 }
1086
1087 if (strcmp(args[2], "enable") == 0)
1088 {
1089 tracemode |= ETMV1_CYCLE_ACCURATE;
1090 }
1091 else if (strcmp(args[2], "disable") == 0)
1092 {
1093 tracemode |= 0;
1094 }
1095 else
1096 {
1097 command_print(cmd_ctx, "invalid option '%s'", args[2]);
1098 return ERROR_OK;
1099 }
1100
1101 if (strcmp(args[3], "enable") == 0)
1102 {
1103 tracemode |= ETMV1_BRANCH_OUTPUT;
1104 }
1105 else if (strcmp(args[3], "disable") == 0)
1106 {
1107 tracemode |= 0;
1108 }
1109 else
1110 {
1111 command_print(cmd_ctx, "invalid option '%s'", args[2]);
1112 return ERROR_OK;
1113 }
1114 }
1115 else if (argc != 0)
1116 {
1117 command_print(cmd_ctx, "usage: configure trace mode <none|data|address|all> <context id bits> <cycle accurate> <branch output>");
1118 return ERROR_OK;
1119 }
1120
1121 command_print(cmd_ctx, "current tracemode configuration:");
1122
1123 switch (tracemode & ETMV1_TRACE_MASK)
1124 {
1125 case ETMV1_TRACE_NONE:
1126 command_print(cmd_ctx, "data tracing: none");
1127 break;
1128 case ETMV1_TRACE_DATA:
1129 command_print(cmd_ctx, "data tracing: data only");
1130 break;
1131 case ETMV1_TRACE_ADDR:
1132 command_print(cmd_ctx, "data tracing: address only");
1133 break;
1134 case ETMV1_TRACE_DATA | ETMV1_TRACE_ADDR:
1135 command_print(cmd_ctx, "data tracing: address and data");
1136 break;
1137 }
1138
1139 switch (tracemode & ETMV1_CONTEXTID_MASK)
1140 {
1141 case ETMV1_CONTEXTID_NONE:
1142 command_print(cmd_ctx, "contextid tracing: none");
1143 break;
1144 case ETMV1_CONTEXTID_8:
1145 command_print(cmd_ctx, "contextid tracing: 8 bit");
1146 break;
1147 case ETMV1_CONTEXTID_16:
1148 command_print(cmd_ctx, "contextid tracing: 16 bit");
1149 break;
1150 case ETMV1_CONTEXTID_32:
1151 command_print(cmd_ctx, "contextid tracing: 32 bit");
1152 break;
1153 }
1154
1155 if (tracemode & ETMV1_CYCLE_ACCURATE)
1156 {
1157 command_print(cmd_ctx, "cycle-accurate tracing enabled");
1158 }
1159 else
1160 {
1161 command_print(cmd_ctx, "cycle-accurate tracing disabled");
1162 }
1163
1164 if (tracemode & ETMV1_BRANCH_OUTPUT)
1165 {
1166 command_print(cmd_ctx, "full branch address output enabled");
1167 }
1168 else
1169 {
1170 command_print(cmd_ctx, "full branch address output disabled");
1171 }
1172
1173 /* only update ETM_CTRL register if tracemode changed */
1174 if (arm7_9->etm_ctx->tracemode != tracemode)
1175 {
1176 reg_t *etm_ctrl_reg = &arm7_9->etm_ctx->reg_cache->reg_list[ETM_CTRL];
1177
1178 etm_get_reg(etm_ctrl_reg);
1179
1180 buf_set_u32(etm_ctrl_reg->value, 2, 2, tracemode & ETMV1_TRACE_MASK);
1181 buf_set_u32(etm_ctrl_reg->value, 14, 2, (tracemode & ETMV1_CONTEXTID_MASK) >> 4);
1182 buf_set_u32(etm_ctrl_reg->value, 12, 1, (tracemode & ETMV1_CYCLE_ACCURATE) >> 8);
1183 buf_set_u32(etm_ctrl_reg->value, 8, 1, (tracemode & ETMV1_BRANCH_OUTPUT) >> 9);
1184 etm_store_reg(etm_ctrl_reg);
1185
1186 arm7_9->etm_ctx->tracemode = tracemode;
1187
1188 /* invalidate old trace data */
1189 arm7_9->etm_ctx->capture_status = TRACE_IDLE;
1190 if (arm7_9->etm_ctx->trace_depth > 0)
1191 {
1192 free(arm7_9->etm_ctx->trace_data);
1193 }
1194 arm7_9->etm_ctx->trace_depth = 0;
1195 }
1196
1197 return ERROR_OK;
1198 }
1199
1200 int handle_etm_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1201 {
1202 target_t *target;
1203 armv4_5_common_t *armv4_5;
1204 arm7_9_common_t *arm7_9;
1205 etm_portmode_t portmode = 0x0;
1206 etm_context_t *etm_ctx = malloc(sizeof(etm_context_t));
1207 int i;
1208
1209 if (argc != 5)
1210 {
1211 ERROR("incomplete 'etm config <target> <port_width> <port_mode> <clocking> <capture_driver>' command");
1212 exit(-1);
1213 }
1214
1215 target = get_target_by_num(strtoul(args[0], NULL, 0));
1216
1217 if (!target)
1218 {
1219 ERROR("target number '%s' not defined", args[0]);
1220 exit(-1);
1221 }
1222
1223 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1224 {
1225 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1226 return ERROR_OK;
1227 }
1228
1229 switch (strtoul(args[1], NULL, 0))
1230 {
1231 case 4:
1232 portmode |= ETM_PORT_4BIT;
1233 break;
1234 case 8:
1235 portmode |= ETM_PORT_8BIT;
1236 break;
1237 case 16:
1238 portmode |= ETM_PORT_16BIT;
1239 break;
1240 default:
1241 command_print(cmd_ctx, "unsupported ETM port width '%s', must be 4, 8 or 16", args[1]);
1242 return ERROR_OK;
1243 }
1244
1245 if (strcmp("normal", args[2]) == 0)
1246 {
1247 portmode |= ETM_PORT_NORMAL;
1248 }
1249 else if (strcmp("multiplexed", args[2]) == 0)
1250 {
1251 portmode |= ETM_PORT_MUXED;
1252 }
1253 else if (strcmp("demultiplexed", args[2]) == 0)
1254 {
1255 portmode |= ETM_PORT_DEMUXED;
1256 }
1257 else
1258 {
1259 command_print(cmd_ctx, "unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'", args[2]);
1260 return ERROR_OK;
1261 }
1262
1263 if (strcmp("half", args[3]) == 0)
1264 {
1265 portmode |= ETM_PORT_HALF_CLOCK;
1266 }
1267 else if (strcmp("full", args[3]) == 0)
1268 {
1269 portmode |= ETM_PORT_FULL_CLOCK;
1270 }
1271 else
1272 {
1273 command_print(cmd_ctx, "unsupported ETM port clocking '%s', must be 'full' or 'half'", args[3]);
1274 return ERROR_OK;
1275 }
1276
1277 for (i=0; etm_capture_drivers[i]; i++)
1278 {
1279 if (strcmp(args[4], etm_capture_drivers[i]->name) == 0)
1280 {
1281 if (etm_capture_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
1282 {
1283 free(etm_ctx);
1284 exit(-1);
1285 }
1286
1287 etm_ctx->capture_driver = etm_capture_drivers[i];
1288
1289 break;
1290 }
1291 }
1292
1293 if (!etm_capture_drivers[i])
1294 {
1295 /* no supported capture driver found, don't register an ETM */
1296 free(etm_ctx);
1297 ERROR("trace capture driver '%s' not found", args[4]);
1298 return ERROR_OK;
1299 }
1300
1301 etm_ctx->target = target;
1302 etm_ctx->trigger_percent = 50;
1303 etm_ctx->trace_data = NULL;
1304 etm_ctx->trace_depth = 0;
1305 etm_ctx->portmode = portmode;
1306 etm_ctx->tracemode = 0x0;
1307 etm_ctx->core_state = ARMV4_5_STATE_ARM;
1308 etm_ctx->image = NULL;
1309 etm_ctx->pipe_index = 0;
1310 etm_ctx->data_index = 0;
1311 etm_ctx->current_pc = 0x0;
1312 etm_ctx->pc_ok = 0;
1313 etm_ctx->last_branch = 0x0;
1314 etm_ctx->last_branch_reason = 0x0;
1315 etm_ctx->last_ptr = 0x0;
1316 etm_ctx->ptr_ok = 0x0;
1317 etm_ctx->context_id = 0x0;
1318 etm_ctx->last_instruction = 0;
1319
1320 arm7_9->etm_ctx = etm_ctx;
1321
1322 etm_register_user_commands(cmd_ctx);
1323
1324 return ERROR_OK;
1325 }
1326
1327 int handle_etm_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1328 {
1329 target_t *target;
1330 armv4_5_common_t *armv4_5;
1331 arm7_9_common_t *arm7_9;
1332 reg_t *etm_config_reg;
1333 reg_t *etm_sys_config_reg;
1334
1335 int max_port_size;
1336
1337 target = get_current_target(cmd_ctx);
1338
1339 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1340 {
1341 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1342 return ERROR_OK;
1343 }
1344
1345 if (!arm7_9->etm_ctx)
1346 {
1347 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1348 return ERROR_OK;
1349 }
1350
1351 etm_config_reg = &arm7_9->etm_ctx->reg_cache->reg_list[ETM_CONFIG];
1352 etm_sys_config_reg = &arm7_9->etm_ctx->reg_cache->reg_list[ETM_SYS_CONFIG];
1353
1354 etm_get_reg(etm_config_reg);
1355 command_print(cmd_ctx, "pairs of address comparators: %i", buf_get_u32(etm_config_reg->value, 0, 4));
1356 command_print(cmd_ctx, "pairs of data comparators: %i", buf_get_u32(etm_config_reg->value, 4, 4));
1357 command_print(cmd_ctx, "memory map decoders: %i", buf_get_u32(etm_config_reg->value, 8, 4));
1358 command_print(cmd_ctx, "number of counters: %i", buf_get_u32(etm_config_reg->value, 12, 4));
1359 command_print(cmd_ctx, "sequencer %spresent",
1360 (buf_get_u32(etm_config_reg->value, 16, 1) == 1) ? "" : "not ");
1361 command_print(cmd_ctx, "number of ext. inputs: %i", buf_get_u32(etm_config_reg->value, 17, 3));
1362 command_print(cmd_ctx, "number of ext. outputs: %i", buf_get_u32(etm_config_reg->value, 20, 3));
1363 command_print(cmd_ctx, "FIFO full %spresent",
1364 (buf_get_u32(etm_config_reg->value, 23, 1) == 1) ? "" : "not ");
1365 command_print(cmd_ctx, "protocol version: %i", buf_get_u32(etm_config_reg->value, 28, 3));
1366
1367 etm_get_reg(etm_sys_config_reg);
1368
1369 switch (buf_get_u32(etm_sys_config_reg->value, 0, 3))
1370 {
1371 case 0:
1372 max_port_size = 4;
1373 break;
1374 case 1:
1375 max_port_size = 8;
1376 break;
1377 case 2:
1378 max_port_size = 16;
1379 break;
1380 }
1381 command_print(cmd_ctx, "max. port size: %i", max_port_size);
1382
1383 command_print(cmd_ctx, "half-rate clocking %ssupported",
1384 (buf_get_u32(etm_sys_config_reg->value, 3, 1) == 1) ? "" : "not ");
1385 command_print(cmd_ctx, "full-rate clocking %ssupported",
1386 (buf_get_u32(etm_sys_config_reg->value, 4, 1) == 1) ? "" : "not ");
1387 command_print(cmd_ctx, "normal trace format %ssupported",
1388 (buf_get_u32(etm_sys_config_reg->value, 5, 1) == 1) ? "" : "not ");
1389 command_print(cmd_ctx, "multiplex trace format %ssupported",
1390 (buf_get_u32(etm_sys_config_reg->value, 6, 1) == 1) ? "" : "not ");
1391 command_print(cmd_ctx, "demultiplex trace format %ssupported",
1392 (buf_get_u32(etm_sys_config_reg->value, 7, 1) == 1) ? "" : "not ");
1393 command_print(cmd_ctx, "FIFO full %ssupported",
1394 (buf_get_u32(etm_sys_config_reg->value, 8, 1) == 1) ? "" : "not ");
1395
1396 return ERROR_OK;
1397 }
1398
1399 int handle_etm_status_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1400 {
1401 target_t *target;
1402 armv4_5_common_t *armv4_5;
1403 arm7_9_common_t *arm7_9;
1404 trace_status_t trace_status;
1405
1406 target = get_current_target(cmd_ctx);
1407
1408 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1409 {
1410 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1411 return ERROR_OK;
1412 }
1413
1414 if (!arm7_9->etm_ctx)
1415 {
1416 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1417 return ERROR_OK;
1418 }
1419
1420 trace_status = arm7_9->etm_ctx->capture_driver->status(arm7_9->etm_ctx);
1421
1422 if (trace_status == TRACE_IDLE)
1423 {
1424 command_print(cmd_ctx, "tracing is idle");
1425 }
1426 else
1427 {
1428 static char *completed = " completed";
1429 static char *running = " is running";
1430 static char *overflowed = ", trace overflowed";
1431 static char *triggered = ", trace triggered";
1432
1433 command_print(cmd_ctx, "trace collection%s%s%s",
1434 (trace_status & TRACE_RUNNING) ? running : completed,
1435 (trace_status & TRACE_OVERFLOWED) ? overflowed : "",
1436 (trace_status & TRACE_TRIGGERED) ? triggered : "");
1437
1438 if (arm7_9->etm_ctx->trace_depth > 0)
1439 {
1440 command_print(cmd_ctx, "%i frames of trace data read", arm7_9->etm_ctx->trace_depth);
1441 }
1442 }
1443
1444 return ERROR_OK;
1445 }
1446
1447 int handle_etm_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1448 {
1449 target_t *target;
1450 armv4_5_common_t *armv4_5;
1451 arm7_9_common_t *arm7_9;
1452 etm_context_t *etm_ctx;
1453
1454 if (argc < 1)
1455 {
1456 command_print(cmd_ctx, "usage: etm image <file> [base address] [type]");
1457 return ERROR_OK;
1458 }
1459
1460 target = get_current_target(cmd_ctx);
1461
1462 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1463 {
1464 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1465 return ERROR_OK;
1466 }
1467
1468 if (!(etm_ctx = arm7_9->etm_ctx))
1469 {
1470 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1471 return ERROR_OK;
1472 }
1473
1474 if (etm_ctx->image)
1475 {
1476 image_close(etm_ctx->image);
1477 free(etm_ctx->image);
1478 command_print(cmd_ctx, "previously loaded image found and closed");
1479 }
1480
1481 etm_ctx->image = malloc(sizeof(image_t));
1482 etm_ctx->image->base_address_set = 0;
1483 etm_ctx->image->start_address_set = 0;
1484
1485 /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
1486 if (argc >= 2)
1487 {
1488 etm_ctx->image->base_address_set = 1;
1489 etm_ctx->image->base_address = strtoul(args[1], NULL, 0);
1490 }
1491 else
1492 {
1493 etm_ctx->image->base_address_set = 0;
1494 }
1495
1496 if (image_open(etm_ctx->image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
1497 {
1498 command_print(cmd_ctx, "image opening error: %s", etm_ctx->image->error_str);
1499 free(etm_ctx->image);
1500 etm_ctx->image = NULL;
1501 return ERROR_OK;
1502 }
1503
1504 return ERROR_OK;
1505 }
1506
1507 int handle_etm_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1508 {
1509 fileio_t file;
1510 target_t *target;
1511 armv4_5_common_t *armv4_5;
1512 arm7_9_common_t *arm7_9;
1513 etm_context_t *etm_ctx;
1514 int i;
1515
1516 if (argc != 1)
1517 {
1518 command_print(cmd_ctx, "usage: etm dump <file>");
1519 return ERROR_OK;
1520 }
1521
1522 target = get_current_target(cmd_ctx);
1523
1524 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1525 {
1526 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1527 return ERROR_OK;
1528 }
1529
1530 if (!(etm_ctx = arm7_9->etm_ctx))
1531 {
1532 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1533 return ERROR_OK;
1534 }
1535
1536 if (etm_ctx->capture_driver->status == TRACE_IDLE)
1537 {
1538 command_print(cmd_ctx, "trace capture wasn't enabled, no trace data captured");
1539 return ERROR_OK;
1540 }
1541
1542 if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING)
1543 {
1544 /* TODO: if on-the-fly capture is to be supported, this needs to be changed */
1545 command_print(cmd_ctx, "trace capture not completed");
1546 return ERROR_OK;
1547 }
1548
1549 /* read the trace data if it wasn't read already */
1550 if (etm_ctx->trace_depth == 0)
1551 etm_ctx->capture_driver->read_trace(etm_ctx);
1552
1553 if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
1554 {
1555 command_print(cmd_ctx, "file open error: %s", file.error_str);
1556 return ERROR_OK;
1557 }
1558
1559 fileio_write_u32(&file, etm_ctx->capture_status);
1560 fileio_write_u32(&file, etm_ctx->portmode);
1561 fileio_write_u32(&file, etm_ctx->tracemode);
1562 fileio_write_u32(&file, etm_ctx->trace_depth);
1563
1564 for (i = 0; i < etm_ctx->trace_depth; i++)
1565 {
1566 fileio_write_u32(&file, etm_ctx->trace_data[i].pipestat);
1567 fileio_write_u32(&file, etm_ctx->trace_data[i].packet);
1568 fileio_write_u32(&file, etm_ctx->trace_data[i].flags);
1569 }
1570
1571 fileio_close(&file);
1572
1573 return ERROR_OK;
1574 }
1575
1576 int handle_etm_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1577 {
1578 fileio_t file;
1579 target_t *target;
1580 armv4_5_common_t *armv4_5;
1581 arm7_9_common_t *arm7_9;
1582 etm_context_t *etm_ctx;
1583 int i;
1584
1585 if (argc != 1)
1586 {
1587 command_print(cmd_ctx, "usage: etm load <file>");
1588 return ERROR_OK;
1589 }
1590
1591 target = get_current_target(cmd_ctx);
1592
1593 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1594 {
1595 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1596 return ERROR_OK;
1597 }
1598
1599 if (!(etm_ctx = arm7_9->etm_ctx))
1600 {
1601 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1602 return ERROR_OK;
1603 }
1604
1605 if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING)
1606 {
1607 command_print(cmd_ctx, "trace capture running, stop first");
1608 return ERROR_OK;
1609 }
1610
1611 if (fileio_open(&file, args[0], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
1612 {
1613 command_print(cmd_ctx, "file open error: %s", file.error_str);
1614 return ERROR_OK;
1615 }
1616
1617 if (file.size % 4)
1618 {
1619 command_print(cmd_ctx, "size isn't a multiple of 4, no valid trace data");
1620 return ERROR_OK;
1621 }
1622
1623 if (etm_ctx->trace_depth > 0)
1624 {
1625 free(etm_ctx->trace_data);
1626 }
1627
1628 fileio_read_u32(&file, &etm_ctx->capture_status);
1629 fileio_read_u32(&file, &etm_ctx->portmode);
1630 fileio_read_u32(&file, &etm_ctx->tracemode);
1631 fileio_read_u32(&file, &etm_ctx->trace_depth);
1632
1633 etm_ctx->trace_data = malloc(sizeof(etmv1_trace_data_t) * etm_ctx->trace_depth);
1634
1635 for (i = 0; i < etm_ctx->trace_depth; i++)
1636 {
1637 u32 pipestat, packet, flags;
1638 fileio_read_u32(&file, &pipestat);
1639 fileio_read_u32(&file, &packet);
1640 fileio_read_u32(&file, &flags);
1641 etm_ctx->trace_data[i].pipestat = pipestat & 0xff;
1642 etm_ctx->trace_data[i].packet = packet & 0xffff;
1643 etm_ctx->trace_data[i].flags = flags;
1644 }
1645
1646 fileio_close(&file);
1647
1648 return ERROR_OK;
1649 }
1650
1651 int handle_etm_trigger_percent_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1652 {
1653 target_t *target;
1654 armv4_5_common_t *armv4_5;
1655 arm7_9_common_t *arm7_9;
1656 etm_context_t *etm_ctx;
1657
1658 target = get_current_target(cmd_ctx);
1659
1660 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1661 {
1662 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1663 return ERROR_OK;
1664 }
1665
1666 if (!(etm_ctx = arm7_9->etm_ctx))
1667 {
1668 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1669 return ERROR_OK;
1670 }
1671
1672 if (argc > 0)
1673 {
1674 u32 new_value = strtoul(args[0], NULL, 0);
1675
1676 if ((new_value < 2) || (new_value > 100))
1677 {
1678 command_print(cmd_ctx, "valid settings are 2% to 100%");
1679 }
1680 else
1681 {
1682 etm_ctx->trigger_percent = new_value;
1683 }
1684 }
1685
1686 command_print(cmd_ctx, "%i percent of the tracebuffer reserved for after the trigger", etm_ctx->trigger_percent);
1687
1688 return ERROR_OK;
1689 }
1690
1691 int handle_etm_start_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1692 {
1693 target_t *target;
1694 armv4_5_common_t *armv4_5;
1695 arm7_9_common_t *arm7_9;
1696 etm_context_t *etm_ctx;
1697 reg_t *etm_ctrl_reg;
1698
1699 target = get_current_target(cmd_ctx);
1700
1701 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1702 {
1703 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1704 return ERROR_OK;
1705 }
1706
1707 if (!(etm_ctx = arm7_9->etm_ctx))
1708 {
1709 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1710 return ERROR_OK;
1711 }
1712
1713 /* invalidate old tracing data */
1714 arm7_9->etm_ctx->capture_status = TRACE_IDLE;
1715 if (arm7_9->etm_ctx->trace_depth > 0)
1716 {
1717 free(arm7_9->etm_ctx->trace_data);
1718 }
1719 arm7_9->etm_ctx->trace_depth = 0;
1720
1721 etm_ctrl_reg = &arm7_9->etm_ctx->reg_cache->reg_list[ETM_CTRL];
1722 etm_get_reg(etm_ctrl_reg);
1723
1724 /* Clear programming bit (10), set port selection bit (11) */
1725 buf_set_u32(etm_ctrl_reg->value, 10, 2, 0x2);
1726
1727 etm_store_reg(etm_ctrl_reg);
1728 jtag_execute_queue();
1729
1730 etm_ctx->capture_driver->start_capture(etm_ctx);
1731
1732 return ERROR_OK;
1733 }
1734
1735 int handle_etm_stop_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1736 {
1737 target_t *target;
1738 armv4_5_common_t *armv4_5;
1739 arm7_9_common_t *arm7_9;
1740 etm_context_t *etm_ctx;
1741 reg_t *etm_ctrl_reg;
1742
1743 target = get_current_target(cmd_ctx);
1744
1745 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1746 {
1747 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1748 return ERROR_OK;
1749 }
1750
1751 if (!(etm_ctx = arm7_9->etm_ctx))
1752 {
1753 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1754 return ERROR_OK;
1755 }
1756
1757 etm_ctrl_reg = &arm7_9->etm_ctx->reg_cache->reg_list[ETM_CTRL];
1758 etm_get_reg(etm_ctrl_reg);
1759
1760 /* Set programming bit (10), clear port selection bit (11) */
1761 buf_set_u32(etm_ctrl_reg->value, 10, 2, 0x1);
1762
1763 etm_store_reg(etm_ctrl_reg);
1764 jtag_execute_queue();
1765
1766 etm_ctx->capture_driver->stop_capture(etm_ctx);
1767
1768 return ERROR_OK;
1769 }
1770
1771 int handle_etm_analyze_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1772 {
1773 target_t *target;
1774 armv4_5_common_t *armv4_5;
1775 arm7_9_common_t *arm7_9;
1776 etm_context_t *etm_ctx;
1777
1778 target = get_current_target(cmd_ctx);
1779
1780 if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
1781 {
1782 command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
1783 return ERROR_OK;
1784 }
1785
1786 if (!(etm_ctx = arm7_9->etm_ctx))
1787 {
1788 command_print(cmd_ctx, "current target doesn't have an ETM configured");
1789 return ERROR_OK;
1790 }
1791
1792 etmv1_analyze_trace(etm_ctx, cmd_ctx);
1793
1794 return ERROR_OK;
1795 }
1796
1797 int etm_register_commands(struct command_context_s *cmd_ctx)
1798 {
1799 etm_cmd = register_command(cmd_ctx, NULL, "etm", NULL, COMMAND_ANY, "Embedded Trace Macrocell");
1800
1801 register_command(cmd_ctx, etm_cmd, "config", handle_etm_config_command, COMMAND_CONFIG, NULL);
1802
1803 return ERROR_OK;
1804 }
1805
1806 int etm_register_user_commands(struct command_context_s *cmd_ctx)
1807 {
1808 register_command(cmd_ctx, etm_cmd, "tracemode", handle_etm_tracemode_command,
1809 COMMAND_EXEC, "configure trace mode <none|data|address|all> <context id bits> <cycle accurate> <branch output");
1810
1811 register_command(cmd_ctx, etm_cmd, "info", handle_etm_info_command,
1812 COMMAND_EXEC, "display info about the current target's ETM");
1813
1814 register_command(cmd_ctx, etm_cmd, "trigger_percent <percent>", handle_etm_trigger_percent_command,
1815 COMMAND_EXEC, "amount (<percent>) of trace buffer to be filled after the trigger occured");
1816 register_command(cmd_ctx, etm_cmd, "status", handle_etm_status_command,
1817 COMMAND_EXEC, "display current target's ETM status");
1818 register_command(cmd_ctx, etm_cmd, "start", handle_etm_start_command,
1819 COMMAND_EXEC, "start ETM trace collection");
1820 register_command(cmd_ctx, etm_cmd, "stop", handle_etm_stop_command,
1821 COMMAND_EXEC, "stop ETM trace collection");
1822
1823 register_command(cmd_ctx, etm_cmd, "analyze", handle_etm_analyze_command,
1824 COMMAND_EXEC, "anaylze collected ETM trace");
1825
1826 register_command(cmd_ctx, etm_cmd, "image", handle_etm_image_command,
1827 COMMAND_EXEC, "load image from <file> [base address]");
1828
1829 register_command(cmd_ctx, etm_cmd, "dump", handle_etm_dump_command,
1830 COMMAND_EXEC, "dump captured trace data <file>");
1831 register_command(cmd_ctx, etm_cmd, "load", handle_etm_load_command,
1832 COMMAND_EXEC, "load trace data for analysis <file>");
1833
1834 return ERROR_OK;
1835 }
Open On-Chip Debugger

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)