From 9abad965ab358c1d598f1354842967cad637b284 Mon Sep 17 00:00:00 2001 From: David Brownell Date: Sat, 19 Dec 2009 13:06:46 -0800 Subject: [PATCH] ETM trigger_percent becomes an ETB command This command was misplaced; it's not generic to all traceport drivers, only the ETB supports this kind of configuration. So move it, and update the relevant documentation. Signed-off-by: David Brownell --- NEWS | 2 ++ doc/openocd.texi | 44 ++++++++++++++++++------------------- src/target/etb.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++-- src/target/etb.h | 3 +++ src/target/etm.c | 49 ----------------------------------------- src/target/etm.h | 1 - 6 files changed, 82 insertions(+), 74 deletions(-) diff --git a/NEWS b/NEWS index 67778eff..efcf8f61 100644 --- a/NEWS +++ b/NEWS @@ -32,6 +32,8 @@ Target Layer: - watchpoint support Cortex-M3 - Exposed DWT registers like cycle counter + ETM, ETB + - "trigger_percent" command moved ETM --> ETB Flash Layer: 'flash bank' and 'nand device' take as first argument. diff --git a/doc/openocd.texi b/doc/openocd.texi index cda5be38..bb3e51ac 100644 --- a/doc/openocd.texi +++ b/doc/openocd.texi @@ -5512,28 +5512,6 @@ trace stream without an image of the code. @end itemize @end deffn -@deffn Command {etm trigger_percent} [percent] -This displays, or optionally changes, the trace port driver's -behavior after the ETM's configured @emph{trigger} event fires. -It controls how much more trace data is saved after the (single) -trace trigger becomes active. - -@itemize -@item The default corresponds to @emph{trace around} usage, -recording 50 percent data before the event and the rest -afterwards. -@item The minimum value of @var{percent} is 2 percent, -recording almost exclusively data before the trigger. -Such extreme @emph{trace before} usage can help figure out -what caused that event to happen. -@item The maximum value of @var{percent} is 100 percent, -recording data almost exclusively after the event. -This extreme @emph{trace after} usage might help sort out -how the event caused trouble. -@end itemize -@c REVISIT allow "break" too -- enter debug mode. -@end deffn - @subsection ETM Trace Operation After setting up the ETM, you can use it to collect data. @@ -5617,6 +5595,28 @@ to use on-chip ETB memory. Associates the ETM for @var{target} with the ETB at @var{etb_tap}. You can see the ETB registers using the @command{reg} command. @end deffn +@deffn Command {etb trigger_percent} [percent] +This displays, or optionally changes, ETB behavior after the +ETM's configured @emph{trigger} event fires. +It controls how much more trace data is saved after the (single) +trace trigger becomes active. + +@itemize +@item The default corresponds to @emph{trace around} usage, +recording 50 percent data before the event and the rest +afterwards. +@item The minimum value of @var{percent} is 2 percent, +recording almost exclusively data before the trigger. +Such extreme @emph{trace before} usage can help figure out +what caused that event to happen. +@item The maximum value of @var{percent} is 100 percent, +recording data almost exclusively after the event. +This extreme @emph{trace after} usage might help sort out +how the event caused trouble. +@end itemize +@c REVISIT allow "break" too -- enter debug mode. +@end deffn + @end deffn @deffn {Trace Port Driver} oocd_trace diff --git a/src/target/etb.c b/src/target/etb.c index 3113eca0..a789777b 100644 --- a/src/target/etb.c +++ b/src/target/etb.c @@ -402,12 +402,63 @@ COMMAND_HANDLER(handle_etb_config_command) return ERROR_OK; } +COMMAND_HANDLER(handle_etb_trigger_percent_command) +{ + struct target *target; + struct arm *arm; + struct etm_context *etm; + struct etb *etb; + + target = get_current_target(CMD_CTX); + arm = target_to_arm(target); + if (!is_arm(arm)) + { + command_print(CMD_CTX, "ETB: current target isn't an ARM"); + return ERROR_FAIL; + } + + etm = arm->etm; + if (!etm) { + command_print(CMD_CTX, "ETB: target has no ETM configured"); + return ERROR_FAIL; + } + if (etm->capture_driver != &etb_capture_driver) { + command_print(CMD_CTX, "ETB: target not using ETB"); + return ERROR_FAIL; + } + etb = arm->etm->capture_driver_priv; + + if (CMD_ARGC > 0) { + uint32_t new_value; + + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value); + if ((new_value < 2) || (new_value > 100)) + command_print(CMD_CTX, + "valid percentages are 2%% to 100%%"); + else + etb->trigger_percent = (unsigned) new_value; + } + + command_print(CMD_CTX, "%d percent of tracebuffer fills after trigger", + etb->trigger_percent); + + return ERROR_OK; +} + static const struct command_registration etb_config_command_handlers[] = { { .name = "config", .handler = &handle_etb_config_command, .mode = COMMAND_CONFIG, - .usage = " ", + .usage = "target tap", + }, + { + .name = "trigger_percent", + .handler = &handle_etb_trigger_percent_command, + .mode = COMMAND_EXEC, + .help = "percent of trace buffer to be filled " + "after the trigger occurs", + .usage = "[percent]", }, COMMAND_REGISTRATION_DONE }; @@ -435,6 +486,8 @@ static int etb_init(struct etm_context *etm_ctx) etb->ram_depth = buf_get_u32(etb->reg_cache->reg_list[ETB_RAM_DEPTH].value, 0, 32); etb->ram_width = buf_get_u32(etb->reg_cache->reg_list[ETB_RAM_WIDTH].value, 0, 32); + etb->trigger_percent = 50; + return ERROR_OK; } @@ -661,7 +714,7 @@ static int etb_start_capture(struct etm_context *etm_ctx) return ERROR_ETM_PORTMODE_NOT_SUPPORTED; } - trigger_count = (etb->ram_depth * etm_ctx->trigger_percent) / 100; + trigger_count = (etb->ram_depth * etb->trigger_percent) / 100; etb_write_reg(&etb->reg_cache->reg_list[ETB_TRIGGER_COUNTER], trigger_count); etb_write_reg(&etb->reg_cache->reg_list[ETB_RAM_WRITE_POINTER], 0x0); diff --git a/src/target/etb.h b/src/target/etb.h index 49385ee9..dfffb68a 100644 --- a/src/target/etb.h +++ b/src/target/etb.h @@ -44,6 +44,9 @@ struct etb /* ETB parameters */ uint32_t ram_depth; uint32_t ram_width; + + /** how much trace buffer to fill after trigger */ + unsigned trigger_percent; }; struct etb_reg diff --git a/src/target/etm.c b/src/target/etm.c index 9cb647cb..fff94949 100644 --- a/src/target/etm.c +++ b/src/target/etm.c @@ -1494,7 +1494,6 @@ COMMAND_HANDLER(handle_etm_config_command) } etm_ctx->target = target; - etm_ctx->trigger_percent = 50; etm_ctx->trace_data = NULL; etm_ctx->portmode = portmode; etm_ctx->core_state = ARM_STATE_ARM; @@ -1923,47 +1922,6 @@ COMMAND_HANDLER(handle_etm_load_command) return ERROR_OK; } -COMMAND_HANDLER(handle_etm_trigger_percent_command) -{ - struct target *target; - struct arm *arm; - struct etm_context *etm_ctx; - - target = get_current_target(CMD_CTX); - arm = target_to_arm(target); - if (!is_arm(arm)) - { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); - return ERROR_FAIL; - } - - etm_ctx = arm->etm; - if (!etm_ctx) - { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); - return ERROR_FAIL; - } - - if (CMD_ARGC > 0) - { - uint32_t new_value; - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value); - - if ((new_value < 2) || (new_value > 100)) - { - command_print(CMD_CTX, "valid settings are 2%% to 100%%"); - } - else - { - etm_ctx->trigger_percent = new_value; - } - } - - command_print(CMD_CTX, "%i percent of the tracebuffer reserved for after the trigger", ((int)(etm_ctx->trigger_percent))); - - return ERROR_OK; -} - COMMAND_HANDLER(handle_etm_start_command) { struct target *target; @@ -2128,13 +2086,6 @@ static const struct command_registration etm_exec_command_handlers[] = { .mode = COMMAND_EXEC, .help = "display info about the current target's ETM", }, - { - .name = "trigger_percent", - .handler = &handle_etm_trigger_percent_command, - .mode = COMMAND_EXEC, - .help = "amount () of trace buffer " - "to be filled after the trigger occured", - }, { .name = "status", .handler = &handle_etm_status_command, diff --git a/src/target/etm.h b/src/target/etm.h index 5b4d5e15..78a5996c 100644 --- a/src/target/etm.h +++ b/src/target/etm.h @@ -158,7 +158,6 @@ struct etm_context struct reg_cache *reg_cache; /* ETM register cache */ struct etm_capture_driver *capture_driver; /* driver used to access ETM data */ void *capture_driver_priv; /* capture driver private data */ - uint32_t trigger_percent; /* how much trace buffer to fill after trigger */ trace_status_t capture_status; /* current state of capture run */ struct etmv1_trace_data *trace_data; /* trace data */ uint32_t trace_depth; /* number of cycles to be analyzed, 0 if no data available */ -- 2.39.5