X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=f7e2ad64881e49e731ad968737b65ef3a2882ee7;hp=5cdfa5dc0095193042b6d1bdc583752d2893f8c7;hb=9ac7cdec82c19481b79f2effcefb7106dd7ade41;hpb=2a4d3c03cd9f6ec1d761a6fb8795d6aac95e9fe3;ds=sidebyside diff --git a/src/target/target.c b/src/target/target.c index 5cdfa5dc00..f7e2ad6488 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -45,27 +45,27 @@ static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv); -static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv); -static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv); +static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv); +static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv); /* targets */ -extern target_type_t arm7tdmi_target; -extern target_type_t arm720t_target; -extern target_type_t arm9tdmi_target; -extern target_type_t arm920t_target; -extern target_type_t arm966e_target; -extern target_type_t arm926ejs_target; -extern target_type_t fa526_target; -extern target_type_t feroceon_target; -extern target_type_t dragonite_target; -extern target_type_t xscale_target; -extern target_type_t cortexm3_target; -extern target_type_t cortexa8_target; -extern target_type_t arm11_target; -extern target_type_t mips_m4k_target; -extern target_type_t avr_target; - -target_type_t *target_types[] = +extern struct target_type arm7tdmi_target; +extern struct target_type arm720t_target; +extern struct target_type arm9tdmi_target; +extern struct target_type arm920t_target; +extern struct target_type arm966e_target; +extern struct target_type arm926ejs_target; +extern struct target_type fa526_target; +extern struct target_type feroceon_target; +extern struct target_type dragonite_target; +extern struct target_type xscale_target; +extern struct target_type cortexm3_target; +extern struct target_type cortexa8_target; +extern struct target_type arm11_target; +extern struct target_type mips_m4k_target; +extern struct target_type avr_target; + +struct target_type *target_types[] = { &arm7tdmi_target, &arm9tdmi_target, @@ -85,9 +85,9 @@ target_type_t *target_types[] = NULL, }; -target_t *all_targets = NULL; -target_event_callback_t *target_event_callbacks = NULL; -target_timer_callback_t *target_timer_callbacks = NULL; +struct target *all_targets = NULL; +struct target_event_callback *target_event_callbacks = NULL; +struct target_timer_callback *target_timer_callbacks = NULL; const Jim_Nvp nvp_assert[] = { { .name = "assert", NVP_ASSERT }, @@ -213,7 +213,7 @@ const Jim_Nvp nvp_reset_modes[] = { }; const char * -target_state_name( target_t *t ) +target_state_name( struct target *t ) { const char *cp; cp = Jim_Nvp_value2name_simple(nvp_target_state, t->state)->name; @@ -227,7 +227,7 @@ target_state_name( target_t *t ) /* determine the number of the new target */ static int new_target_number(void) { - target_t *t; + struct target *t; int x; /* number is 0 based */ @@ -243,7 +243,7 @@ static int new_target_number(void) } /* read a uint32_t from a buffer in target memory endianness */ -uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer) +uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer) { if (target->endianness == TARGET_LITTLE_ENDIAN) return le_to_h_u32(buffer); @@ -252,7 +252,7 @@ uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer) } /* read a uint16_t from a buffer in target memory endianness */ -uint16_t target_buffer_get_u16(target_t *target, const uint8_t *buffer) +uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer) { if (target->endianness == TARGET_LITTLE_ENDIAN) return le_to_h_u16(buffer); @@ -261,13 +261,13 @@ uint16_t target_buffer_get_u16(target_t *target, const uint8_t *buffer) } /* read a uint8_t from a buffer in target memory endianness */ -uint8_t target_buffer_get_u8(target_t *target, const uint8_t *buffer) +uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer) { return *buffer & 0x0ff; } /* write a uint32_t to a buffer in target memory endianness */ -void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value) +void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value) { if (target->endianness == TARGET_LITTLE_ENDIAN) h_u32_to_le(buffer, value); @@ -276,7 +276,7 @@ void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value) } /* write a uint16_t to a buffer in target memory endianness */ -void target_buffer_set_u16(target_t *target, uint8_t *buffer, uint16_t value) +void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value) { if (target->endianness == TARGET_LITTLE_ENDIAN) h_u16_to_le(buffer, value); @@ -285,15 +285,15 @@ void target_buffer_set_u16(target_t *target, uint8_t *buffer, uint16_t value) } /* write a uint8_t to a buffer in target memory endianness */ -void target_buffer_set_u8(target_t *target, uint8_t *buffer, uint8_t value) +void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t value) { *buffer = value; } /* return a pointer to a configured target; id is name or number */ -target_t *get_target(const char *id) +struct target *get_target(const char *id) { - target_t *target; + struct target *target; /* try as tcltarget name */ for (target = all_targets; target; target = target->next) { @@ -322,9 +322,9 @@ target_t *get_target(const char *id) } /* returns a pointer to the n-th configured target */ -static target_t *get_target_by_num(int num) +static struct target *get_target_by_num(int num) { - target_t *target = all_targets; + struct target *target = all_targets; while (target) { if (target->target_number == num) { @@ -336,9 +336,9 @@ static target_t *get_target_by_num(int num) return NULL; } -target_t* get_current_target(command_context_t *cmd_ctx) +struct target* get_current_target(struct command_context *cmd_ctx) { - target_t *target = get_target_by_num(cmd_ctx->current_target); + struct target *target = get_target_by_num(cmd_ctx->current_target); if (target == NULL) { @@ -349,7 +349,7 @@ target_t* get_current_target(command_context_t *cmd_ctx) return target; } -int target_poll(struct target_s *target) +int target_poll(struct target *target) { int retval; @@ -384,7 +384,7 @@ int target_poll(struct target_s *target) return ERROR_OK; } -int target_halt(struct target_s *target) +int target_halt(struct target *target) { int retval; /* We can't poll until after examine */ @@ -404,7 +404,7 @@ int target_halt(struct target_s *target) return ERROR_OK; } -int target_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution) +int target_resume(struct target *target, int current, uint32_t address, int handle_breakpoints, int debug_execution) { int retval; @@ -425,7 +425,7 @@ int target_resume(struct target_s *target, int current, uint32_t address, int ha return retval; } -int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode) +int target_process_reset(struct command_context *cmd_ctx, enum target_reset_mode reset_mode) { char buf[100]; int retval; @@ -460,33 +460,33 @@ int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mo return retval; } -static int identity_virt2phys(struct target_s *target, +static int identity_virt2phys(struct target *target, uint32_t virtual, uint32_t *physical) { *physical = virtual; return ERROR_OK; } -static int no_mmu(struct target_s *target, int *enabled) +static int no_mmu(struct target *target, int *enabled) { *enabled = 0; return ERROR_OK; } -static int default_examine(struct target_s *target) +static int default_examine(struct target *target) { target_set_examined(target); return ERROR_OK; } -int target_examine_one(struct target_s *target) +int target_examine_one(struct target *target) { return target->type->examine(target); } static int jtag_enable_callback(enum jtag_event event, void *priv) { - target_t *target = priv; + struct target *target = priv; if (event != JTAG_TAP_EVENT_ENABLE || !target->tap->enabled) return ERROR_OK; @@ -504,7 +504,7 @@ static int jtag_enable_callback(enum jtag_event event, void *priv) int target_examine(void) { int retval = ERROR_OK; - target_t *target; + struct target *target; for (target = all_targets; target; target = target->next) { @@ -519,12 +519,12 @@ int target_examine(void) } return retval; } -const char *target_get_name(struct target_s *target) +const char *target_get_name(struct target *target) { return target->type->name; } -static int target_write_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) +static int target_write_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { if (!target_was_examined(target)) { @@ -534,7 +534,7 @@ static int target_write_memory_imp(struct target_s *target, uint32_t address, ui return target->type->write_memory_imp(target, address, size, count, buffer); } -static int target_read_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) +static int target_read_memory_imp(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { if (!target_was_examined(target)) { @@ -544,7 +544,7 @@ static int target_read_memory_imp(struct target_s *target, uint32_t address, uin return target->type->read_memory_imp(target, address, size, count, buffer); } -static int target_soft_reset_halt_imp(struct target_s *target) +static int target_soft_reset_halt_imp(struct target *target) { if (!target_was_examined(target)) { @@ -559,7 +559,7 @@ static int target_soft_reset_halt_imp(struct target_s *target) return target->type->soft_reset_halt_imp(target); } -static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info) +static int target_run_algorithm_imp(struct target *target, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info) { if (!target_was_examined(target)) { @@ -569,73 +569,73 @@ static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, return target->type->run_algorithm_imp(target, num_mem_params, mem_params, num_reg_params, reg_param, entry_point, exit_point, timeout_ms, arch_info); } -int target_read_memory(struct target_s *target, +int target_read_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { return target->type->read_memory(target, address, size, count, buffer); } -int target_read_phys_memory(struct target_s *target, +int target_read_phys_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { return target->type->read_phys_memory(target, address, size, count, buffer); } -int target_write_memory(struct target_s *target, +int target_write_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { return target->type->write_memory(target, address, size, count, buffer); } -int target_write_phys_memory(struct target_s *target, +int target_write_phys_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { return target->type->write_phys_memory(target, address, size, count, buffer); } -int target_bulk_write_memory(struct target_s *target, +int target_bulk_write_memory(struct target *target, uint32_t address, uint32_t count, uint8_t *buffer) { return target->type->bulk_write_memory(target, address, count, buffer); } -int target_add_breakpoint(struct target_s *target, - struct breakpoint_s *breakpoint) +int target_add_breakpoint(struct target *target, + struct breakpoint *breakpoint) { return target->type->add_breakpoint(target, breakpoint); } -int target_remove_breakpoint(struct target_s *target, - struct breakpoint_s *breakpoint) +int target_remove_breakpoint(struct target *target, + struct breakpoint *breakpoint) { return target->type->remove_breakpoint(target, breakpoint); } -int target_add_watchpoint(struct target_s *target, - struct watchpoint_s *watchpoint) +int target_add_watchpoint(struct target *target, + struct watchpoint *watchpoint) { return target->type->add_watchpoint(target, watchpoint); } -int target_remove_watchpoint(struct target_s *target, - struct watchpoint_s *watchpoint) +int target_remove_watchpoint(struct target *target, + struct watchpoint *watchpoint) { return target->type->remove_watchpoint(target, watchpoint); } -int target_get_gdb_reg_list(struct target_s *target, - struct reg_s **reg_list[], int *reg_list_size) +int target_get_gdb_reg_list(struct target *target, + struct reg **reg_list[], int *reg_list_size) { return target->type->get_gdb_reg_list(target, reg_list, reg_list_size); } -int target_step(struct target_s *target, +int target_step(struct target *target, int current, uint32_t address, int handle_breakpoints) { return target->type->step(target, current, address, handle_breakpoints); } -int target_run_algorithm(struct target_s *target, - int num_mem_params, mem_param_t *mem_params, - int num_reg_params, reg_param_t *reg_param, +int target_run_algorithm(struct target *target, + int num_mem_params, struct mem_param *mem_params, + int num_reg_params, struct reg_param *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info) { @@ -644,37 +644,30 @@ int target_run_algorithm(struct target_s *target, entry_point, exit_point, timeout_ms, arch_info); } -/// @returns @c true if the target has been examined. -bool target_was_examined(struct target_s *target) -{ - return target->type->examined; -} -/// Sets the @c examined flag for the given target. -void target_set_examined(struct target_s *target) -{ - target->type->examined = true; -} -// Reset the @c examined flag for the given target. -void target_reset_examined(struct target_s *target) +/** + * Reset the @c examined flag for the given target. + * Pure paranoia -- targets are zeroed on allocation. + */ +static void target_reset_examined(struct target *target) { - target->type->examined = false; + target->examined = false; } -static int default_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value) +static int default_mrc(struct target *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value) { LOG_ERROR("Not implemented: %s", __func__); return ERROR_FAIL; } -static int default_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value) +static int default_mcr(struct target *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value) { LOG_ERROR("Not implemented: %s", __func__); return ERROR_FAIL; } -static int arm_cp_check(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm) +static int arm_cp_check(struct target *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm) { /* basic check */ if (!target_was_examined(target)) @@ -716,7 +709,7 @@ static int arm_cp_check(struct target_s *target, int cpnum, uint32_t op1, uint32 return ERROR_OK; } -int target_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value) +int target_mrc(struct target *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value) { int retval; @@ -727,7 +720,7 @@ int target_mrc(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, u return target->type->mrc(target, cpnum, op1, op2, CRn, CRm, value); } -int target_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value) +int target_mcr(struct target *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value) { int retval; @@ -739,7 +732,7 @@ int target_mcr(struct target_s *target, int cpnum, uint32_t op1, uint32_t op2, u } static int -err_read_phys_memory(struct target_s *target, uint32_t address, +err_read_phys_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { LOG_ERROR("Not implemented: %s", __func__); @@ -747,20 +740,21 @@ err_read_phys_memory(struct target_s *target, uint32_t address, } static int -err_write_phys_memory(struct target_s *target, uint32_t address, +err_write_phys_memory(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer) { LOG_ERROR("Not implemented: %s", __func__); return ERROR_FAIL; } -int target_init(struct command_context_s *cmd_ctx) +int target_init(struct command_context *cmd_ctx) { - target_t *target = all_targets; + struct target *target; int retval; - while (target) - { + for (target = all_targets; target; target = target->next) { + struct target_type *type = target->type; + target_reset_examined(target); if (target->type->examine == NULL) { @@ -773,22 +767,6 @@ int target_init(struct command_context_s *cmd_ctx) return retval; } - /* Set up default functions if none are provided by target */ - if (target->type->virt2phys == NULL) - { - target->type->virt2phys = identity_virt2phys; - } - - if (target->type->read_phys_memory == NULL) - { - target->type->read_phys_memory = err_read_phys_memory; - } - - if (target->type->write_phys_memory == NULL) - { - target->type->write_phys_memory = err_write_phys_memory; - } - /** * @todo MCR/MRC are ARM-specific; don't require them in * all targets, or for ARMs without coprocessors. @@ -833,11 +811,45 @@ int target_init(struct command_context_s *cmd_ctx) target->type->run_algorithm_imp = target->type->run_algorithm; target->type->run_algorithm = target_run_algorithm_imp; - if (target->type->mmu == NULL) - { - target->type->mmu = no_mmu; + /* Sanity-check MMU support ... stub in what we must, to help + * implement it in stages, but warn if we need to do so. + */ + if (type->mmu) { + if (type->write_phys_memory == NULL) { + LOG_ERROR("type '%s' is missing %s", + type->name, + "write_phys_memory"); + type->write_phys_memory = err_write_phys_memory; + } + if (type->read_phys_memory == NULL) { + LOG_ERROR("type '%s' is missing %s", + type->name, + "read_phys_memory"); + type->read_phys_memory = err_read_phys_memory; + } + if (type->virt2phys == NULL) { + LOG_ERROR("type '%s' is missing %s", + type->name, + "virt2phys"); + type->virt2phys = identity_virt2phys; + } + + /* Make sure no-MMU targets all behave the same: make no + * distinction between physical and virtual addresses, and + * ensure that virt2phys() is always an identity mapping. + */ + } else { + if (type->write_phys_memory + || type->read_phys_memory + || type->virt2phys) + LOG_WARNING("type '%s' has broken MMU hooks", + type->name); + + type->mmu = no_mmu; + type->write_phys_memory = type->write_memory; + type->read_phys_memory = type->read_memory; + type->virt2phys = identity_virt2phys; } - target = target->next; } if (all_targets) @@ -851,9 +863,9 @@ int target_init(struct command_context_s *cmd_ctx) return ERROR_OK; } -int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv) +int target_register_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv) { - target_event_callback_t **callbacks_p = &target_event_callbacks; + struct target_event_callback **callbacks_p = &target_event_callbacks; if (callback == NULL) { @@ -867,7 +879,7 @@ int target_register_event_callback(int (*callback)(struct target_s *target, enum callbacks_p = &((*callbacks_p)->next); } - (*callbacks_p) = malloc(sizeof(target_event_callback_t)); + (*callbacks_p) = malloc(sizeof(struct target_event_callback)); (*callbacks_p)->callback = callback; (*callbacks_p)->priv = priv; (*callbacks_p)->next = NULL; @@ -877,7 +889,7 @@ int target_register_event_callback(int (*callback)(struct target_s *target, enum int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv) { - target_timer_callback_t **callbacks_p = &target_timer_callbacks; + struct target_timer_callback **callbacks_p = &target_timer_callbacks; struct timeval now; if (callback == NULL) @@ -892,7 +904,7 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int callbacks_p = &((*callbacks_p)->next); } - (*callbacks_p) = malloc(sizeof(target_timer_callback_t)); + (*callbacks_p) = malloc(sizeof(struct target_timer_callback)); (*callbacks_p)->callback = callback; (*callbacks_p)->periodic = periodic; (*callbacks_p)->time_ms = time_ms; @@ -913,10 +925,10 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int return ERROR_OK; } -int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv) +int target_unregister_event_callback(int (*callback)(struct target *target, enum target_event event, void *priv), void *priv) { - target_event_callback_t **p = &target_event_callbacks; - target_event_callback_t *c = target_event_callbacks; + struct target_event_callback **p = &target_event_callbacks; + struct target_event_callback *c = target_event_callbacks; if (callback == NULL) { @@ -925,7 +937,7 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en while (c) { - target_event_callback_t *next = c->next; + struct target_event_callback *next = c->next; if ((c->callback == callback) && (c->priv == priv)) { *p = next; @@ -942,8 +954,8 @@ int target_unregister_event_callback(int (*callback)(struct target_s *target, en int target_unregister_timer_callback(int (*callback)(void *priv), void *priv) { - target_timer_callback_t **p = &target_timer_callbacks; - target_timer_callback_t *c = target_timer_callbacks; + struct target_timer_callback **p = &target_timer_callbacks; + struct target_timer_callback *c = target_timer_callbacks; if (callback == NULL) { @@ -952,7 +964,7 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv) while (c) { - target_timer_callback_t *next = c->next; + struct target_timer_callback *next = c->next; if ((c->callback == callback) && (c->priv == priv)) { *p = next; @@ -967,10 +979,10 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv) return ERROR_OK; } -int target_call_event_callbacks(target_t *target, enum target_event event) +int target_call_event_callbacks(struct target *target, enum target_event event) { - target_event_callback_t *callback = target_event_callbacks; - target_event_callback_t *next_callback; + struct target_event_callback *callback = target_event_callbacks; + struct target_event_callback *next_callback; if (event == TARGET_EVENT_HALTED) { @@ -995,7 +1007,7 @@ int target_call_event_callbacks(target_t *target, enum target_event event) } static int target_timer_callback_periodic_restart( - target_timer_callback_t *cb, struct timeval *now) + struct target_timer_callback *cb, struct timeval *now) { int time_ms = cb->time_ms; cb->when.tv_usec = now->tv_usec + (time_ms % 1000) * 1000; @@ -1009,7 +1021,7 @@ static int target_timer_callback_periodic_restart( return ERROR_OK; } -static int target_call_timer_callback(target_timer_callback_t *cb, +static int target_call_timer_callback(struct target_timer_callback *cb, struct timeval *now) { cb->callback(cb->priv); @@ -1027,11 +1039,11 @@ static int target_call_timer_callbacks_check_time(int checktime) struct timeval now; gettimeofday(&now, NULL); - target_timer_callback_t *callback = target_timer_callbacks; + struct target_timer_callback *callback = target_timer_callbacks; while (callback) { // cleaning up may unregister and free this callback - target_timer_callback_t *next_callback = callback->next; + struct target_timer_callback *next_callback = callback->next; bool call_it = callback->callback && ((!checktime && callback->periodic) || @@ -1063,10 +1075,10 @@ int target_call_timer_callbacks_now(void) return target_call_timer_callbacks_check_time(0); } -int target_alloc_working_area(struct target_s *target, uint32_t size, working_area_t **area) +int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area) { - working_area_t *c = target->working_areas; - working_area_t *new_wa = NULL; + struct working_area *c = target->working_areas; + struct working_area *new_wa = NULL; /* Reevaluate working area address based on MMU state*/ if (target->working_areas == NULL) @@ -1126,7 +1138,7 @@ int target_alloc_working_area(struct target_s *target, uint32_t size, working_ar /* if not, allocate a new one */ if (!new_wa) { - working_area_t **p = &target->working_areas; + struct working_area **p = &target->working_areas; uint32_t first_free = target->working_area; uint32_t free_size = target->working_area_size; @@ -1148,7 +1160,7 @@ int target_alloc_working_area(struct target_s *target, uint32_t size, working_ar LOG_DEBUG("allocated new working area at address 0x%08x", (unsigned)first_free); - new_wa = malloc(sizeof(working_area_t)); + new_wa = malloc(sizeof(struct working_area)); new_wa->next = NULL; new_wa->size = size; new_wa->address = first_free; @@ -1183,7 +1195,7 @@ int target_alloc_working_area(struct target_s *target, uint32_t size, working_ar return ERROR_OK; } -int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore) +int target_free_working_area_restore(struct target *target, struct working_area *area, int restore) { if (area->free) return ERROR_OK; @@ -1204,7 +1216,7 @@ int target_free_working_area_restore(struct target_s *target, working_area_t *ar return ERROR_OK; } -int target_free_working_area(struct target_s *target, working_area_t *area) +int target_free_working_area(struct target *target, struct working_area *area) { return target_free_working_area_restore(target, area, 1); } @@ -1212,13 +1224,13 @@ int target_free_working_area(struct target_s *target, working_area_t *area) /* free resources and restore memory, if restoring memory fails, * free up resources anyway */ -void target_free_all_working_areas_restore(struct target_s *target, int restore) +void target_free_all_working_areas_restore(struct target *target, int restore) { - working_area_t *c = target->working_areas; + struct working_area *c = target->working_areas; while (c) { - working_area_t *next = c->next; + struct working_area *next = c->next; target_free_working_area_restore(target, c, restore); if (c->backup) @@ -1232,12 +1244,12 @@ void target_free_all_working_areas_restore(struct target_s *target, int restore) target->working_areas = NULL; } -void target_free_all_working_areas(struct target_s *target) +void target_free_all_working_areas(struct target *target) { target_free_all_working_areas_restore(target, 1); } -int target_arch_state(struct target_s *target) +int target_arch_state(struct target *target) { int retval; if (target == NULL) @@ -1259,7 +1271,7 @@ int target_arch_state(struct target_s *target) * mode respectively, otherwise data is handled as quickly as * possible */ -int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer) +int target_write_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer) { int retval; LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", @@ -1341,7 +1353,7 @@ int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size * mode respectively, otherwise data is handled as quickly as * possible */ -int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer) +int target_read_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer) { int retval; LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", @@ -1422,7 +1434,7 @@ int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, return ERROR_OK; } -int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc) +int target_checksum_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* crc) { uint8_t *buffer; int retval; @@ -1467,7 +1479,7 @@ int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t s return retval; } -int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank) +int target_blank_check_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* blank) { int retval; if (!target_was_examined(target)) @@ -1484,7 +1496,7 @@ int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_ return retval; } -int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value) +int target_read_u32(struct target *target, uint32_t address, uint32_t *value) { uint8_t value_buf[4]; if (!target_was_examined(target)) @@ -1512,7 +1524,7 @@ int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value) return retval; } -int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value) +int target_read_u16(struct target *target, uint32_t address, uint16_t *value) { uint8_t value_buf[2]; if (!target_was_examined(target)) @@ -1540,7 +1552,7 @@ int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value) return retval; } -int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value) +int target_read_u8(struct target *target, uint32_t address, uint8_t *value) { int retval = target_read_memory(target, address, 1, 1, value); if (!target_was_examined(target)) @@ -1565,7 +1577,7 @@ int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value) return retval; } -int target_write_u32(struct target_s *target, uint32_t address, uint32_t value) +int target_write_u32(struct target *target, uint32_t address, uint32_t value) { int retval; uint8_t value_buf[4]; @@ -1588,7 +1600,7 @@ int target_write_u32(struct target_s *target, uint32_t address, uint32_t value) return retval; } -int target_write_u16(struct target_s *target, uint32_t address, uint16_t value) +int target_write_u16(struct target *target, uint32_t address, uint16_t value) { int retval; uint8_t value_buf[2]; @@ -1611,7 +1623,7 @@ int target_write_u16(struct target_s *target, uint32_t address, uint16_t value) return retval; } -int target_write_u8(struct target_s *target, uint32_t address, uint8_t value) +int target_write_u8(struct target *target, uint32_t address, uint8_t value) { int retval; if (!target_was_examined(target)) @@ -1631,9 +1643,9 @@ int target_write_u8(struct target_s *target, uint32_t address, uint8_t value) return retval; } -static int handle_targets_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_targets_command) { - target_t *target = all_targets; + struct target *target = all_targets; if (argc == 1) { @@ -1755,7 +1767,7 @@ static int sense_handler(void) } static void target_call_event_callbacks_all(enum target_event e) { - target_t *target; + struct target *target; target = all_targets; while (target) { target_call_event_callbacks(target, e); @@ -1821,7 +1833,7 @@ int handle_target(void *priv) /* Poll targets for state changes unless that's globally disabled. * Skip targets that are currently disabled. */ - for (target_t *target = all_targets; + for (struct target *target = all_targets; is_jtag_poll_safe() && target; target = target->next) { @@ -1843,10 +1855,10 @@ int handle_target(void *priv) return retval; } -static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_reg_command) { - target_t *target; - reg_t *reg = NULL; + struct target *target; + struct reg *reg = NULL; int count = 0; char *value; @@ -1857,7 +1869,7 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char /* list all available registers for the current target */ if (argc == 0) { - reg_cache_t *cache = target->reg_cache; + struct reg_cache *cache = target->reg_cache; count = 0; while (cache) @@ -1900,7 +1912,7 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char unsigned num; COMMAND_PARSE_NUMBER(uint, args[0], num); - reg_cache_t *cache = target->reg_cache; + struct reg_cache *cache = target->reg_cache; count = 0; while (cache) { @@ -1942,7 +1954,7 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char if (reg->valid == 0) { - reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); + struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type); arch_type->get(reg); } value = buf_to_str(reg->value, reg->size, 16); @@ -1957,7 +1969,7 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char uint8_t *buf = malloc(CEIL(reg->size, 8)); str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0); - reg_arch_type_t *arch_type = register_get_arch_type(reg->arch_type); + struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type); arch_type->set(reg, buf); value = buf_to_str(reg->value, reg->size, 16); @@ -1974,10 +1986,10 @@ static int handle_reg_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_poll_command) { int retval = ERROR_OK; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); if (argc == 0) { @@ -2016,7 +2028,7 @@ static int handle_poll_command(struct command_context_s *cmd_ctx, char *cmd, cha return retval; } -static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_wait_halt_command) { if (argc > 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2027,14 +2039,14 @@ static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd int retval = parse_uint(args[0], &ms); if (ERROR_OK != retval) { - command_print(cmd_ctx, "usage: %s [seconds]", cmd); + command_print(cmd_ctx, "usage: %s [seconds]", CMD_NAME); return ERROR_COMMAND_SYNTAX_ERROR; } // convert seconds (given) to milliseconds (needed) ms *= 1000; } - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); return target_wait_state(target, TARGET_HALTED, ms); } @@ -2044,7 +2056,7 @@ static int handle_wait_halt_command(struct command_context_s *cmd_ctx, char *cmd * * After 500ms, keep_alive() is invoked */ -int target_wait_state(target_t *target, enum target_state state, int ms) +int target_wait_state(struct target *target, enum target_state state, int ms) { int retval; long long then = 0, cur; @@ -2083,11 +2095,11 @@ int target_wait_state(target_t *target, enum target_state state, int ms) return ERROR_OK; } -static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_halt_command) { LOG_DEBUG("-"); - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); int retval = target_halt(target); if (ERROR_OK != retval) return retval; @@ -2102,12 +2114,12 @@ static int handle_halt_command(struct command_context_s *cmd_ctx, char *cmd, cha return ERROR_OK; } - return handle_wait_halt_command(cmd_ctx, cmd, args, argc); + return CALL_COMMAND_HANDLER(handle_wait_halt_command); } -static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_soft_reset_halt_command) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); LOG_USER("requesting target halt and executing a soft reset"); @@ -2116,7 +2128,7 @@ static int handle_soft_reset_halt_command(struct command_context_s *cmd_ctx, cha return ERROR_OK; } -static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_reset_command) { if (argc > 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2137,13 +2149,13 @@ static int handle_reset_command(struct command_context_s *cmd_ctx, char *cmd, ch } -static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_resume_command) { int current = 1; if (argc > 1) return ERROR_COMMAND_SYNTAX_ERROR; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); target_handle_event(target, TARGET_EVENT_OLD_pre_resume); /* with no args, resume from current pc, addr = 0, @@ -2159,7 +2171,7 @@ static int handle_resume_command(struct command_context_s *cmd_ctx, char *cmd, c return target_resume(target, current, addr, 1, 0); } -static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_step_command) { if (argc > 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2177,13 +2189,13 @@ static int handle_step_command(struct command_context_s *cmd_ctx, char *cmd, cha current_pc = 0; } - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); return target->type->step(target, current_pc, addr, 1); } -static void handle_md_output(struct command_context_s *cmd_ctx, - struct target_s *target, uint32_t address, unsigned size, +static void handle_md_output(struct command_context *cmd_ctx, + struct target *target, uint32_t address, unsigned size, unsigned count, const uint8_t *buffer) { const unsigned line_bytecnt = 32; @@ -2231,13 +2243,14 @@ static void handle_md_output(struct command_context_s *cmd_ctx, } } -static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_md_command) { if (argc < 1) return ERROR_COMMAND_SYNTAX_ERROR; unsigned size = 0; - switch (cmd[2]) { + const char *cmd_name = CMD_NAME; + switch (cmd_name[6]) { case 'w': size = 4; break; case 'h': size = 2; break; case 'b': size = 1; break; @@ -2245,7 +2258,7 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char } bool physical=strcmp(args[0], "phys")==0; - int (*fn)(struct target_s *target, + int (*fn)(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer); if (physical) { @@ -2270,7 +2283,7 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char uint8_t *buffer = calloc(count, size); - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); int retval = fn(target, address, size, count, buffer); if (ERROR_OK == retval) handle_md_output(cmd_ctx, target, address, size, count, buffer); @@ -2280,15 +2293,16 @@ static int handle_md_command(struct command_context_s *cmd_ctx, char *cmd, char return retval; } -static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_mw_command) { if (argc < 2) { return ERROR_COMMAND_SYNTAX_ERROR; } bool physical=strcmp(args[0], "phys")==0; - int (*fn)(struct target_s *target, + int (*fn)(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer); + const char *cmd_name = CMD_NAME; if (physical) { argc--; @@ -2311,10 +2325,10 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char if (argc == 3) COMMAND_PARSE_NUMBER(uint, args[2], count); - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); unsigned wordsize; uint8_t value_buf[4]; - switch (cmd[2]) + switch (cmd_name[6]) { case 'w': wordsize = 4; @@ -2344,8 +2358,7 @@ static int handle_mw_command(struct command_context_s *cmd_ctx, char *cmd, char } -static int parse_load_image_command_args(struct command_context_s *cmd_ctx, - char **args, int argc, image_t *image, +static COMMAND_HELPER(parse_load_image_command_args, struct image *image, uint32_t *min_address, uint32_t *max_address) { if (argc < 1 || argc > 5) @@ -2382,7 +2395,7 @@ static int parse_load_image_command_args(struct command_context_s *cmd_ctx, return ERROR_OK; } -static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_load_image_command) { uint8_t *buffer; uint32_t buf_cnt; @@ -2390,14 +2403,14 @@ static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cm uint32_t min_address = 0; uint32_t max_address = 0xffffffff; int i; - image_t image; + struct image image; - int retval = parse_load_image_command_args(cmd_ctx, args, argc, + int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args, &image, &min_address, &max_address); if (ERROR_OK != retval) return retval; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); struct duration bench; duration_start(&bench); @@ -2473,15 +2486,15 @@ static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cm } -static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_dump_image_command) { - fileio_t fileio; + struct fileio fileio; uint8_t buffer[560]; int retvaltemp; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); if (argc != 3) { @@ -2536,7 +2549,7 @@ static int handle_dump_image_command(struct command_context_s *cmd_ctx, char *cm return retval; } -static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify) +static COMMAND_HELPER(handle_verify_image_command_internal, int verify) { uint8_t *buffer; uint32_t buf_cnt; @@ -2546,9 +2559,9 @@ static int handle_verify_image_command_internal(struct command_context_s *cmd_ct uint32_t checksum = 0; uint32_t mem_checksum = 0; - image_t image; + struct image image; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); if (argc < 1) { @@ -2681,20 +2694,20 @@ done: return retval; } -static int handle_verify_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_verify_image_command) { - return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 1); + return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 1); } -static int handle_test_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_test_image_command) { - return handle_verify_image_command_internal(cmd_ctx, cmd, args, argc, 0); + return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, 0); } -static int handle_bp_command_list(struct command_context_s *cmd_ctx) +static int handle_bp_command_list(struct command_context *cmd_ctx) { - target_t *target = get_current_target(cmd_ctx); - breakpoint_t *breakpoint = target->breakpoints; + struct target *target = get_current_target(cmd_ctx); + struct breakpoint *breakpoint = target->breakpoints; while (breakpoint) { if (breakpoint->type == BKPT_SOFT) @@ -2719,10 +2732,10 @@ static int handle_bp_command_list(struct command_context_s *cmd_ctx) return ERROR_OK; } -static int handle_bp_command_set(struct command_context_s *cmd_ctx, +static int handle_bp_command_set(struct command_context *cmd_ctx, uint32_t addr, uint32_t length, int hw) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); int retval = breakpoint_add(target, addr, length, hw); if (ERROR_OK == retval) command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr); @@ -2731,8 +2744,7 @@ static int handle_bp_command_set(struct command_context_s *cmd_ctx, return retval; } -static int handle_bp_command(struct command_context_s *cmd_ctx, - char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_bp_command) { if (argc == 0) return handle_bp_command_list(cmd_ctx); @@ -2760,7 +2772,7 @@ static int handle_bp_command(struct command_context_s *cmd_ctx, return handle_bp_command_set(cmd_ctx, addr, length, hw); } -static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_rbp_command) { if (argc != 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2768,29 +2780,31 @@ static int handle_rbp_command(struct command_context_s *cmd_ctx, char *cmd, char uint32_t addr; COMMAND_PARSE_NUMBER(u32, args[0], addr); - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); breakpoint_remove(target, addr); return ERROR_OK; } -static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_wp_command) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); if (argc == 0) { - watchpoint_t *watchpoint = target->watchpoints; + struct watchpoint *watchpoint = target->watchpoints; while (watchpoint) { - command_print(cmd_ctx, - "address: 0x%8.8" PRIx32 ", len: 0x%8.8x, r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32 "", - watchpoint->address, - watchpoint->length, - (int)(watchpoint->rw), - watchpoint->value, - watchpoint->mask); + command_print(cmd_ctx, "address: 0x%8.8" PRIx32 + ", len: 0x%8.8" PRIx32 + ", r/w/a: %i, value: 0x%8.8" PRIx32 + ", mask: 0x%8.8" PRIx32, + watchpoint->address, + watchpoint->length, + (int)watchpoint->rw, + watchpoint->value, + watchpoint->mask); watchpoint = watchpoint->next; } return ERROR_OK; @@ -2846,7 +2860,7 @@ static int handle_wp_command(struct command_context_s *cmd_ctx, char *cmd, char return retval; } -static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_rwp_command) { if (argc != 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2854,7 +2868,7 @@ static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char uint32_t addr; COMMAND_PARSE_NUMBER(u32, args[0], addr); - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); watchpoint_remove(target, addr); return ERROR_OK; @@ -2867,8 +2881,7 @@ static int handle_rwp_command(struct command_context_s *cmd_ctx, char *cmd, char * The low-level target implementation must have logged a detailed error * which is forwarded to telnet/GDB session. */ -static int handle_virt2phys_command(command_context_t *cmd_ctx, - char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_virt2phys_command) { if (argc != 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -2877,7 +2890,7 @@ static int handle_virt2phys_command(command_context_t *cmd_ctx, COMMAND_PARSE_NUMBER(u32, args[0], va); uint32_t pa; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); int retval = target->type->virt2phys(target, va, &pa); if (retval == ERROR_OK) command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa); @@ -2909,7 +2922,7 @@ static void writeString(FILE *f, char *s) } /* Dump a gmon.out histogram file. */ -static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename) +static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename) { uint32_t i; FILE *f = fopen(filename, "w"); @@ -3002,9 +3015,9 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename) } /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */ -static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_profile_command) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); struct timeval timeout, now; gettimeofday(&timeout, NULL); @@ -3026,7 +3039,7 @@ static int handle_profile_command(struct command_context_s *cmd_ctx, char *cmd, int numSamples = 0; /* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */ - reg_t *reg = register_get_by_name(target->reg_cache, "pc", 1); + struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1); for (;;) { @@ -3116,8 +3129,8 @@ static int new_int_array_element(Jim_Interp * interp, const char *varname, int i static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - command_context_t *context; - target_t *target; + struct command_context *context; + struct target *target; context = Jim_GetAssocData(interp, "context"); if (context == NULL) @@ -3135,7 +3148,7 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return target_mem2array(interp, target, argc-1, argv + 1); } -static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv) +static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv) { long l; uint32_t width; @@ -3305,8 +3318,8 @@ static int get_int_array_element(Jim_Interp * interp, const char *varname, int i static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - command_context_t *context; - target_t *target; + struct command_context *context; + struct target *target; context = Jim_GetAssocData(interp, "context"); if (context == NULL) { @@ -3321,7 +3334,7 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return target_array2mem(interp,target, argc-1, argv + 1); } -static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv) +static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv) { long l; uint32_t width; @@ -3460,7 +3473,7 @@ static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_ void target_all_handle_event(enum target_event e) { - target_t *target; + struct target *target; LOG_DEBUG("**all*targets: event: %d, %s", (int)e, @@ -3477,9 +3490,9 @@ void target_all_handle_event(enum target_event e) /* FIX? should we propagate errors here rather than printing them * and continuing? */ -void target_handle_event(target_t *target, enum target_event e) +void target_handle_event(struct target *target, enum target_event e) { - target_event_action_t *teap; + struct target_event_action *teap; for (teap = target->event_action; teap != NULL; teap = teap->next) { if (teap->event == e) { @@ -3524,7 +3537,7 @@ static Jim_Nvp nvp_config_opts[] = { { .name = NULL, .value = -1 } }; -static int target_configure(Jim_GetOptInfo *goi, target_t *target) +static int target_configure(Jim_GetOptInfo *goi, struct target *target) { Jim_Nvp *n; Jim_Obj *o; @@ -3597,7 +3610,7 @@ static int target_configure(Jim_GetOptInfo *goi, target_t *target) } { - target_event_action_t *teap; + struct target_event_action *teap; teap = target->event_action; /* replace existing? */ @@ -3769,7 +3782,7 @@ static int target_configure(Jim_GetOptInfo *goi, target_t *target) case TCFG_CHAIN_POSITION: if (goi->isconfigure) { Jim_Obj *o; - jtag_tap_t *tap; + struct jtag_tap *tap; target_free_all_working_areas(target); e = Jim_GetOpt_Obj(goi, &o); if (e != JIM_OK) { @@ -3805,8 +3818,8 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv) int x,y,z; uint8_t target_buf[32]; Jim_Nvp *n; - target_t *target; - struct command_context_s *cmd_ctx; + struct target *target; + struct command_context *cmd_ctx; int e; enum { @@ -4167,7 +4180,7 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv) * scripts/programs should use 'name cget -event NAME' */ { - target_event_action_t *teap; + struct target_event_action *teap; teap = target->event_action; command_print(cmd_ctx, "Event actions for target (%d) %s\n", target->target_number, @@ -4221,8 +4234,8 @@ static int target_create(Jim_GetOptInfo *goi) char *cp2; int e; int x; - target_t *target; - struct command_context_s *cmd_ctx; + struct target *target; + struct command_context *cmd_ctx; cmd_ctx = Jim_GetAssocData(goi->interp, "context"); if (goi->argc < 3) { @@ -4269,14 +4282,14 @@ static int target_create(Jim_GetOptInfo *goi) } /* Create it */ - target = calloc(1,sizeof(target_t)); + target = calloc(1,sizeof(struct target)); /* set target number */ target->target_number = new_target_number(); /* allocate memory for each unique target type */ - target->type = (target_type_t*)calloc(1,sizeof(target_type_t)); + target->type = (struct target_type*)calloc(1,sizeof(struct target_type)); - memcpy(target->type, target_types[x], sizeof(target_type_t)); + memcpy(target->type, target_types[x], sizeof(struct target_type)); /* will be set by "-endian" */ target->endianness = TARGET_ENDIAN_UNKNOWN; @@ -4299,7 +4312,7 @@ static int target_create(Jim_GetOptInfo *goi) target->halt_issued = false; /* initialize trace information */ - target->trace_info = malloc(sizeof(trace_t)); + target->trace_info = malloc(sizeof(struct trace)); target->trace_info->num_trace_points = 0; target->trace_info->trace_points_size = 0; target->trace_info->trace_points = NULL; @@ -4348,7 +4361,7 @@ static int target_create(Jim_GetOptInfo *goi) /* append to end of list */ { - target_t **tpp; + struct target **tpp; tpp = &(all_targets); while (*tpp) { tpp = &((*tpp)->next); @@ -4374,8 +4387,8 @@ static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { int x,r,e; jim_wide w; - struct command_context_s *cmd_ctx; - target_t *target; + struct command_context *cmd_ctx; + struct target *target; Jim_GetOptInfo goi; enum tcmd { /* TG = target generic */ @@ -4520,7 +4533,7 @@ static void free_fastload(void) -static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_fast_load_image_command) { uint8_t *buffer; uint32_t buf_cnt; @@ -4529,9 +4542,9 @@ static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, cha uint32_t max_address = 0xffffffff; int i; - image_t image; + struct image image; - int retval = parse_load_image_command_args(cmd_ctx, args, argc, + int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args, &image, &min_address, &max_address); if (ERROR_OK != retval) return retval; @@ -4631,7 +4644,7 @@ static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, cha return retval; } -static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_fast_load_command) { if (argc > 0) return ERROR_COMMAND_SYNTAX_ERROR; @@ -4646,7 +4659,7 @@ static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd int retval = ERROR_OK; for (i = 0; i < fastload_num;i++) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd_ctx); command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x", (unsigned int)(fastload[i].address), (unsigned int)(fastload[i].length)); @@ -4663,8 +4676,8 @@ static int handle_fast_load_command(struct command_context_s *cmd_ctx, char *cmd static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - command_context_t *context; - target_t *target; + struct command_context *context; + struct target *target; int retval; context = Jim_GetAssocData(interp, "context"); @@ -4747,7 +4760,7 @@ static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return JIM_OK; } -int target_register_commands(struct command_context_s *cmd_ctx) +int target_register_commands(struct command_context *cmd_ctx) { register_command(cmd_ctx, NULL, "targets", @@ -4760,7 +4773,7 @@ int target_register_commands(struct command_context_s *cmd_ctx) return ERROR_OK; } -int target_register_user_commands(struct command_context_s *cmd_ctx) +int target_register_user_commands(struct command_context *cmd_ctx) { int retval = ERROR_OK; if ((retval = target_request_register_commands(cmd_ctx)) != ERROR_OK)