X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=df8496f576333cc14899b6703a7253437173a3af;hp=e8f91def47ae8cc3481112d6b2540483d3ab37df;hb=dfecfd5fd471708ac15af08b52964e8f8da9f4be;hpb=72b421418f315cb54a01ba4d249082f989d5154a

diff --git a/src/target/target.c b/src/target/target.c
index e8f91def47..df8496f576 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -86,8 +86,8 @@ target_type_t *target_types[] =
 };
 
 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 },
@@ -600,12 +600,12 @@ int target_bulk_write_memory(struct target_s *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);
 }
@@ -872,7 +872,7 @@ int target_init(struct command_context_s *cmd_ctx)
 
 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)
 	{
@@ -886,7 +886,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;
@@ -896,7 +896,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)
@@ -911,7 +911,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;
@@ -934,8 +934,8 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 
 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)
 	{
@@ -944,7 +944,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;
@@ -961,8 +961,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)
 	{
@@ -971,7 +971,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;
@@ -988,8 +988,8 @@ int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
 
 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)
 	{
@@ -1014,7 +1014,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;
@@ -1028,7 +1028,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);
@@ -1046,11 +1046,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) ||
@@ -1082,10 +1082,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_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)
@@ -1145,7 +1145,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;
 
@@ -1167,7 +1167,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;
@@ -1202,7 +1202,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_s *target, struct working_area *area, int restore)
 {
 	if (area->free)
 		return ERROR_OK;
@@ -1223,7 +1223,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_s *target, struct working_area *area)
 {
 	return target_free_working_area_restore(target, area, 1);
 }
@@ -1233,11 +1233,11 @@ int target_free_working_area(struct target_s *target, working_area_t *area)
  */
 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)
@@ -1876,7 +1876,7 @@ COMMAND_HANDLER(handle_reg_command)
 	/* 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)
@@ -1919,7 +1919,7 @@ COMMAND_HANDLER(handle_reg_command)
 		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)
 		{
@@ -1961,7 +1961,7 @@ COMMAND_HANDLER(handle_reg_command)
 
 		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);
@@ -1976,7 +1976,7 @@ COMMAND_HANDLER(handle_reg_command)
 		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);
@@ -2363,7 +2363,7 @@ COMMAND_HANDLER(handle_mw_command)
 
 }
 
-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)
@@ -2408,7 +2408,7 @@ COMMAND_HANDLER(handle_load_image_command)
 	uint32_t min_address = 0;
 	uint32_t max_address = 0xffffffff;
 	int i;
-	image_t image;
+	struct image image;
 
 	int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
 			&image, &min_address, &max_address);
@@ -2564,7 +2564,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 	uint32_t checksum = 0;
 	uint32_t mem_checksum = 0;
 
-	image_t image;
+	struct image image;
 
 	target_t *target = get_current_target(cmd_ctx);
 
@@ -2712,7 +2712,7 @@ COMMAND_HANDLER(handle_test_image_command)
 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)
@@ -3495,7 +3495,7 @@ void target_all_handle_event(enum target_event e)
  */
 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) {
@@ -3613,7 +3613,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? */
@@ -4183,7 +4183,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,
@@ -4315,7 +4315,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;
@@ -4545,7 +4545,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	uint32_t max_address = 0xffffffff;
 	int i;
 
-	image_t image;
+	struct image image;
 
 	int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
 			&image, &min_address, &max_address);