static int target_mem2array(Jim_Interp *interp, target_t *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,
};
target_t *all_targets = NULL;
-target_event_callback_t *target_event_callbacks = NULL;
-target_timer_callback_t *target_timer_callbacks = 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 },
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_s *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))
{
}
int target_add_breakpoint(struct target_s *target,
- struct breakpoint_s *breakpoint)
+ struct breakpoint *breakpoint)
{
return target->type->add_breakpoint(target, breakpoint);
}
int target_remove_breakpoint(struct target_s *target,
- struct breakpoint_s *breakpoint)
+ struct breakpoint *breakpoint)
{
return target->type->remove_breakpoint(target, breakpoint);
}
int target_add_watchpoint(struct target_s *target,
- struct watchpoint_s *watchpoint)
+ struct watchpoint *watchpoint)
{
return target->type->add_watchpoint(target, watchpoint);
}
int target_remove_watchpoint(struct target_s *target,
- struct watchpoint_s *watchpoint)
+ 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)
+ struct reg **reg_list[], int *reg_list_size)
{
return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
}
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 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)
{
int retval;
for (target = all_targets; target; target = target->next) {
- struct target_type_s *type = target->type;
+ struct target_type *type = target->type;
target_reset_examined(target);
if (target->type->examine == NULL)
int target_register_event_callback(int (*callback)(struct target_s *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)
{
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;
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)
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;
int target_unregister_event_callback(int (*callback)(struct target_s *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)
{
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;
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)
{
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;
int target_call_event_callbacks(target_t *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)
{
}
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;
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);
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) ||
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_s *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)
/* 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;
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;
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_s *target, struct working_area *area, int restore)
{
if (area->free)
return ERROR_OK;
return ERROR_OK;
}
-int target_free_working_area(struct target_s *target, working_area_t *area)
+int target_free_working_area(struct target_s *target, struct working_area *area)
{
return target_free_working_area_restore(target, area, 1);
}
*/
void target_free_all_working_areas_restore(struct target_s *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)
COMMAND_HANDLER(handle_reg_command)
{
target_t *target;
- reg_t *reg = NULL;
+ struct reg *reg = NULL;
int count = 0;
char *value;
/* 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)
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)
{
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);
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);
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)
return ERROR_OK;
}
- return handle_wait_halt_command(cmd_ctx, cmd, args, argc);
+ return CALL_COMMAND_HANDLER(handle_wait_halt_command);
}
COMMAND_HANDLER(handle_soft_reset_halt_command)
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned size = 0;
- switch (cmd[2]) {
+ switch (CMD_NAME[2]) {
case 'w': size = 4; break;
case 'h': size = 2; break;
case 'b': size = 1; break;
target_t *target = get_current_target(cmd_ctx);
unsigned wordsize;
uint8_t value_buf[4];
- switch (cmd[2])
+ switch (CMD_NAME[2])
{
case 'w':
wordsize = 4;
}
-static COMMAND_HELPER(parse_load_image_command_args, 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)
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, cmd, args, argc,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;
COMMAND_HANDLER(handle_dump_image_command)
{
- fileio_t fileio;
+ struct fileio fileio;
uint8_t buffer[560];
int retvaltemp;
uint32_t checksum = 0;
uint32_t mem_checksum = 0;
- image_t image;
+ struct image image;
target_t *target = get_current_target(cmd_ctx);
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);
}
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)
{
target_t *target = get_current_target(cmd_ctx);
- breakpoint_t *breakpoint = target->breakpoints;
+ struct breakpoint *breakpoint = target->breakpoints;
while (breakpoint)
{
if (breakpoint->type == BKPT_SOFT)
if (argc == 0)
{
- watchpoint_t *watchpoint = target->watchpoints;
+ struct watchpoint *watchpoint = target->watchpoints;
while (watchpoint)
{
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 (;;)
{
*/
void target_handle_event(target_t *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) {
}
{
- target_event_action_t *teap;
+ struct target_event_action *teap;
teap = target->event_action;
/* replace existing? */
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) {
* 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,
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;
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;
uint32_t max_address = 0xffffffff;
int i;
- image_t image;
+ struct image image;
- int retval = parse_load_image_command_args(cmd_ctx, cmd, args, argc,
+ int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
&image, &min_address, &max_address);
if (ERROR_OK != retval)
return retval;