1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
28 static char* etb_reg_list
[] =
35 "ETB_ram_read_pointer",
36 "ETB_ram_write_pointer",
37 "ETB_trigger_counter",
41 static int etb_reg_arch_type
= -1;
43 static int etb_get_reg(struct reg
*reg
);
45 static int etb_set_instr(struct etb
*etb
, uint32_t new_instr
)
53 if (buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
) != new_instr
)
55 struct scan_field field
;
58 field
.num_bits
= tap
->ir_length
;
59 field
.out_value
= calloc(CEIL(field
.num_bits
, 8), 1);
60 buf_set_u32(field
.out_value
, 0, field
.num_bits
, new_instr
);
62 field
.in_value
= NULL
;
64 jtag_add_ir_scan(1, &field
, jtag_get_end_state());
66 free(field
.out_value
);
72 static int etb_scann(struct etb
*etb
, uint32_t new_scan_chain
)
74 if (etb
->cur_scan_chain
!= new_scan_chain
)
76 struct scan_field field
;
80 field
.out_value
= calloc(CEIL(field
.num_bits
, 8), 1);
81 buf_set_u32(field
.out_value
, 0, field
.num_bits
, new_scan_chain
);
83 field
.in_value
= NULL
;
85 /* select INTEST instruction */
86 etb_set_instr(etb
, 0x2);
87 jtag_add_dr_scan(1, &field
, jtag_get_end_state());
89 etb
->cur_scan_chain
= new_scan_chain
;
91 free(field
.out_value
);
97 static int etb_read_reg_w_check(struct reg
*, uint8_t *, uint8_t *);
98 static int etb_set_reg_w_exec(struct reg
*, uint8_t *);
100 static int etb_read_reg(struct reg
*reg
)
102 return etb_read_reg_w_check(reg
, NULL
, NULL
);
105 static int etb_get_reg(struct reg
*reg
)
109 if ((retval
= etb_read_reg(reg
)) != ERROR_OK
)
111 LOG_ERROR("BUG: error scheduling ETB register read");
115 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
117 LOG_ERROR("ETB register read failed");
124 struct reg_cache
* etb_build_reg_cache(struct etb
*etb
)
126 struct reg_cache
*reg_cache
= malloc(sizeof(struct reg_cache
));
127 struct reg
*reg_list
= NULL
;
128 struct etb_reg
*arch_info
= NULL
;
132 /* register a register arch-type for etm registers only once */
133 if (etb_reg_arch_type
== -1)
134 etb_reg_arch_type
= register_reg_arch_type(etb_get_reg
, etb_set_reg_w_exec
);
136 /* the actual registers are kept in two arrays */
137 reg_list
= calloc(num_regs
, sizeof(struct reg
));
138 arch_info
= calloc(num_regs
, sizeof(struct etb_reg
));
140 /* fill in values for the reg cache */
141 reg_cache
->name
= "etb registers";
142 reg_cache
->next
= NULL
;
143 reg_cache
->reg_list
= reg_list
;
144 reg_cache
->num_regs
= num_regs
;
146 /* set up registers */
147 for (i
= 0; i
< num_regs
; i
++)
149 reg_list
[i
].name
= etb_reg_list
[i
];
150 reg_list
[i
].size
= 32;
151 reg_list
[i
].dirty
= 0;
152 reg_list
[i
].valid
= 0;
153 reg_list
[i
].value
= calloc(1, 4);
154 reg_list
[i
].arch_info
= &arch_info
[i
];
155 reg_list
[i
].arch_type
= etb_reg_arch_type
;
156 reg_list
[i
].size
= 32;
157 arch_info
[i
].addr
= i
;
158 arch_info
[i
].etb
= etb
;
164 static void etb_getbuf(jtag_callback_data_t arg
)
166 uint8_t *in
= (uint8_t *)arg
;
168 *((uint32_t *)in
) = buf_get_u32(in
, 0, 32);
172 static int etb_read_ram(struct etb
*etb
, uint32_t *data
, int num_frames
)
174 struct scan_field fields
[3];
177 jtag_set_end_state(TAP_IDLE
);
179 etb_set_instr(etb
, 0xc);
181 fields
[0].tap
= etb
->tap
;
182 fields
[0].num_bits
= 32;
183 fields
[0].out_value
= NULL
;
184 fields
[0].in_value
= NULL
;
186 fields
[1].tap
= etb
->tap
;
187 fields
[1].num_bits
= 7;
188 fields
[1].out_value
= malloc(1);
189 buf_set_u32(fields
[1].out_value
, 0, 7, 4);
190 fields
[1].in_value
= NULL
;
192 fields
[2].tap
= etb
->tap
;
193 fields
[2].num_bits
= 1;
194 fields
[2].out_value
= malloc(1);
195 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
196 fields
[2].in_value
= NULL
;
198 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
200 for (i
= 0; i
< num_frames
; i
++)
202 /* ensure nR/W reamins set to read */
203 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
205 /* address remains set to 0x4 (RAM data) until we read the last frame */
206 if (i
< num_frames
- 1)
207 buf_set_u32(fields
[1].out_value
, 0, 7, 4);
209 buf_set_u32(fields
[1].out_value
, 0, 7, 0);
211 fields
[0].in_value
= (uint8_t *)(data
+ i
);
212 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
214 jtag_add_callback(etb_getbuf
, (jtag_callback_data_t
)(data
+ i
));
217 jtag_execute_queue();
219 free(fields
[1].out_value
);
220 free(fields
[2].out_value
);
225 static int etb_read_reg_w_check(struct reg
*reg
,
226 uint8_t* check_value
, uint8_t* check_mask
)
228 struct etb_reg
*etb_reg
= reg
->arch_info
;
229 uint8_t reg_addr
= etb_reg
->addr
& 0x7f;
230 struct scan_field fields
[3];
232 LOG_DEBUG("%i", (int)(etb_reg
->addr
));
234 jtag_set_end_state(TAP_IDLE
);
235 etb_scann(etb_reg
->etb
, 0x0);
236 etb_set_instr(etb_reg
->etb
, 0xc);
238 fields
[0].tap
= etb_reg
->etb
->tap
;
239 fields
[0].num_bits
= 32;
240 fields
[0].out_value
= reg
->value
;
241 fields
[0].in_value
= NULL
;
242 fields
[0].check_value
= NULL
;
243 fields
[0].check_mask
= NULL
;
245 fields
[1].tap
= etb_reg
->etb
->tap
;
246 fields
[1].num_bits
= 7;
247 fields
[1].out_value
= malloc(1);
248 buf_set_u32(fields
[1].out_value
, 0, 7, reg_addr
);
249 fields
[1].in_value
= NULL
;
250 fields
[1].check_value
= NULL
;
251 fields
[1].check_mask
= NULL
;
253 fields
[2].tap
= etb_reg
->etb
->tap
;
254 fields
[2].num_bits
= 1;
255 fields
[2].out_value
= malloc(1);
256 buf_set_u32(fields
[2].out_value
, 0, 1, 0);
257 fields
[2].in_value
= NULL
;
258 fields
[2].check_value
= NULL
;
259 fields
[2].check_mask
= NULL
;
261 jtag_add_dr_scan(3, fields
, jtag_get_end_state());
263 /* read the identification register in the second run, to make sure we
264 * don't read the ETB data register twice, skipping every second entry
266 buf_set_u32(fields
[1].out_value
, 0, 7, 0x0);
267 fields
[0].in_value
= reg
->value
;
268 fields
[0].check_value
= check_value
;
269 fields
[0].check_mask
= check_mask
;
271 jtag_add_dr_scan_check(3, fields
, jtag_get_end_state());
273 free(fields
[1].out_value
);
274 free(fields
[2].out_value
);
279 static int etb_write_reg(struct reg
*, uint32_t);
281 static int etb_set_reg(struct reg
*reg
, uint32_t value
)
285 if ((retval
= etb_write_reg(reg
, value
)) != ERROR_OK
)
287 LOG_ERROR("BUG: error scheduling ETB register write");
291 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
298 static int etb_set_reg_w_exec(struct reg
*reg
, uint8_t *buf
)
302 etb_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
304 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
306 LOG_ERROR("ETB: register write failed");
312 static int etb_write_reg(struct reg
*reg
, uint32_t value
)
314 struct etb_reg
*etb_reg
= reg
->arch_info
;
315 uint8_t reg_addr
= etb_reg
->addr
& 0x7f;
316 struct scan_field fields
[3];
318 LOG_DEBUG("%i: 0x%8.8" PRIx32
"", (int)(etb_reg
->addr
), value
);
320 jtag_set_end_state(TAP_IDLE
);
321 etb_scann(etb_reg
->etb
, 0x0);
322 etb_set_instr(etb_reg
->etb
, 0xc);
324 fields
[0].tap
= etb_reg
->etb
->tap
;
325 fields
[0].num_bits
= 32;
326 fields
[0].out_value
= malloc(4);
327 buf_set_u32(fields
[0].out_value
, 0, 32, value
);
328 fields
[0].in_value
= NULL
;
330 fields
[1].tap
= etb_reg
->etb
->tap
;
331 fields
[1].num_bits
= 7;
332 fields
[1].out_value
= malloc(1);
333 buf_set_u32(fields
[1].out_value
, 0, 7, reg_addr
);
334 fields
[1].in_value
= NULL
;
336 fields
[2].tap
= etb_reg
->etb
->tap
;
337 fields
[2].num_bits
= 1;
338 fields
[2].out_value
= malloc(1);
339 buf_set_u32(fields
[2].out_value
, 0, 1, 1);
341 fields
[2].in_value
= NULL
;
343 free(fields
[0].out_value
);
344 free(fields
[1].out_value
);
345 free(fields
[2].out_value
);
350 COMMAND_HANDLER(handle_etb_config_command
)
352 struct target
*target
;
353 struct jtag_tap
*tap
;
358 return ERROR_COMMAND_SYNTAX_ERROR
;
361 target
= get_target(args
[0]);
365 LOG_ERROR("ETB: target '%s' not defined", args
[0]);
369 arm
= target_to_arm(target
);
372 command_print(cmd_ctx
, "ETB: '%s' isn't an ARM", args
[0]);
376 tap
= jtag_tap_by_string(args
[1]);
379 command_print(cmd_ctx
, "ETB: TAP %s does not exist", args
[1]);
385 struct etb
*etb
= malloc(sizeof(struct etb
));
387 arm
->etm
->capture_driver_priv
= etb
;
390 etb
->cur_scan_chain
= 0xffffffff;
391 etb
->reg_cache
= NULL
;
397 LOG_ERROR("ETM: target has no ETM defined, ETB left unconfigured");
404 static int etb_register_commands(struct command_context
*cmd_ctx
)
406 struct command
*etb_cmd
= register_command(cmd_ctx
, NULL
, "etb",
407 NULL
, COMMAND_ANY
, "Embedded Trace Buffer");
409 register_command(cmd_ctx
, etb_cmd
, "config",
410 handle_etb_config_command
, COMMAND_CONFIG
,
416 static int etb_init(struct etm_context
*etm_ctx
)
418 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
420 etb
->etm_ctx
= etm_ctx
;
422 /* identify ETB RAM depth and width */
423 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_DEPTH
]);
424 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WIDTH
]);
425 jtag_execute_queue();
427 etb
->ram_depth
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_DEPTH
].value
, 0, 32);
428 etb
->ram_width
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WIDTH
].value
, 0, 32);
433 static trace_status_t
etb_status(struct etm_context
*etm_ctx
)
435 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
436 struct reg
*control
= &etb
->reg_cache
->reg_list
[ETB_CTRL
];
437 struct reg
*status
= &etb
->reg_cache
->reg_list
[ETB_STATUS
];
438 trace_status_t retval
= 0;
439 int etb_timeout
= 100;
441 etb
->etm_ctx
= etm_ctx
;
443 /* read control and status registers */
444 etb_read_reg(control
);
445 etb_read_reg(status
);
446 jtag_execute_queue();
448 /* See if it's (still) active */
449 retval
= buf_get_u32(control
->value
, 0, 1) ? TRACE_RUNNING
: TRACE_IDLE
;
451 /* check Full bit to identify wraparound/overflow */
452 if (buf_get_u32(status
->value
, 0, 1) == 1)
453 retval
|= TRACE_OVERFLOWED
;
455 /* check Triggered bit to identify trigger condition */
456 if (buf_get_u32(status
->value
, 1, 1) == 1)
457 retval
|= TRACE_TRIGGERED
;
459 /* check AcqComp to see if trigger counter dropped to zero */
460 if (buf_get_u32(status
->value
, 2, 1) == 1) {
461 /* wait for DFEmpty */
462 while (etb_timeout
-- && buf_get_u32(status
->value
, 3, 1) == 0)
465 if (etb_timeout
== 0)
466 LOG_ERROR("ETB: DFEmpty won't go high, status 0x%02x",
467 (unsigned) buf_get_u32(status
->value
, 0, 4));
469 if (!(etm_ctx
->capture_status
& TRACE_TRIGGERED
))
470 LOG_WARNING("ETB: trace complete without triggering?");
472 retval
|= TRACE_COMPLETED
;
475 /* NOTE: using a trigger is optional; and at least ETB11 has a mode
476 * where it can ignore the trigger counter.
479 /* update recorded state */
480 etm_ctx
->capture_status
= retval
;
485 static int etb_read_trace(struct etm_context
*etm_ctx
)
487 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
489 int num_frames
= etb
->ram_depth
;
490 uint32_t *trace_data
= NULL
;
493 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_STATUS
]);
494 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
]);
495 jtag_execute_queue();
497 /* check if we overflowed, and adjust first frame of the trace accordingly
498 * if we didn't overflow, read only up to the frame that would be written next,
499 * i.e. don't read invalid entries
501 if (buf_get_u32(etb
->reg_cache
->reg_list
[ETB_STATUS
].value
, 0, 1))
503 first_frame
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
].value
, 0, 32);
507 num_frames
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
].value
, 0, 32);
510 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_READ_POINTER
], first_frame
);
512 /* read data into temporary array for unpacking */
513 trace_data
= malloc(sizeof(uint32_t) * num_frames
);
514 etb_read_ram(etb
, trace_data
, num_frames
);
516 if (etm_ctx
->trace_depth
> 0)
518 free(etm_ctx
->trace_data
);
521 if ((etm_ctx
->portmode
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_4BIT
)
522 etm_ctx
->trace_depth
= num_frames
* 3;
523 else if ((etm_ctx
->portmode
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_8BIT
)
524 etm_ctx
->trace_depth
= num_frames
* 2;
526 etm_ctx
->trace_depth
= num_frames
;
528 etm_ctx
->trace_data
= malloc(sizeof(struct etmv1_trace_data
) * etm_ctx
->trace_depth
);
530 for (i
= 0, j
= 0; i
< num_frames
; i
++)
532 if ((etm_ctx
->portmode
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_4BIT
)
535 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
536 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x78) >> 3;
537 etm_ctx
->trace_data
[j
].flags
= 0;
538 if ((trace_data
[i
] & 0x80) >> 7)
540 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
542 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
544 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
545 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
548 /* trace word j + 1 */
549 etm_ctx
->trace_data
[j
+ 1].pipestat
= (trace_data
[i
] & 0x100) >> 8;
550 etm_ctx
->trace_data
[j
+ 1].packet
= (trace_data
[i
] & 0x7800) >> 11;
551 etm_ctx
->trace_data
[j
+ 1].flags
= 0;
552 if ((trace_data
[i
] & 0x8000) >> 15)
554 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRACESYNC_CYCLE
;
556 if (etm_ctx
->trace_data
[j
+ 1].pipestat
== STAT_TR
)
558 etm_ctx
->trace_data
[j
+ 1].pipestat
= etm_ctx
->trace_data
[j
+ 1].packet
& 0x7;
559 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRIGGER_CYCLE
;
562 /* trace word j + 2 */
563 etm_ctx
->trace_data
[j
+ 2].pipestat
= (trace_data
[i
] & 0x10000) >> 16;
564 etm_ctx
->trace_data
[j
+ 2].packet
= (trace_data
[i
] & 0x780000) >> 19;
565 etm_ctx
->trace_data
[j
+ 2].flags
= 0;
566 if ((trace_data
[i
] & 0x800000) >> 23)
568 etm_ctx
->trace_data
[j
+ 2].flags
|= ETMV1_TRACESYNC_CYCLE
;
570 if (etm_ctx
->trace_data
[j
+ 2].pipestat
== STAT_TR
)
572 etm_ctx
->trace_data
[j
+ 2].pipestat
= etm_ctx
->trace_data
[j
+ 2].packet
& 0x7;
573 etm_ctx
->trace_data
[j
+ 2].flags
|= ETMV1_TRIGGER_CYCLE
;
578 else if ((etm_ctx
->portmode
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_8BIT
)
581 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
582 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x7f8) >> 3;
583 etm_ctx
->trace_data
[j
].flags
= 0;
584 if ((trace_data
[i
] & 0x800) >> 11)
586 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
588 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
590 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
591 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
594 /* trace word j + 1 */
595 etm_ctx
->trace_data
[j
+ 1].pipestat
= (trace_data
[i
] & 0x7000) >> 12;
596 etm_ctx
->trace_data
[j
+ 1].packet
= (trace_data
[i
] & 0x7f8000) >> 15;
597 etm_ctx
->trace_data
[j
+ 1].flags
= 0;
598 if ((trace_data
[i
] & 0x800000) >> 23)
600 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRACESYNC_CYCLE
;
602 if (etm_ctx
->trace_data
[j
+ 1].pipestat
== STAT_TR
)
604 etm_ctx
->trace_data
[j
+ 1].pipestat
= etm_ctx
->trace_data
[j
+ 1].packet
& 0x7;
605 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRIGGER_CYCLE
;
613 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
614 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x7fff8) >> 3;
615 etm_ctx
->trace_data
[j
].flags
= 0;
616 if ((trace_data
[i
] & 0x80000) >> 19)
618 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
620 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
622 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
623 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
635 static int etb_start_capture(struct etm_context
*etm_ctx
)
637 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
638 uint32_t etb_ctrl_value
= 0x1;
639 uint32_t trigger_count
;
641 if ((etm_ctx
->portmode
& ETM_PORT_MODE_MASK
) == ETM_PORT_DEMUXED
)
643 if ((etm_ctx
->portmode
& ETM_PORT_WIDTH_MASK
) != ETM_PORT_8BIT
)
645 LOG_ERROR("ETB can't run in demultiplexed mode with a 4 or 16 bit port");
646 return ERROR_ETM_PORTMODE_NOT_SUPPORTED
;
648 etb_ctrl_value
|= 0x2;
651 if ((etm_ctx
->portmode
& ETM_PORT_MODE_MASK
) == ETM_PORT_MUXED
) {
652 LOG_ERROR("ETB: can't run in multiplexed mode");
653 return ERROR_ETM_PORTMODE_NOT_SUPPORTED
;
656 trigger_count
= (etb
->ram_depth
* etm_ctx
->trigger_percent
) / 100;
658 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_TRIGGER_COUNTER
], trigger_count
);
659 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
], 0x0);
660 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_CTRL
], etb_ctrl_value
);
661 jtag_execute_queue();
663 /* we're starting a new trace, initialize capture status */
664 etm_ctx
->capture_status
= TRACE_RUNNING
;
669 static int etb_stop_capture(struct etm_context
*etm_ctx
)
671 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
672 struct reg
*etb_ctrl_reg
= &etb
->reg_cache
->reg_list
[ETB_CTRL
];
674 etb_write_reg(etb_ctrl_reg
, 0x0);
675 jtag_execute_queue();
677 /* trace stopped, just clear running flag, but preserve others */
678 etm_ctx
->capture_status
&= ~TRACE_RUNNING
;
683 struct etm_capture_driver etb_capture_driver
=
686 .register_commands
= etb_register_commands
,
688 .status
= etb_status
,
689 .start_capture
= etb_start_capture
,
690 .stop_capture
= etb_stop_capture
,
691 .read_trace
= etb_read_trace
,