X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Fetm.c;h=72e8b3d21fe422b0f7b58da5e8863db8f36fe91f;hb=23402315ce01071f30d7ec0c5ca7563ce41f1cc6;hp=a4ff6c5f5626e71d2e056105010eac37a0ec1bb0;hpb=5b6df55a1e5e4c0f531bc336691bc7c9a6a0df87;p=openocd.git diff --git a/src/target/etm.c b/src/target/etm.c index a4ff6c5f56..72e8b3d21f 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) @@ -1182,22 +1179,22 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update, etmv1_tracemode_t tracemode; /* what parts of data access are traced? */ - if (strcmp(args[0], "none") == 0) + if (strcmp(CMD_ARGV[0], "none") == 0) tracemode = ETMV1_TRACE_NONE; - else if (strcmp(args[0], "data") == 0) + else if (strcmp(CMD_ARGV[0], "data") == 0) tracemode = ETMV1_TRACE_DATA; - else if (strcmp(args[0], "address") == 0) + else if (strcmp(CMD_ARGV[0], "address") == 0) tracemode = ETMV1_TRACE_ADDR; - else if (strcmp(args[0], "all") == 0) + else if (strcmp(CMD_ARGV[0], "all") == 0) tracemode = ETMV1_TRACE_DATA | ETMV1_TRACE_ADDR; else { - command_print(cmd_ctx, "invalid option '%s'", args[0]); + command_print(cmd_ctx, "invalid option '%s'", CMD_ARGV[0]); return ERROR_INVALID_ARGUMENTS; } uint8_t context_id; - COMMAND_PARSE_NUMBER(u8, args[1], context_id); + COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], context_id); switch (context_id) { case 0: @@ -1213,27 +1210,27 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update, tracemode |= ETMV1_CONTEXTID_32; break; default: - command_print(cmd_ctx, "invalid option '%s'", args[1]); + command_print(cmd_ctx, "invalid option '%s'", CMD_ARGV[1]); return ERROR_INVALID_ARGUMENTS; } - if (strcmp(args[2], "enable") == 0) + if (strcmp(CMD_ARGV[2], "enable") == 0) tracemode |= ETMV1_CYCLE_ACCURATE; - else if (strcmp(args[2], "disable") == 0) + else if (strcmp(CMD_ARGV[2], "disable") == 0) tracemode |= 0; else { - command_print(cmd_ctx, "invalid option '%s'", args[2]); + command_print(cmd_ctx, "invalid option '%s'", CMD_ARGV[2]); return ERROR_INVALID_ARGUMENTS; } - if (strcmp(args[3], "enable") == 0) + if (strcmp(CMD_ARGV[3], "enable") == 0) tracemode |= ETMV1_BRANCH_OUTPUT; - else if (strcmp(args[3], "disable") == 0) + else if (strcmp(CMD_ARGV[3], "disable") == 0) tracemode |= 0; else { - command_print(cmd_ctx, "invalid option '%s'", args[3]); + command_print(cmd_ctx, "invalid option '%s'", CMD_ARGV[3]); return ERROR_INVALID_ARGUMENTS; } @@ -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,19 +1368,19 @@ 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]); + target = get_target(CMD_ARGV[0]); if (!target) { - LOG_ERROR("target '%s' not defined", args[0]); + LOG_ERROR("target '%s' not defined", CMD_ARGV[0]); return ERROR_FAIL; } @@ -1407,7 +1404,7 @@ COMMAND_HANDLER(handle_etm_config_command) * "normal full" ... */ uint8_t port_width; - COMMAND_PARSE_NUMBER(u8, args[1], port_width); + COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], port_width); switch (port_width) { /* before ETMv3.0 */ @@ -1441,43 +1438,43 @@ COMMAND_HANDLER(handle_etm_config_command) break; default: command_print(cmd_ctx, - "unsupported ETM port width '%s'", args[1]); + "unsupported ETM port width '%s'", CMD_ARGV[1]); return ERROR_FAIL; } - if (strcmp("normal", args[2]) == 0) + if (strcmp("normal", CMD_ARGV[2]) == 0) { portmode |= ETM_PORT_NORMAL; } - else if (strcmp("multiplexed", args[2]) == 0) + else if (strcmp("multiplexed", CMD_ARGV[2]) == 0) { portmode |= ETM_PORT_MUXED; } - else if (strcmp("demultiplexed", args[2]) == 0) + else if (strcmp("demultiplexed", CMD_ARGV[2]) == 0) { portmode |= ETM_PORT_DEMUXED; } else { - command_print(cmd_ctx, "unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'", args[2]); + command_print(cmd_ctx, "unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'", CMD_ARGV[2]); return ERROR_FAIL; } - if (strcmp("half", args[3]) == 0) + if (strcmp("half", CMD_ARGV[3]) == 0) { portmode |= ETM_PORT_HALF_CLOCK; } - else if (strcmp("full", args[3]) == 0) + else if (strcmp("full", CMD_ARGV[3]) == 0) { portmode |= ETM_PORT_FULL_CLOCK; } else { - command_print(cmd_ctx, "unsupported ETM port clocking '%s', must be 'full' or 'half'", args[3]); + command_print(cmd_ctx, "unsupported ETM port clocking '%s', must be 'full' or 'half'", CMD_ARGV[3]); 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; @@ -1485,7 +1482,7 @@ COMMAND_HANDLER(handle_etm_config_command) for (i = 0; etm_capture_drivers[i]; i++) { - if (strcmp(args[4], etm_capture_drivers[i]->name) == 0) + if (strcmp(CMD_ARGV[4], etm_capture_drivers[i]->name) == 0) { int retval; if ((retval = etm_capture_drivers[i]->register_commands(cmd_ctx)) != ERROR_OK) @@ -1504,7 +1501,7 @@ COMMAND_HANDLER(handle_etm_config_command) { /* no supported capture driver found, don't register an ETM */ free(etm_ctx); - LOG_ERROR("trace capture driver '%s' not found", args[4]); + LOG_ERROR("trace capture driver '%s' not found", CMD_ARGV[4]); 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,22 +1758,22 @@ 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); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], etm_ctx->image->base_address); } else { 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, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK) { free(etm_ctx->image); etm_ctx->image = NULL; @@ -1788,13 +1785,13 @@ COMMAND_HANDLER(handle_etm_image_command) COMMAND_HANDLER(handle_etm_dump_command) { - fileio_t file; - target_t *target; + struct fileio file; + 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; @@ -1832,7 +1829,7 @@ COMMAND_HANDLER(handle_etm_dump_command) if (etm_ctx->trace_depth == 0) etm_ctx->capture_driver->read_trace(etm_ctx); - if (fileio_open(&file, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) + if (fileio_open(&file, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { return ERROR_FAIL; } @@ -1856,13 +1853,13 @@ COMMAND_HANDLER(handle_etm_dump_command) COMMAND_HANDLER(handle_etm_load_command) { - fileio_t file; - target_t *target; + struct fileio file; + 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; @@ -1889,7 +1886,7 @@ COMMAND_HANDLER(handle_etm_load_command) return ERROR_FAIL; } - if (fileio_open(&file, args[0], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) + if (fileio_open(&file, CMD_ARGV[0], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) { 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,10 +1956,10 @@ 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); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value); if ((new_value < 2) || (new_value > 100)) { @@ -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: "