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 ***************************************************************************/
30 static char* etb_reg_list
[] =
37 "ETB_ram_read_pointer",
38 "ETB_ram_write_pointer",
39 "ETB_trigger_counter",
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
;
57 field
.num_bits
= tap
->ir_length
;
58 void * t
= calloc(DIV_ROUND_UP(field
.num_bits
, 8), 1);
60 buf_set_u32(t
, 0, field
.num_bits
, new_instr
);
62 field
.in_value
= NULL
;
64 jtag_add_ir_scan(tap
, &field
, TAP_IDLE
);
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
;
79 void * t
= calloc(DIV_ROUND_UP(field
.num_bits
, 8), 1);
81 buf_set_u32(t
, 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(etb
->tap
, 1, &field
, TAP_IDLE
);
89 etb
->cur_scan_chain
= new_scan_chain
;
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 static const struct reg_arch_type etb_reg_type
= {
126 .set
= etb_set_reg_w_exec
,
129 struct reg_cache
* etb_build_reg_cache(struct etb
*etb
)
131 struct reg_cache
*reg_cache
= malloc(sizeof(struct reg_cache
));
132 struct reg
*reg_list
= NULL
;
133 struct etb_reg
*arch_info
= NULL
;
137 /* the actual registers are kept in two arrays */
138 reg_list
= calloc(num_regs
, sizeof(struct reg
));
139 arch_info
= calloc(num_regs
, sizeof(struct etb_reg
));
141 /* fill in values for the reg cache */
142 reg_cache
->name
= "etb registers";
143 reg_cache
->next
= NULL
;
144 reg_cache
->reg_list
= reg_list
;
145 reg_cache
->num_regs
= num_regs
;
147 /* set up registers */
148 for (i
= 0; i
< num_regs
; i
++)
150 reg_list
[i
].name
= etb_reg_list
[i
];
151 reg_list
[i
].size
= 32;
152 reg_list
[i
].dirty
= 0;
153 reg_list
[i
].valid
= 0;
154 reg_list
[i
].value
= calloc(1, 4);
155 reg_list
[i
].arch_info
= &arch_info
[i
];
156 reg_list
[i
].type
= &etb_reg_type
;
157 reg_list
[i
].size
= 32;
158 arch_info
[i
].addr
= i
;
159 arch_info
[i
].etb
= etb
;
165 static void etb_getbuf(jtag_callback_data_t arg
)
167 uint8_t *in
= (uint8_t *)arg
;
169 *((uint32_t *)arg
) = buf_get_u32(in
, 0, 32);
173 static int etb_read_ram(struct etb
*etb
, uint32_t *data
, int num_frames
)
175 struct scan_field fields
[3];
179 etb_set_instr(etb
, 0xc);
181 fields
[0].num_bits
= 32;
182 fields
[0].out_value
= NULL
;
183 fields
[0].in_value
= NULL
;
185 fields
[1].num_bits
= 7;
187 fields
[1].out_value
= &temp1
;
188 buf_set_u32(&temp1
, 0, 7, 4);
189 fields
[1].in_value
= NULL
;
191 fields
[2].num_bits
= 1;
193 fields
[2].out_value
= &temp2
;
194 buf_set_u32(&temp2
, 0, 1, 0);
195 fields
[2].in_value
= NULL
;
197 jtag_add_dr_scan(etb
->tap
, 3, fields
, TAP_IDLE
);
199 for (i
= 0; i
< num_frames
; i
++)
201 /* ensure nR/W reamins set to read */
202 buf_set_u32(&temp2
, 0, 1, 0);
204 /* address remains set to 0x4 (RAM data) until we read the last frame */
205 if (i
< num_frames
- 1)
206 buf_set_u32(&temp1
, 0, 7, 4);
208 buf_set_u32(&temp1
, 0, 7, 0);
210 fields
[0].in_value
= (uint8_t *)(data
+ i
);
211 jtag_add_dr_scan(etb
->tap
, 3, fields
, TAP_IDLE
);
213 jtag_add_callback(etb_getbuf
, (jtag_callback_data_t
)(data
+ i
));
216 jtag_execute_queue();
221 static int etb_read_reg_w_check(struct reg
*reg
,
222 uint8_t* check_value
, uint8_t* check_mask
)
224 struct etb_reg
*etb_reg
= reg
->arch_info
;
225 uint8_t reg_addr
= etb_reg
->addr
& 0x7f;
226 struct scan_field fields
[3];
228 LOG_DEBUG("%i", (int)(etb_reg
->addr
));
230 etb_scann(etb_reg
->etb
, 0x0);
231 etb_set_instr(etb_reg
->etb
, 0xc);
233 fields
[0].num_bits
= 32;
234 fields
[0].out_value
= reg
->value
;
235 fields
[0].in_value
= NULL
;
236 fields
[0].check_value
= NULL
;
237 fields
[0].check_mask
= NULL
;
239 fields
[1].num_bits
= 7;
241 fields
[1].out_value
= &temp1
;
242 buf_set_u32(&temp1
, 0, 7, reg_addr
);
243 fields
[1].in_value
= NULL
;
244 fields
[1].check_value
= NULL
;
245 fields
[1].check_mask
= NULL
;
247 fields
[2].num_bits
= 1;
249 fields
[2].out_value
= &temp2
;
250 buf_set_u32(&temp2
, 0, 1, 0);
251 fields
[2].in_value
= NULL
;
252 fields
[2].check_value
= NULL
;
253 fields
[2].check_mask
= NULL
;
255 jtag_add_dr_scan(etb_reg
->etb
->tap
, 3, fields
, TAP_IDLE
);
257 /* read the identification register in the second run, to make sure we
258 * don't read the ETB data register twice, skipping every second entry
260 buf_set_u32(&temp1
, 0, 7, 0x0);
261 fields
[0].in_value
= reg
->value
;
262 fields
[0].check_value
= check_value
;
263 fields
[0].check_mask
= check_mask
;
265 jtag_add_dr_scan_check(etb_reg
->etb
->tap
, 3, fields
, TAP_IDLE
);
270 static int etb_write_reg(struct reg
*, uint32_t);
272 static int etb_set_reg(struct reg
*reg
, uint32_t value
)
276 if ((retval
= etb_write_reg(reg
, value
)) != ERROR_OK
)
278 LOG_ERROR("BUG: error scheduling ETB register write");
282 buf_set_u32(reg
->value
, 0, reg
->size
, value
);
289 static int etb_set_reg_w_exec(struct reg
*reg
, uint8_t *buf
)
293 etb_set_reg(reg
, buf_get_u32(buf
, 0, reg
->size
));
295 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
297 LOG_ERROR("ETB: register write failed");
303 static int etb_write_reg(struct reg
*reg
, uint32_t value
)
305 struct etb_reg
*etb_reg
= reg
->arch_info
;
306 uint8_t reg_addr
= etb_reg
->addr
& 0x7f;
307 struct scan_field fields
[3];
309 LOG_DEBUG("%i: 0x%8.8" PRIx32
"", (int)(etb_reg
->addr
), value
);
311 etb_scann(etb_reg
->etb
, 0x0);
312 etb_set_instr(etb_reg
->etb
, 0xc);
314 fields
[0].num_bits
= 32;
316 fields
[0].out_value
= temp0
;
317 buf_set_u32(&temp0
, 0, 32, value
);
318 fields
[0].in_value
= NULL
;
320 fields
[1].num_bits
= 7;
322 fields
[1].out_value
= &temp1
;
323 buf_set_u32(&temp1
, 0, 7, reg_addr
);
324 fields
[1].in_value
= NULL
;
326 fields
[2].num_bits
= 1;
328 fields
[2].out_value
= &temp2
;
329 buf_set_u32(&temp2
, 0, 1, 1);
330 fields
[2].in_value
= NULL
;
332 jtag_add_dr_scan(etb_reg
->etb
->tap
, 3, fields
, TAP_IDLE
);
337 COMMAND_HANDLER(handle_etb_config_command
)
339 struct target
*target
;
340 struct jtag_tap
*tap
;
345 return ERROR_COMMAND_SYNTAX_ERROR
;
348 target
= get_target(CMD_ARGV
[0]);
352 LOG_ERROR("ETB: target '%s' not defined", CMD_ARGV
[0]);
356 arm
= target_to_arm(target
);
359 command_print(CMD_CTX
, "ETB: '%s' isn't an ARM", CMD_ARGV
[0]);
363 tap
= jtag_tap_by_string(CMD_ARGV
[1]);
366 command_print(CMD_CTX
, "ETB: TAP %s does not exist", CMD_ARGV
[1]);
372 struct etb
*etb
= malloc(sizeof(struct etb
));
374 arm
->etm
->capture_driver_priv
= etb
;
377 etb
->cur_scan_chain
= 0xffffffff;
378 etb
->reg_cache
= NULL
;
384 LOG_ERROR("ETM: target has no ETM defined, ETB left unconfigured");
391 COMMAND_HANDLER(handle_etb_trigger_percent_command
)
393 struct target
*target
;
395 struct etm_context
*etm
;
398 target
= get_current_target(CMD_CTX
);
399 arm
= target_to_arm(target
);
402 command_print(CMD_CTX
, "ETB: current target isn't an ARM");
408 command_print(CMD_CTX
, "ETB: target has no ETM configured");
411 if (etm
->capture_driver
!= &etb_capture_driver
) {
412 command_print(CMD_CTX
, "ETB: target not using ETB");
415 etb
= arm
->etm
->capture_driver_priv
;
420 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], new_value
);
421 if ((new_value
< 2) || (new_value
> 100))
422 command_print(CMD_CTX
,
423 "valid percentages are 2%% to 100%%");
425 etb
->trigger_percent
= (unsigned) new_value
;
428 command_print(CMD_CTX
, "%d percent of tracebuffer fills after trigger",
429 etb
->trigger_percent
);
434 static const struct command_registration etb_config_command_handlers
[] = {
436 /* NOTE: with ADIv5, ETBs are accessed using DAP operations,
437 * possibly over SWD, not through separate TAPs...
440 .handler
= handle_etb_config_command
,
441 .mode
= COMMAND_CONFIG
,
442 .help
= "Associate ETB with target and JTAG TAP.",
443 .usage
= "target tap",
446 .name
= "trigger_percent",
447 .handler
= handle_etb_trigger_percent_command
,
448 .mode
= COMMAND_EXEC
,
449 .help
= "Set percent of trace buffer to be filled "
450 "after the trigger occurs (2..100).",
451 .usage
= "[percent]",
453 COMMAND_REGISTRATION_DONE
455 static const struct command_registration etb_command_handlers
[] = {
459 .help
= "Emebdded Trace Buffer command group",
460 .chain
= etb_config_command_handlers
,
462 COMMAND_REGISTRATION_DONE
465 static int etb_init(struct etm_context
*etm_ctx
)
467 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
469 etb
->etm_ctx
= etm_ctx
;
471 /* identify ETB RAM depth and width */
472 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_DEPTH
]);
473 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WIDTH
]);
474 jtag_execute_queue();
476 etb
->ram_depth
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_DEPTH
].value
, 0, 32);
477 etb
->ram_width
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WIDTH
].value
, 0, 32);
479 etb
->trigger_percent
= 50;
484 static trace_status_t
etb_status(struct etm_context
*etm_ctx
)
486 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
487 struct reg
*control
= &etb
->reg_cache
->reg_list
[ETB_CTRL
];
488 struct reg
*status
= &etb
->reg_cache
->reg_list
[ETB_STATUS
];
489 trace_status_t retval
= 0;
490 int etb_timeout
= 100;
492 etb
->etm_ctx
= etm_ctx
;
494 /* read control and status registers */
495 etb_read_reg(control
);
496 etb_read_reg(status
);
497 jtag_execute_queue();
499 /* See if it's (still) active */
500 retval
= buf_get_u32(control
->value
, 0, 1) ? TRACE_RUNNING
: TRACE_IDLE
;
502 /* check Full bit to identify wraparound/overflow */
503 if (buf_get_u32(status
->value
, 0, 1) == 1)
504 retval
|= TRACE_OVERFLOWED
;
506 /* check Triggered bit to identify trigger condition */
507 if (buf_get_u32(status
->value
, 1, 1) == 1)
508 retval
|= TRACE_TRIGGERED
;
510 /* check AcqComp to see if trigger counter dropped to zero */
511 if (buf_get_u32(status
->value
, 2, 1) == 1) {
512 /* wait for DFEmpty */
513 while (etb_timeout
-- && buf_get_u32(status
->value
, 3, 1) == 0)
516 if (etb_timeout
== 0)
517 LOG_ERROR("ETB: DFEmpty won't go high, status 0x%02x",
518 (unsigned) buf_get_u32(status
->value
, 0, 4));
520 if (!(etm_ctx
->capture_status
& TRACE_TRIGGERED
))
521 LOG_WARNING("ETB: trace complete without triggering?");
523 retval
|= TRACE_COMPLETED
;
526 /* NOTE: using a trigger is optional; and at least ETB11 has a mode
527 * where it can ignore the trigger counter.
530 /* update recorded state */
531 etm_ctx
->capture_status
= retval
;
536 static int etb_read_trace(struct etm_context
*etm_ctx
)
538 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
540 int num_frames
= etb
->ram_depth
;
541 uint32_t *trace_data
= NULL
;
544 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_STATUS
]);
545 etb_read_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
]);
546 jtag_execute_queue();
548 /* check if we overflowed, and adjust first frame of the trace accordingly
549 * if we didn't overflow, read only up to the frame that would be written next,
550 * i.e. don't read invalid entries
552 if (buf_get_u32(etb
->reg_cache
->reg_list
[ETB_STATUS
].value
, 0, 1))
554 first_frame
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
].value
, 0, 32);
558 num_frames
= buf_get_u32(etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
].value
, 0, 32);
561 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_READ_POINTER
], first_frame
);
563 /* read data into temporary array for unpacking */
564 trace_data
= malloc(sizeof(uint32_t) * num_frames
);
565 etb_read_ram(etb
, trace_data
, num_frames
);
567 if (etm_ctx
->trace_depth
> 0)
569 free(etm_ctx
->trace_data
);
572 if ((etm_ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_4BIT
)
573 etm_ctx
->trace_depth
= num_frames
* 3;
574 else if ((etm_ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_8BIT
)
575 etm_ctx
->trace_depth
= num_frames
* 2;
577 etm_ctx
->trace_depth
= num_frames
;
579 etm_ctx
->trace_data
= malloc(sizeof(struct etmv1_trace_data
) * etm_ctx
->trace_depth
);
581 for (i
= 0, j
= 0; i
< num_frames
; i
++)
583 if ((etm_ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_4BIT
)
586 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
587 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x78) >> 3;
588 etm_ctx
->trace_data
[j
].flags
= 0;
589 if ((trace_data
[i
] & 0x80) >> 7)
591 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
593 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
595 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
596 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
599 /* trace word j + 1 */
600 etm_ctx
->trace_data
[j
+ 1].pipestat
= (trace_data
[i
] & 0x100) >> 8;
601 etm_ctx
->trace_data
[j
+ 1].packet
= (trace_data
[i
] & 0x7800) >> 11;
602 etm_ctx
->trace_data
[j
+ 1].flags
= 0;
603 if ((trace_data
[i
] & 0x8000) >> 15)
605 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRACESYNC_CYCLE
;
607 if (etm_ctx
->trace_data
[j
+ 1].pipestat
== STAT_TR
)
609 etm_ctx
->trace_data
[j
+ 1].pipestat
= etm_ctx
->trace_data
[j
+ 1].packet
& 0x7;
610 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRIGGER_CYCLE
;
613 /* trace word j + 2 */
614 etm_ctx
->trace_data
[j
+ 2].pipestat
= (trace_data
[i
] & 0x10000) >> 16;
615 etm_ctx
->trace_data
[j
+ 2].packet
= (trace_data
[i
] & 0x780000) >> 19;
616 etm_ctx
->trace_data
[j
+ 2].flags
= 0;
617 if ((trace_data
[i
] & 0x800000) >> 23)
619 etm_ctx
->trace_data
[j
+ 2].flags
|= ETMV1_TRACESYNC_CYCLE
;
621 if (etm_ctx
->trace_data
[j
+ 2].pipestat
== STAT_TR
)
623 etm_ctx
->trace_data
[j
+ 2].pipestat
= etm_ctx
->trace_data
[j
+ 2].packet
& 0x7;
624 etm_ctx
->trace_data
[j
+ 2].flags
|= ETMV1_TRIGGER_CYCLE
;
629 else if ((etm_ctx
->control
& ETM_PORT_WIDTH_MASK
) == ETM_PORT_8BIT
)
632 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
633 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x7f8) >> 3;
634 etm_ctx
->trace_data
[j
].flags
= 0;
635 if ((trace_data
[i
] & 0x800) >> 11)
637 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
639 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
641 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
642 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
645 /* trace word j + 1 */
646 etm_ctx
->trace_data
[j
+ 1].pipestat
= (trace_data
[i
] & 0x7000) >> 12;
647 etm_ctx
->trace_data
[j
+ 1].packet
= (trace_data
[i
] & 0x7f8000) >> 15;
648 etm_ctx
->trace_data
[j
+ 1].flags
= 0;
649 if ((trace_data
[i
] & 0x800000) >> 23)
651 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRACESYNC_CYCLE
;
653 if (etm_ctx
->trace_data
[j
+ 1].pipestat
== STAT_TR
)
655 etm_ctx
->trace_data
[j
+ 1].pipestat
= etm_ctx
->trace_data
[j
+ 1].packet
& 0x7;
656 etm_ctx
->trace_data
[j
+ 1].flags
|= ETMV1_TRIGGER_CYCLE
;
664 etm_ctx
->trace_data
[j
].pipestat
= trace_data
[i
] & 0x7;
665 etm_ctx
->trace_data
[j
].packet
= (trace_data
[i
] & 0x7fff8) >> 3;
666 etm_ctx
->trace_data
[j
].flags
= 0;
667 if ((trace_data
[i
] & 0x80000) >> 19)
669 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRACESYNC_CYCLE
;
671 if (etm_ctx
->trace_data
[j
].pipestat
== STAT_TR
)
673 etm_ctx
->trace_data
[j
].pipestat
= etm_ctx
->trace_data
[j
].packet
& 0x7;
674 etm_ctx
->trace_data
[j
].flags
|= ETMV1_TRIGGER_CYCLE
;
686 static int etb_start_capture(struct etm_context
*etm_ctx
)
688 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
689 uint32_t etb_ctrl_value
= 0x1;
690 uint32_t trigger_count
;
692 if ((etm_ctx
->control
& ETM_PORT_MODE_MASK
) == ETM_PORT_DEMUXED
)
694 if ((etm_ctx
->control
& ETM_PORT_WIDTH_MASK
) != ETM_PORT_8BIT
)
696 LOG_ERROR("ETB can't run in demultiplexed mode with a 4 or 16 bit port");
697 return ERROR_ETM_PORTMODE_NOT_SUPPORTED
;
699 etb_ctrl_value
|= 0x2;
702 if ((etm_ctx
->control
& ETM_PORT_MODE_MASK
) == ETM_PORT_MUXED
) {
703 LOG_ERROR("ETB: can't run in multiplexed mode");
704 return ERROR_ETM_PORTMODE_NOT_SUPPORTED
;
707 trigger_count
= (etb
->ram_depth
* etb
->trigger_percent
) / 100;
709 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_TRIGGER_COUNTER
], trigger_count
);
710 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_RAM_WRITE_POINTER
], 0x0);
711 etb_write_reg(&etb
->reg_cache
->reg_list
[ETB_CTRL
], etb_ctrl_value
);
712 jtag_execute_queue();
714 /* we're starting a new trace, initialize capture status */
715 etm_ctx
->capture_status
= TRACE_RUNNING
;
720 static int etb_stop_capture(struct etm_context
*etm_ctx
)
722 struct etb
*etb
= etm_ctx
->capture_driver_priv
;
723 struct reg
*etb_ctrl_reg
= &etb
->reg_cache
->reg_list
[ETB_CTRL
];
725 etb_write_reg(etb_ctrl_reg
, 0x0);
726 jtag_execute_queue();
728 /* trace stopped, just clear running flag, but preserve others */
729 etm_ctx
->capture_status
&= ~TRACE_RUNNING
;
734 struct etm_capture_driver etb_capture_driver
=
737 .commands
= etb_command_handlers
,
739 .status
= etb_status
,
740 .start_capture
= etb_start_capture
,
741 .stop_capture
= etb_stop_capture
,
742 .read_trace
= etb_read_trace
,
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)