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 <dbrownell@users.sourceforge.net>

diff --git a/NEWS b/NEWS
index 67778eff6dde0cc1d6a55e4b114ff75c1144224d..efcf8f619d4bcf91dc0e82bb0db614bb90696d9a 100644 (file)
--- 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 <bank_name> as first argument.

diff --git a/doc/openocd.texi b/doc/openocd.texi
index cda5be385ba43f5df546bf5df9f26d2a7c36146d..bb3e51ac1e61b6d988653ed57ceb1214e241879a 100644 (file)
--- 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 3113eca0651c70750436b71cb2a255b86586b511..a789777baa64e8f6bce650f3e124b78746c7c160 100644 (file)
--- 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 = "<target> <tap>",
+               .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 49385ee90d0c99897f8cf8f2828ec9ed0804091c..dfffb68a242ccc97efe8eba8d209ebdf38092566 100644 (file)
--- 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 9cb647cbebff0096328a9df69566ea5e93c85be1..fff94949470d74bfada734c0424233a11dd1b86f 100644 (file)
--- 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 (<percent>) 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 5b4d5e15159ce8d95c50c3d0ebaca45aed3d38d9..78a5996ca974db7fc9e8639193b3261590682403 100644 (file)
--- 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 */