X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fetm.c;h=044ccb06265cd142b7dd094e0ca23f6d6f49c32e;hp=6d34f6c9ca89471226f0259643d1dfa2a1e1e2ff;hb=7bf1a86e473a12882bf6f71cb4d0d416394b69d4;hpb=9f212b01be20da43ba534ad33b20419779c89335 diff --git a/src/target/etm.c b/src/target/etm.c index 6d34f6c9ca..044ccb0626 100644 --- a/src/target/etm.c +++ b/src/target/etm.c @@ -22,9 +22,11 @@ #endif #include "armv4_5.h" +#include "etm.h" #include "etb.h" #include "image.h" #include "arm_disassembler.h" +#include "register.h" /* @@ -49,8 +51,6 @@ * ARM IHI 0014O ... Embedded Trace Macrocell, Architecture Specification */ -#define ARRAY_SIZE(x) ((int)(sizeof(x)/sizeof((x)[0]))) - enum { RO, /* read/only */ WO, /* write/only */ @@ -214,28 +214,30 @@ static const struct etm_reg_info etm_outputs[] = { { 0x6f, 32, RO, 0x20, "ETM_contextid_comparator_mask", } #endif -static int etm_reg_arch_type = -1; - -static int etm_get_reg(reg_t *reg); -static int etm_read_reg_w_check(reg_t *reg, +static int etm_get_reg(struct reg *reg); +static int etm_read_reg_w_check(struct reg *reg, uint8_t* check_value, uint8_t* check_mask); -static int etm_register_user_commands(struct command_context_s *cmd_ctx); -static int etm_set_reg_w_exec(reg_t *reg, uint8_t *buf); -static int etm_write_reg(reg_t *reg, uint32_t value); +static int etm_register_user_commands(struct command_context *cmd_ctx); +static int etm_set_reg_w_exec(struct reg *reg, uint8_t *buf); +static int etm_write_reg(struct reg *reg, uint32_t value); -static command_t *etm_cmd; +static struct command *etm_cmd; +static const struct reg_arch_type etm_scan6_type = { + .get = etm_get_reg, + .set = etm_set_reg_w_exec, +}; /* Look up register by ID ... most ETM instances only * support a subset of the possible registers. */ -static reg_t *etm_reg_lookup(etm_context_t *etm_ctx, unsigned id) +static struct reg *etm_reg_lookup(struct etm_context *etm_ctx, unsigned id) { - reg_cache_t *cache = etm_ctx->reg_cache; + struct reg_cache *cache = etm_ctx->reg_cache; int i; for (i = 0; i < cache->num_regs; i++) { - struct etm_reg_s *reg = cache->reg_list[i].arch_info; + struct etm_reg *reg = cache->reg_list[i].arch_info; if (reg->reg_info->addr == id) return &cache->reg_list[i]; @@ -247,11 +249,11 @@ static reg_t *etm_reg_lookup(etm_context_t *etm_ctx, unsigned id) return NULL; } -static void etm_reg_add(unsigned bcd_vers, arm_jtag_t *jtag_info, - reg_cache_t *cache, etm_reg_t *ereg, +static void etm_reg_add(unsigned bcd_vers, struct arm_jtag *jtag_info, + struct reg_cache *cache, struct etm_reg *ereg, const struct etm_reg_info *r, unsigned nreg) { - reg_t *reg = cache->reg_list; + struct reg *reg = cache->reg_list; reg += cache->num_regs; ereg += cache->num_regs; @@ -269,7 +271,7 @@ static void etm_reg_add(unsigned bcd_vers, arm_jtag_t *jtag_info, reg->size = r->size; reg->value = &ereg->value; reg->arch_info = ereg; - reg->arch_type = etm_reg_arch_type; + reg->type = &etm_scan6_type; reg++; cache->num_regs++; @@ -279,22 +281,17 @@ static void etm_reg_add(unsigned bcd_vers, arm_jtag_t *jtag_info, } } -reg_cache_t *etm_build_reg_cache(target_t *target, - arm_jtag_t *jtag_info, etm_context_t *etm_ctx) +struct reg_cache *etm_build_reg_cache(struct target *target, + struct arm_jtag *jtag_info, struct etm_context *etm_ctx) { - reg_cache_t *reg_cache = malloc(sizeof(reg_cache_t)); - reg_t *reg_list = NULL; - etm_reg_t *arch_info = NULL; + struct reg_cache *reg_cache = malloc(sizeof(struct reg_cache)); + struct reg *reg_list = NULL; + struct etm_reg *arch_info = NULL; unsigned bcd_vers, config; - /* register a register arch-type for etm registers only once */ - if (etm_reg_arch_type == -1) - etm_reg_arch_type = register_reg_arch_type(etm_get_reg, - etm_set_reg_w_exec); - /* the actual registers are kept in two arrays */ - reg_list = calloc(128, sizeof(reg_t)); - arch_info = calloc(128, sizeof(etm_reg_t)); + reg_list = calloc(128, sizeof(struct reg)); + arch_info = calloc(128, sizeof(struct etm_reg)); /* fill in values for the reg cache */ reg_cache->name = "etm registers"; @@ -349,10 +346,7 @@ reg_cache_t *etm_build_reg_cache(target_t *target, break; default: LOG_WARNING("Bad ETMv1 protocol %d", config >> 28); - free(reg_cache); - free(reg_list); - free(arch_info); - return ERROR_OK; + goto fail; } } etm_ctx->bcd_vers = bcd_vers; @@ -391,15 +385,12 @@ reg_cache_t *etm_build_reg_cache(target_t *target, /* the ETM might have an ETB connected */ if (strcmp(etm_ctx->capture_driver->name, "etb") == 0) { - etb_t *etb = etm_ctx->capture_driver_priv; + struct etb *etb = etm_ctx->capture_driver_priv; if (!etb) { LOG_ERROR("etb selected as etm capture driver, but no ETB configured"); - free(reg_cache); - free(reg_list); - free(arch_info); - return ERROR_OK; + goto fail; } reg_cache->next = etb_build_reg_cache(etb); @@ -409,25 +400,31 @@ reg_cache_t *etm_build_reg_cache(target_t *target, etm_ctx->reg_cache = reg_cache; return reg_cache; + +fail: + free(reg_cache); + free(reg_list); + free(arch_info); + return NULL; } -static int etm_read_reg(reg_t *reg) +static int etm_read_reg(struct reg *reg) { return etm_read_reg_w_check(reg, NULL, NULL); } -static int etm_store_reg(reg_t *reg) +static int etm_store_reg(struct reg *reg) { return etm_write_reg(reg, buf_get_u32(reg->value, 0, reg->size)); } -int etm_setup(target_t *target) +int etm_setup(struct target *target) { int retval; uint32_t etm_ctrl_value; struct arm *arm = target_to_arm(target); - etm_context_t *etm_ctx = arm->etm; - reg_t *etm_ctrl_reg; + struct etm_context *etm_ctx = arm->etm; + struct reg *etm_ctrl_reg; etm_ctrl_reg = etm_reg_lookup(etm_ctx, ETM_CTRL); if (!etm_ctrl_reg) @@ -467,7 +464,7 @@ int etm_setup(target_t *target) return ERROR_OK; } -static int etm_get_reg(reg_t *reg) +static int etm_get_reg(struct reg *reg) { int retval; @@ -486,13 +483,13 @@ static int etm_get_reg(reg_t *reg) return ERROR_OK; } -static int etm_read_reg_w_check(reg_t *reg, +static int etm_read_reg_w_check(struct reg *reg, uint8_t* check_value, uint8_t* check_mask) { - etm_reg_t *etm_reg = reg->arch_info; + struct etm_reg *etm_reg = reg->arch_info; const struct etm_reg_info *r = etm_reg->reg_info; uint8_t reg_addr = r->addr & 0x7f; - scan_field_t fields[3]; + struct scan_field fields[3]; if (etm_reg->reg_info->mode == WO) { LOG_ERROR("BUG: can't read write-only register %s", r->name); @@ -542,7 +539,7 @@ static int etm_read_reg_w_check(reg_t *reg, return ERROR_OK; } -static int etm_set_reg(reg_t *reg, uint32_t value) +static int etm_set_reg(struct reg *reg, uint32_t value) { int retval; @@ -559,7 +556,7 @@ static int etm_set_reg(reg_t *reg, uint32_t value) return ERROR_OK; } -static int etm_set_reg_w_exec(reg_t *reg, uint8_t *buf) +static int etm_set_reg_w_exec(struct reg *reg, uint8_t *buf) { int retval; @@ -573,12 +570,12 @@ static int etm_set_reg_w_exec(reg_t *reg, uint8_t *buf) return ERROR_OK; } -static int etm_write_reg(reg_t *reg, uint32_t value) +static int etm_write_reg(struct reg *reg, uint32_t value) { - etm_reg_t *etm_reg = reg->arch_info; + struct etm_reg *etm_reg = reg->arch_info; const struct etm_reg_info *r = etm_reg->reg_info; uint8_t reg_addr = r->addr & 0x7f; - scan_field_t fields[3]; + struct scan_field fields[3]; if (etm_reg->reg_info->mode == RO) { LOG_ERROR("BUG: can't write read--only register %s", r->name); @@ -621,12 +618,12 @@ static int etm_write_reg(reg_t *reg, uint32_t value) /* ETM trace analysis functionality * */ -extern etm_capture_driver_t etm_dummy_capture_driver; +extern struct etm_capture_driver etm_dummy_capture_driver; #if BUILD_OOCD_TRACE == 1 -extern etm_capture_driver_t oocd_trace_capture_driver; +extern struct etm_capture_driver oocd_trace_capture_driver; #endif -static etm_capture_driver_t *etm_capture_drivers[] = +static struct etm_capture_driver *etm_capture_drivers[] = { &etb_capture_driver, &etm_dummy_capture_driver, @@ -636,11 +633,11 @@ static etm_capture_driver_t *etm_capture_drivers[] = NULL }; -static int etm_read_instruction(etm_context_t *ctx, arm_instruction_t *instruction) +static int etm_read_instruction(struct etm_context *ctx, struct arm_instruction *instruction) { int i; int section = -1; - uint32_t size_read; + size_t size_read; uint32_t opcode; int retval; @@ -704,7 +701,7 @@ static int etm_read_instruction(etm_context_t *ctx, arm_instruction_t *instructi return ERROR_OK; } -static int etmv1_next_packet(etm_context_t *ctx, uint8_t *packet, int apo) +static int etmv1_next_packet(struct etm_context *ctx, uint8_t *packet, int apo) { while (ctx->data_index < ctx->trace_depth) { @@ -769,7 +766,7 @@ static int etmv1_next_packet(etm_context_t *ctx, uint8_t *packet, int apo) return -1; } -static int etmv1_branch_address(etm_context_t *ctx) +static int etmv1_branch_address(struct etm_context *ctx) { int retval; uint8_t packet; @@ -855,7 +852,7 @@ static int etmv1_branch_address(etm_context_t *ctx) return 0; } -static int etmv1_data(etm_context_t *ctx, int size, uint32_t *data) +static int etmv1_data(struct etm_context *ctx, int size, uint32_t *data) { int j; uint8_t buf[4]; @@ -884,10 +881,10 @@ static int etmv1_data(etm_context_t *ctx, int size, uint32_t *data) return 0; } -static int etmv1_analyze_trace(etm_context_t *ctx, struct command_context_s *cmd_ctx) +static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context *cmd_ctx) { int retval; - arm_instruction_t instruction; + struct arm_instruction instruction; /* read the trace data if it wasn't read already */ if (ctx->trace_depth == 0) @@ -1249,9 +1246,9 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update, COMMAND_HANDLER(handle_etm_tracemode_command) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); struct arm *arm = target_to_arm(target); - struct etm *etm; + struct etm_context *etm; if (!is_arm(arm)) { command_print(cmd_ctx, "ETM: current target isn't an ARM"); @@ -1266,7 +1263,7 @@ COMMAND_HANDLER(handle_etm_tracemode_command) etmv1_tracemode_t tracemode = etm->tracemode; - switch (argc) + switch (CMD_ARGC) { case 0: break; @@ -1340,7 +1337,7 @@ COMMAND_HANDLER(handle_etm_tracemode_command) /* only update ETM_CTRL register if tracemode changed */ if (etm->tracemode != tracemode) { - reg_t *etm_ctrl_reg; + struct reg *etm_ctrl_reg; etm_ctrl_reg = etm_reg_lookup(etm, ETM_CTRL); if (!etm_ctrl_reg) @@ -1371,13 +1368,13 @@ COMMAND_HANDLER(handle_etm_tracemode_command) COMMAND_HANDLER(handle_etm_config_command) { - target_t *target; + struct target *target; struct arm *arm; etm_portmode_t portmode = 0x0; - struct etm *etm_ctx; + struct etm_context *etm_ctx; int i; - if (argc != 5) + if (CMD_ARGC != 5) return ERROR_COMMAND_SYNTAX_ERROR; target = get_target(args[0]); @@ -1477,7 +1474,7 @@ COMMAND_HANDLER(handle_etm_config_command) return ERROR_FAIL; } - etm_ctx = calloc(1, sizeof(etm_context_t)); + etm_ctx = calloc(1, sizeof(struct etm_context)); if (!etm_ctx) { LOG_DEBUG("out of memory"); return ERROR_FAIL; @@ -1521,10 +1518,10 @@ COMMAND_HANDLER(handle_etm_config_command) COMMAND_HANDLER(handle_etm_info_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm; - reg_t *etm_sys_config_reg; + struct etm_context *etm; + struct reg *etm_sys_config_reg; int max_port_size; uint32_t config; @@ -1653,9 +1650,9 @@ COMMAND_HANDLER(handle_etm_info_command) COMMAND_HANDLER(handle_etm_status_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm; + struct etm_context *etm; trace_status_t trace_status; target = get_current_target(cmd_ctx); @@ -1675,7 +1672,7 @@ COMMAND_HANDLER(handle_etm_status_command) /* ETM status */ if (etm->bcd_vers >= 0x11) { - reg_t *reg; + struct reg *reg; reg = etm_reg_lookup(etm, ETM_STATUS); if (!reg) @@ -1729,11 +1726,11 @@ COMMAND_HANDLER(handle_etm_status_command) COMMAND_HANDLER(handle_etm_image_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; + struct etm_context *etm_ctx; - if (argc < 1) + if (CMD_ARGC < 1) { command_print(cmd_ctx, "usage: etm image [base address] [type]"); return ERROR_FAIL; @@ -1761,12 +1758,12 @@ COMMAND_HANDLER(handle_etm_image_command) command_print(cmd_ctx, "previously loaded image found and closed"); } - etm_ctx->image = malloc(sizeof(image_t)); + etm_ctx->image = malloc(sizeof(struct image)); etm_ctx->image->base_address_set = 0; etm_ctx->image->start_address_set = 0; /* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */ - if (argc >= 2) + if (CMD_ARGC >= 2) { etm_ctx->image->base_address_set = 1; COMMAND_PARSE_NUMBER(int, args[1], etm_ctx->image->base_address); @@ -1776,7 +1773,7 @@ COMMAND_HANDLER(handle_etm_image_command) etm_ctx->image->base_address_set = 0; } - if (image_open(etm_ctx->image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) + if (image_open(etm_ctx->image, args[0], (CMD_ARGC >= 3) ? args[2] : NULL) != ERROR_OK) { free(etm_ctx->image); etm_ctx->image = NULL; @@ -1789,12 +1786,12 @@ COMMAND_HANDLER(handle_etm_image_command) COMMAND_HANDLER(handle_etm_dump_command) { struct fileio file; - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; + struct etm_context *etm_ctx; uint32_t i; - if (argc != 1) + if (CMD_ARGC != 1) { command_print(cmd_ctx, "usage: etm dump "); return ERROR_FAIL; @@ -1857,12 +1854,12 @@ COMMAND_HANDLER(handle_etm_dump_command) COMMAND_HANDLER(handle_etm_load_command) { struct fileio file; - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; + struct etm_context *etm_ctx; uint32_t i; - if (argc != 1) + if (CMD_ARGC != 1) { command_print(cmd_ctx, "usage: etm load "); return ERROR_FAIL; @@ -1914,7 +1911,7 @@ COMMAND_HANDLER(handle_etm_load_command) fileio_read_u32(&file, &tmp); etm_ctx->tracemode = tmp; fileio_read_u32(&file, &etm_ctx->trace_depth); } - etm_ctx->trace_data = malloc(sizeof(etmv1_trace_data_t) * etm_ctx->trace_depth); + etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth); if (etm_ctx->trace_data == NULL) { command_print(cmd_ctx, "not enough memory to perform operation"); @@ -1940,9 +1937,9 @@ COMMAND_HANDLER(handle_etm_load_command) COMMAND_HANDLER(handle_etm_trigger_percent_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; + struct etm_context *etm_ctx; target = get_current_target(cmd_ctx); arm = target_to_arm(target); @@ -1959,7 +1956,7 @@ COMMAND_HANDLER(handle_etm_trigger_percent_command) return ERROR_FAIL; } - if (argc > 0) + if (CMD_ARGC > 0) { uint32_t new_value; COMMAND_PARSE_NUMBER(u32, args[0], new_value); @@ -1981,10 +1978,10 @@ COMMAND_HANDLER(handle_etm_trigger_percent_command) COMMAND_HANDLER(handle_etm_start_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; - reg_t *etm_ctrl_reg; + struct etm_context *etm_ctx; + struct reg *etm_ctrl_reg; target = get_current_target(cmd_ctx); arm = target_to_arm(target); @@ -2029,10 +2026,10 @@ COMMAND_HANDLER(handle_etm_start_command) COMMAND_HANDLER(handle_etm_stop_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; - reg_t *etm_ctrl_reg; + struct etm_context *etm_ctx; + struct reg *etm_ctrl_reg; target = get_current_target(cmd_ctx); arm = target_to_arm(target); @@ -2068,9 +2065,9 @@ COMMAND_HANDLER(handle_etm_stop_command) COMMAND_HANDLER(handle_etm_analyze_command) { - target_t *target; + struct target *target; struct arm *arm; - etm_context_t *etm_ctx; + struct etm_context *etm_ctx; int retval; target = get_current_target(cmd_ctx); @@ -2109,7 +2106,7 @@ COMMAND_HANDLER(handle_etm_analyze_command) return retval; } -int etm_register_commands(struct command_context_s *cmd_ctx) +int etm_register_commands(struct command_context *cmd_ctx) { etm_cmd = register_command(cmd_ctx, NULL, "etm", NULL, COMMAND_ANY, "Embedded Trace Macrocell"); @@ -2119,7 +2116,7 @@ int etm_register_commands(struct command_context_s *cmd_ctx) return ERROR_OK; } -static int etm_register_user_commands(struct command_context_s *cmd_ctx) +static int etm_register_user_commands(struct command_context *cmd_ctx) { register_command(cmd_ctx, etm_cmd, "tracemode", handle_etm_tracemode_command, COMMAND_EXEC, "configure/display trace mode: "