X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=fef7c2991315c3345d0070412153d7883a7490bf;hp=8cc46ecd665fdf31d9c22efb189a77ba208ff28d;hb=93459582fd340e4f63efed0fab9abd49a2cb6373;hpb=a585bdf7269ce5c861c83ee3294ba1f074e9c877

diff --git a/src/target/target.c b/src/target/target.c
index 8cc46ecd66..fef7c29913 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 },
@@ -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_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))
 	{
@@ -611,12 +611,12 @@ int target_remove_breakpoint(struct target_s *target,
 }
 
 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);
 }
@@ -634,8 +634,8 @@ int target_step(struct target_s *target,
 
 
 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)
 {
@@ -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);
@@ -2493,7 +2493,7 @@ COMMAND_HANDLER(handle_load_image_command)
 
 COMMAND_HANDLER(handle_dump_image_command)
 {
-	fileio_t fileio;
+	struct fileio fileio;
 
 	uint8_t buffer[560];
 	int retvaltemp;
@@ -2797,7 +2797,7 @@ COMMAND_HANDLER(handle_wp_command)
 
 	if (argc == 0)
 	{
-		watchpoint_t *watchpoint = target->watchpoints;
+		struct watchpoint *watchpoint = target->watchpoints;
 
 		while (watchpoint)
 		{
@@ -3785,7 +3785,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) {