Commit 7926c328 authored by Dominic Braun's avatar Dominic Braun Committed by Greg Kroah-Hartman
Browse files

staging: vc04_services: Remove VCHIQ_SERVICE_T typedef 



Typedefing structs is not encouraged in the kernel.

Signed-off-by: default avatarDominic Braun <inf.braun@fau.de>
Signed-off-by: default avatarTobias Büttner <tobias.buettner@fau.de>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent d3af2bcc

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c

+26 −25
Original line number Diff line number Diff line
@@ -110,7 +110,7 @@ static const char *const resume_state_names[] = { 
static void suspend_timer_callback(struct timer_list *t);



struct user_service {

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	void *userdata;

	VCHIQ_INSTANCE_T instance;

	char is_vchi;
@@ -336,7 +336,7 @@ VCHIQ_STATUS_T vchiq_add_service( 
{

	VCHIQ_STATUS_T status;

	VCHIQ_STATE_T *state = instance->state;

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;

	int srvstate;



	vchiq_log_trace(vchiq_core_log_level,
@@ -375,7 +375,7 @@ VCHIQ_STATUS_T vchiq_open_service( 
{

	VCHIQ_STATUS_T   status = VCHIQ_ERROR;

	VCHIQ_STATE_T   *state = instance->state;

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;



	vchiq_log_trace(vchiq_core_log_level,

		"%s(%p) called", __func__, instance);
@@ -462,7 +462,7 @@ vchiq_blocking_bulk_transfer(VCHIQ_SERVICE_HANDLE_T handle, void *data, 
	unsigned int size, VCHIQ_BULK_DIR_T dir)

{

	VCHIQ_INSTANCE_T instance;

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	VCHIQ_STATUS_T status;

	struct bulk_waiter_node *waiter = NULL;
@@ -619,7 +619,7 @@ service_callback(VCHIQ_REASON_T reason, struct vchiq_header *header, 
	** contains a circular buffer for completion records.

	*/

	struct user_service *user_service;

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	VCHIQ_INSTANCE_T instance;

	bool skip_completion = false;
@@ -834,7 +834,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
{

	VCHIQ_INSTANCE_T instance = file->private_data;

	VCHIQ_STATUS_T status = VCHIQ_SUCCESS;

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;

	long ret = 0;

	int i, rc;
@@ -1201,7 +1201,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 


			for (ret = 0; ret < args.count; ret++) {

				struct vchiq_completion_data *completion;

				VCHIQ_SERVICE_T *service;

				struct vchiq_service *service;

				struct user_service *user_service;

				struct vchiq_header *header;
@@ -1991,7 +1991,7 @@ static int vchiq_release(struct inode *inode, struct file *file) 
{

	VCHIQ_INSTANCE_T instance = file->private_data;

	VCHIQ_STATE_T *state = vchiq_get_state();

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	int ret = 0;

	int i;
@@ -2062,7 +2062,7 @@ static int vchiq_release(struct inode *inode, struct file *file) 
	while (instance->completion_remove !=

		instance->completion_insert) {

		struct vchiq_completion_data *completion;

		VCHIQ_SERVICE_T *service;

		struct vchiq_service *service;



		completion = &instance->completions[

			instance->completion_remove & (MAX_COMPLETIONS - 1)];
@@ -2167,7 +2167,7 @@ vchiq_dump_platform_instances(void *dump_context) 
		marking those that have been dumped. */



	for (i = 0; i < state->unused_service; i++) {

		VCHIQ_SERVICE_T *service = state->services[i];

		struct vchiq_service *service = state->services[i];

		VCHIQ_INSTANCE_T instance;



		if (service && (service->base.callback == service_callback)) {
@@ -2178,7 +2178,7 @@ vchiq_dump_platform_instances(void *dump_context) 
	}



	for (i = 0; i < state->unused_service; i++) {

		VCHIQ_SERVICE_T *service = state->services[i];

		struct vchiq_service *service = state->services[i];

		VCHIQ_INSTANCE_T instance;



		if (service && (service->base.callback == service_callback)) {
@@ -2208,7 +2208,8 @@ vchiq_dump_platform_instances(void *dump_context) 
***************************************************************************/



void

vchiq_dump_platform_service_state(void *dump_context, VCHIQ_SERVICE_T *service)

vchiq_dump_platform_service_state(void *dump_context,

				  struct vchiq_service *service)

{

	struct user_service *user_service =

			(struct user_service *)service->base.userdata;
@@ -2756,7 +2757,7 @@ output_timeout_error(VCHIQ_STATE_T *state) 
		goto output_msg;

	}

	for (i = 0; i < active_services; i++) {

		VCHIQ_SERVICE_T *service_ptr = state->services[i];

		struct vchiq_service *service_ptr = state->services[i];



		if (service_ptr && service_ptr->service_use_count &&

			(service_ptr->srvstate != VCHIQ_SRVSTATE_FREE)) {
@@ -2987,7 +2988,7 @@ vchiq_check_resume(VCHIQ_STATE_T *state) 
}



VCHIQ_STATUS_T

vchiq_use_internal(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,

vchiq_use_internal(VCHIQ_STATE_T *state, struct vchiq_service *service,

		   enum USE_TYPE_E use_type)

{

	struct vchiq_arm_state *arm_state = vchiq_platform_get_arm_state(state);
@@ -3120,7 +3121,7 @@ vchiq_use_internal(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, 
}



VCHIQ_STATUS_T

vchiq_release_internal(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service)

vchiq_release_internal(VCHIQ_STATE_T *state, struct vchiq_service *service)

{

	struct vchiq_arm_state *arm_state = vchiq_platform_get_arm_state(state);

	VCHIQ_STATUS_T ret = VCHIQ_SUCCESS;
@@ -3202,13 +3203,13 @@ vchiq_on_remote_release(VCHIQ_STATE_T *state) 
}



VCHIQ_STATUS_T

vchiq_use_service_internal(VCHIQ_SERVICE_T *service)

vchiq_use_service_internal(struct vchiq_service *service)

{

	return vchiq_use_internal(service->state, service, USE_TYPE_SERVICE);

}



VCHIQ_STATUS_T

vchiq_release_service_internal(VCHIQ_SERVICE_T *service)

vchiq_release_service_internal(struct vchiq_service *service)

{

	return vchiq_release_internal(service->state, service);

}
@@ -3222,7 +3223,7 @@ vchiq_instance_get_debugfs_node(VCHIQ_INSTANCE_T instance) 
int

vchiq_instance_get_use_count(VCHIQ_INSTANCE_T instance)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	int use_count = 0, i;



	i = 0;
@@ -3249,7 +3250,7 @@ vchiq_instance_get_trace(VCHIQ_INSTANCE_T instance) 
void

vchiq_instance_set_trace(VCHIQ_INSTANCE_T instance, int trace)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	int i;



	i = 0;
@@ -3276,7 +3277,7 @@ VCHIQ_STATUS_T 
vchiq_use_service_no_resume(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_STATUS_T ret = VCHIQ_ERROR;

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);



	if (service) {

		ret = vchiq_use_internal(service->state, service,
@@ -3290,7 +3291,7 @@ VCHIQ_STATUS_T 
vchiq_use_service(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_STATUS_T ret = VCHIQ_ERROR;

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);



	if (service) {

		ret = vchiq_use_internal(service->state, service,
@@ -3304,7 +3305,7 @@ VCHIQ_STATUS_T 
vchiq_release_service(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_STATUS_T ret = VCHIQ_ERROR;

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);



	if (service) {

		ret = vchiq_release_internal(service->state, service);
@@ -3354,7 +3355,7 @@ vchiq_dump_service_use_state(VCHIQ_STATE_T *state) 
		only_nonzero = 1;



	for (i = 0; i < active_services; i++) {

		VCHIQ_SERVICE_T *service_ptr = state->services[i];

		struct vchiq_service *service_ptr = state->services[i];



		if (!service_ptr)

			continue;
@@ -3406,7 +3407,7 @@ vchiq_dump_service_use_state(VCHIQ_STATE_T *state) 
}



VCHIQ_STATUS_T

vchiq_check_service(VCHIQ_SERVICE_T *service)

vchiq_check_service(struct vchiq_service *service)

{

	struct vchiq_arm_state *arm_state;

	VCHIQ_STATUS_T ret = VCHIQ_ERROR;

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h

+4 −4
Original line number Diff line number Diff line
@@ -163,7 +163,7 @@ extern VCHIQ_STATUS_T 
vchiq_release_service(VCHIQ_SERVICE_HANDLE_T handle);



extern VCHIQ_STATUS_T

vchiq_check_service(VCHIQ_SERVICE_T *service);

vchiq_check_service(struct vchiq_service *service);



extern VCHIQ_STATUS_T

vchiq_platform_suspend(VCHIQ_STATE_T *state);
@@ -187,10 +187,10 @@ extern int 
vchiq_videocore_wanted(VCHIQ_STATE_T *state);



extern VCHIQ_STATUS_T

vchiq_use_internal(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,

vchiq_use_internal(VCHIQ_STATE_T *state, struct vchiq_service *service,

		   enum USE_TYPE_E use_type);

extern VCHIQ_STATUS_T

vchiq_release_internal(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service);

vchiq_release_internal(VCHIQ_STATE_T *state, struct vchiq_service *service);



extern struct vchiq_debugfs_node *

vchiq_instance_get_debugfs_node(VCHIQ_INSTANCE_T instance);

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c

+66 −71
Original line number Diff line number Diff line
@@ -152,7 +152,7 @@ static const char *msg_type_str(unsigned int msg_type) 
}



static inline void

vchiq_set_service_state(VCHIQ_SERVICE_T *service, int newstate)

vchiq_set_service_state(struct vchiq_service *service, int newstate)

{

	vchiq_log_info(vchiq_core_log_level, "%d: srv:%d %s->%s",

		service->state->id, service->localport,
@@ -161,10 +161,10 @@ vchiq_set_service_state(VCHIQ_SERVICE_T *service, int newstate) 
	service->srvstate = newstate;

}



VCHIQ_SERVICE_T *

struct vchiq_service *

find_service_by_handle(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;



	spin_lock(&service_spinlock);

	service = handle_to_service(handle);
@@ -183,10 +183,10 @@ find_service_by_handle(VCHIQ_SERVICE_HANDLE_T handle) 
	return service;

}



VCHIQ_SERVICE_T *

struct vchiq_service *

find_service_by_port(VCHIQ_STATE_T *state, int localport)

{

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;



	if ((unsigned int)localport <= VCHIQ_PORT_MAX) {

		spin_lock(&service_spinlock);
@@ -206,11 +206,11 @@ find_service_by_port(VCHIQ_STATE_T *state, int localport) 
	return service;

}



VCHIQ_SERVICE_T *

struct vchiq_service *

find_service_for_instance(VCHIQ_INSTANCE_T instance,

	VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;



	spin_lock(&service_spinlock);

	service = handle_to_service(handle);
@@ -230,11 +230,11 @@ find_service_for_instance(VCHIQ_INSTANCE_T instance, 
	return service;

}



VCHIQ_SERVICE_T *

struct vchiq_service *

find_closed_service_for_instance(VCHIQ_INSTANCE_T instance,

	VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;



	spin_lock(&service_spinlock);

	service = handle_to_service(handle);
@@ -256,16 +256,16 @@ find_closed_service_for_instance(VCHIQ_INSTANCE_T instance, 
	return service;

}



VCHIQ_SERVICE_T *

struct vchiq_service *

next_service_by_instance(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance,

	int *pidx)

{

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;

	int idx = *pidx;



	spin_lock(&service_spinlock);

	while (idx < state->unused_service) {

		VCHIQ_SERVICE_T *srv = state->services[idx++];

		struct vchiq_service *srv = state->services[idx++];



		if (srv && (srv->srvstate != VCHIQ_SRVSTATE_FREE) &&

			(srv->instance == instance)) {
@@ -283,7 +283,7 @@ next_service_by_instance(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance, 
}



void

lock_service(VCHIQ_SERVICE_T *service)

lock_service(struct vchiq_service *service)

{

	spin_lock(&service_spinlock);

	WARN_ON(!service);
@@ -295,7 +295,7 @@ lock_service(VCHIQ_SERVICE_T *service) 
}



void

unlock_service(VCHIQ_SERVICE_T *service)

unlock_service(struct vchiq_service *service)

{

	spin_lock(&service_spinlock);

	if (!service) {
@@ -327,7 +327,7 @@ unlock_service(VCHIQ_SERVICE_T *service) 
int

vchiq_get_client_id(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	int id;



	id = service ? service->client_id : 0;
@@ -340,7 +340,7 @@ vchiq_get_client_id(VCHIQ_SERVICE_HANDLE_T handle) 
void *

vchiq_get_service_userdata(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service = handle_to_service(handle);

	struct vchiq_service *service = handle_to_service(handle);



	return service ? service->base.userdata : NULL;

}
@@ -348,13 +348,13 @@ vchiq_get_service_userdata(VCHIQ_SERVICE_HANDLE_T handle) 
int

vchiq_get_service_fourcc(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_SERVICE_T *service = handle_to_service(handle);

	struct vchiq_service *service = handle_to_service(handle);



	return service ? service->base.fourcc : 0;

}



static void

mark_service_closing_internal(VCHIQ_SERVICE_T *service, int sh_thread)

mark_service_closing_internal(struct vchiq_service *service, int sh_thread)

{

	VCHIQ_STATE_T *state = service->state;

	struct vchiq_service_quota *service_quota;
@@ -379,13 +379,13 @@ mark_service_closing_internal(VCHIQ_SERVICE_T *service, int sh_thread) 
}



static void

mark_service_closing(VCHIQ_SERVICE_T *service)

mark_service_closing(struct vchiq_service *service)

{

	mark_service_closing_internal(service, 0);

}



static inline VCHIQ_STATUS_T

make_service_callback(VCHIQ_SERVICE_T *service, VCHIQ_REASON_T reason,

make_service_callback(struct vchiq_service *service, VCHIQ_REASON_T reason,

		      struct vchiq_header *header, void *bulk_userdata)

{

	VCHIQ_STATUS_T status;
@@ -482,7 +482,7 @@ calc_stride(size_t size) 
}



/* Called by the slot handler thread */

static VCHIQ_SERVICE_T *

static struct vchiq_service *

get_listening_service(VCHIQ_STATE_T *state, int fourcc)

{

	int i;
@@ -490,7 +490,7 @@ get_listening_service(VCHIQ_STATE_T *state, int fourcc) 
	WARN_ON(fourcc == VCHIQ_FOURCC_INVALID);



	for (i = 0; i < state->unused_service; i++) {

		VCHIQ_SERVICE_T *service = state->services[i];

		struct vchiq_service *service = state->services[i];



		if (service &&

			(service->public_fourcc == fourcc) &&
@@ -506,13 +506,13 @@ get_listening_service(VCHIQ_STATE_T *state, int fourcc) 
}



/* Called by the slot handler thread */

static VCHIQ_SERVICE_T *

static struct vchiq_service *

get_connected_service(VCHIQ_STATE_T *state, unsigned int port)

{

	int i;



	for (i = 0; i < state->unused_service; i++) {

		VCHIQ_SERVICE_T *service = state->services[i];

		struct vchiq_service *service = state->services[i];



		if (service && (service->srvstate == VCHIQ_SRVSTATE_OPEN)

			&& (service->remoteport == port)) {
@@ -524,7 +524,7 @@ get_connected_service(VCHIQ_STATE_T *state, unsigned int port) 
}



inline void

request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type)

request_poll(VCHIQ_STATE_T *state, struct vchiq_service *service, int poll_type)

{

	u32 value;
@@ -799,13 +799,10 @@ copy_message_data( 


/* Called by the slot handler and application threads */

static VCHIQ_STATUS_T

queue_message(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,

	int msgid,

queue_message(VCHIQ_STATE_T *state, struct vchiq_service *service, int msgid,

	      ssize_t (*copy_callback)(void *context, void *dest,

				       size_t offset, size_t maxsize),

	void *context,

	size_t size,

	int flags)

	      void *context, size_t size, int flags)

{

	VCHIQ_SHARED_STATE_T *local;

	struct vchiq_service_quota *service_quota = NULL;
@@ -1049,13 +1046,11 @@ queue_message(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, 


/* Called by the slot handler and application threads */

static VCHIQ_STATUS_T

queue_message_sync(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,

queue_message_sync(VCHIQ_STATE_T *state, struct vchiq_service *service,

		   int msgid,

		   ssize_t (*copy_callback)(void *context, void *dest,

					    size_t offset, size_t maxsize),

	void *context,

	int size,

	int is_blocking)

		   void *context, int size, int is_blocking)

{

	VCHIQ_SHARED_STATE_T *local;

	struct vchiq_header *header;
@@ -1150,7 +1145,7 @@ claim_slot(VCHIQ_SLOT_INFO_T *slot) 


static void

release_slot(VCHIQ_STATE_T *state, VCHIQ_SLOT_INFO_T *slot_info,

	struct vchiq_header *header, VCHIQ_SERVICE_T *service)

	     struct vchiq_header *header, struct vchiq_service *service)

{

	int release_count;
@@ -1202,7 +1197,7 @@ release_slot(VCHIQ_STATE_T *state, VCHIQ_SLOT_INFO_T *slot_info, 


/* Called by the slot handler - don't hold the bulk mutex */

static VCHIQ_STATUS_T

notify_bulks(VCHIQ_SERVICE_T *service, struct vchiq_bulk_queue *queue,

notify_bulks(struct vchiq_service *service, struct vchiq_bulk_queue *queue,

	     int retry_poll)

{

	VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
@@ -1297,7 +1292,7 @@ poll_services(VCHIQ_STATE_T *state) 
		flags = atomic_xchg(&state->poll_services[group], 0);

		for (i = 0; flags; i++) {

			if (flags & (1 << i)) {

				VCHIQ_SERVICE_T *service =

				struct vchiq_service *service =

					find_service_by_port(state,

						(group<<5) + i);

				u32 service_flags;
@@ -1353,7 +1348,7 @@ poll_services(VCHIQ_STATE_T *state) 


/* Called with the bulk_mutex held */

static void

abort_outstanding_bulks(VCHIQ_SERVICE_T *service,

abort_outstanding_bulks(struct vchiq_service *service,

			struct vchiq_bulk_queue *queue)

{

	int is_tx = (queue == &service->bulk_tx);
@@ -1406,7 +1401,7 @@ abort_outstanding_bulks(VCHIQ_SERVICE_T *service, 
static int

parse_open(VCHIQ_STATE_T *state, struct vchiq_header *header)

{

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;

	int msgid, size;

	unsigned int localport, remoteport;
@@ -1529,7 +1524,7 @@ static void 
parse_rx_slots(VCHIQ_STATE_T *state)

{

	VCHIQ_SHARED_STATE_T *remote = state->remote;

	VCHIQ_SERVICE_T *service = NULL;

	struct vchiq_service *service = NULL;

	int tx_pos;



	DEBUG_INITIALISE(state->local)
@@ -1993,7 +1988,7 @@ sync_func(void *v) 
			state->remote->slot_sync);



	while (1) {

		VCHIQ_SERVICE_T *service;

		struct vchiq_service *service;

		int msgid, size;

		int type;

		unsigned int localport, remoteport;
@@ -2301,17 +2296,17 @@ vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero) 
}



/* Called from application thread when a client or server service is created. */

VCHIQ_SERVICE_T *

struct vchiq_service *

vchiq_add_service_internal(VCHIQ_STATE_T *state,

	const struct vchiq_service_params *params, int srvstate,

	VCHIQ_INSTANCE_T instance, VCHIQ_USERDATA_TERM_T userdata_term)

{

	VCHIQ_SERVICE_T *service;

	VCHIQ_SERVICE_T **pservice = NULL;

	struct vchiq_service *service;

	struct vchiq_service **pservice = NULL;

	struct vchiq_service_quota *service_quota;

	int i;



	service = kmalloc(sizeof(VCHIQ_SERVICE_T), GFP_KERNEL);

	service = kmalloc(sizeof(*service), GFP_KERNEL);

	if (!service)

		return service;
@@ -2363,7 +2358,7 @@ vchiq_add_service_internal(VCHIQ_STATE_T *state, 


	if (srvstate == VCHIQ_SRVSTATE_OPENING) {

		for (i = 0; i < state->unused_service; i++) {

			VCHIQ_SERVICE_T *srv = state->services[i];

			struct vchiq_service *srv = state->services[i];



			if (!srv) {

				pservice = &state->services[i];
@@ -2372,7 +2367,7 @@ vchiq_add_service_internal(VCHIQ_STATE_T *state, 
		}

	} else {

		for (i = (state->unused_service - 1); i >= 0; i--) {

			VCHIQ_SERVICE_T *srv = state->services[i];

			struct vchiq_service *srv = state->services[i];



			if (!srv)

				pservice = &state->services[i];
@@ -2433,7 +2428,7 @@ vchiq_add_service_internal(VCHIQ_STATE_T *state, 
}



VCHIQ_STATUS_T

vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id)

vchiq_open_service_internal(struct vchiq_service *service, int client_id)

{

	struct vchiq_open_payload payload = {

		service->base.fourcc,
@@ -2476,7 +2471,7 @@ vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id) 
}



static void

release_service_messages(VCHIQ_SERVICE_T *service)

release_service_messages(struct vchiq_service *service)

{

	VCHIQ_STATE_T *state = service->state;

	int slot_last = state->remote->slot_last;
@@ -2537,7 +2532,7 @@ release_service_messages(VCHIQ_SERVICE_T *service) 
}



static int

do_abort_bulks(VCHIQ_SERVICE_T *service)

do_abort_bulks(struct vchiq_service *service)

{

	VCHIQ_STATUS_T status;
@@ -2556,7 +2551,7 @@ do_abort_bulks(VCHIQ_SERVICE_T *service) 
}



static VCHIQ_STATUS_T

close_service_complete(VCHIQ_SERVICE_T *service, int failstate)

close_service_complete(struct vchiq_service *service, int failstate)

{

	VCHIQ_STATUS_T status;

	int is_server = (service->public_fourcc != VCHIQ_FOURCC_INVALID);
@@ -2618,7 +2613,7 @@ close_service_complete(VCHIQ_SERVICE_T *service, int failstate) 


/* Called by the slot handler */

VCHIQ_STATUS_T

vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd)

vchiq_close_service_internal(struct vchiq_service *service, int close_recvd)

{

	VCHIQ_STATE_T *state = service->state;

	VCHIQ_STATUS_T status = VCHIQ_SUCCESS;
@@ -2752,7 +2747,7 @@ vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd) 


/* Called from the application process upon process death */

void

vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service)

vchiq_terminate_service_internal(struct vchiq_service *service)

{

	VCHIQ_STATE_T *state = service->state;
@@ -2767,7 +2762,7 @@ vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service) 


/* Called from the slot handler */

void

vchiq_free_service_internal(VCHIQ_SERVICE_T *service)

vchiq_free_service_internal(struct vchiq_service *service)

{

	VCHIQ_STATE_T *state = service->state;
@@ -2800,7 +2795,7 @@ vchiq_free_service_internal(VCHIQ_SERVICE_T *service) 
VCHIQ_STATUS_T

vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	int i;



	/* Find all services registered to this client and enable them. */
@@ -2836,7 +2831,7 @@ vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance) 
VCHIQ_STATUS_T

vchiq_shutdown_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance)

{

	VCHIQ_SERVICE_T *service;

	struct vchiq_service *service;

	int i;



	/* Find all services registered to this client and enable them. */
@@ -2893,7 +2888,7 @@ VCHIQ_STATUS_T 
vchiq_close_service(VCHIQ_SERVICE_HANDLE_T handle)

{

	/* Unregister the service */

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	VCHIQ_STATUS_T status = VCHIQ_SUCCESS;



	if (!service)
@@ -2952,7 +2947,7 @@ VCHIQ_STATUS_T 
vchiq_remove_service(VCHIQ_SERVICE_HANDLE_T handle)

{

	/* Unregister the service */

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	VCHIQ_STATUS_T status = VCHIQ_SUCCESS;



	if (!service)
@@ -3019,7 +3014,7 @@ VCHIQ_STATUS_T vchiq_bulk_transfer(VCHIQ_SERVICE_HANDLE_T handle, 
				   VCHIQ_BULK_MODE_T mode,

				   VCHIQ_BULK_DIR_T dir)

{

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_bulk_queue *queue;

	struct vchiq_bulk *bulk;

	VCHIQ_STATE_T *state;
@@ -3171,7 +3166,7 @@ vchiq_queue_message(VCHIQ_SERVICE_HANDLE_T handle, 
		    void *context,

		    size_t size)

{

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	VCHIQ_STATUS_T status = VCHIQ_ERROR;



	if (!service ||
@@ -3220,7 +3215,7 @@ void 
vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle,

		      struct vchiq_header *header)

{

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	VCHIQ_SHARED_STATE_T *remote;

	VCHIQ_STATE_T *state;

	int slot_index;
@@ -3260,7 +3255,7 @@ VCHIQ_STATUS_T 
vchiq_get_peer_version(VCHIQ_SERVICE_HANDLE_T handle, short *peer_version)

{

	VCHIQ_STATUS_T status = VCHIQ_ERROR;

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);



	if (!service ||

	    (vchiq_check_service(service) != VCHIQ_SUCCESS) ||
@@ -3289,7 +3284,7 @@ VCHIQ_STATUS_T 
vchiq_set_service_option(VCHIQ_SERVICE_HANDLE_T handle,

	VCHIQ_SERVICE_OPTION_T option, int value)

{

	VCHIQ_SERVICE_T *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(handle);

	VCHIQ_STATUS_T status = VCHIQ_ERROR;



	if (service) {
@@ -3461,7 +3456,7 @@ vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state) 
	vchiq_dump_platform_instances(dump_context);



	for (i = 0; i < state->unused_service; i++) {

		VCHIQ_SERVICE_T *service = find_service_by_port(state, i);

		struct vchiq_service *service = find_service_by_port(state, i);



		if (service) {

			vchiq_dump_service_state(dump_context, service);
@@ -3471,7 +3466,7 @@ vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state) 
}



void

vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service)

vchiq_dump_service_state(void *dump_context, struct vchiq_service *service)

{

	char buf[80];

	int len;

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h

+26 −25
Original line number Diff line number Diff line
@@ -280,7 +280,7 @@ typedef struct vchiq_slot_info_struct { 
	short release_count;

} VCHIQ_SLOT_INFO_T;



typedef struct vchiq_service_struct {

struct vchiq_service {

	struct vchiq_service_base base;

	VCHIQ_SERVICE_HANDLE_T handle;

	unsigned int ref_count;
@@ -326,11 +326,11 @@ typedef struct vchiq_service_struct { 
		uint64_t bulk_tx_bytes;

		uint64_t bulk_rx_bytes;

	} stats;

} VCHIQ_SERVICE_T;

};



/* The quota information is outside VCHIQ_SERVICE_T so that it can be

	statically allocated, since for accounting reasons a service's slot

	usage is carried over between users of the same port number.

/* The quota information is outside struct vchiq_service so that it can

 * be statically allocated, since for accounting reasons a service's slot

 * usage is carried over between users of the same port number.

 */

struct vchiq_service_quota {

	unsigned short slot_quota;
@@ -496,7 +496,7 @@ struct vchiq_state_struct { 
		int error_count;

	} stats;



	VCHIQ_SERVICE_T * services[VCHIQ_MAX_SERVICES];

	struct vchiq_service *services[VCHIQ_MAX_SERVICES];

	struct vchiq_service_quota service_quotas[VCHIQ_MAX_SERVICES];

	VCHIQ_SLOT_INFO_T slot_info[VCHIQ_MAX_SLOTS];
@@ -529,22 +529,22 @@ vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero); 
extern VCHIQ_STATUS_T

vchiq_connect_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

vchiq_add_service_internal(VCHIQ_STATE_T *state,

	const struct vchiq_service_params *params, int srvstate,

	VCHIQ_INSTANCE_T instance, VCHIQ_USERDATA_TERM_T userdata_term);



extern VCHIQ_STATUS_T

vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id);

vchiq_open_service_internal(struct vchiq_service *service, int client_id);



extern VCHIQ_STATUS_T

vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd);

vchiq_close_service_internal(struct vchiq_service *service, int close_recvd);



extern void

vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service);

vchiq_terminate_service_internal(struct vchiq_service *service);



extern void

vchiq_free_service_internal(VCHIQ_SERVICE_T *service);

vchiq_free_service_internal(struct vchiq_service *service);



extern VCHIQ_STATUS_T

vchiq_shutdown_internal(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance);
@@ -567,7 +567,7 @@ extern void 
vchiq_dump_state(void *dump_context, VCHIQ_STATE_T *state);



extern void

vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service);

vchiq_dump_service_state(void *dump_context, struct vchiq_service *service);



extern void

vchiq_loud_error_header(void);
@@ -576,9 +576,10 @@ extern void 
vchiq_loud_error_footer(void);



extern void

request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type);

request_poll(VCHIQ_STATE_T *state, struct vchiq_service *service,

	     int poll_type);



static inline VCHIQ_SERVICE_T *

static inline struct vchiq_service *

handle_to_service(VCHIQ_SERVICE_HANDLE_T handle)

{

	VCHIQ_STATE_T *state = vchiq_states[(handle / VCHIQ_MAX_SERVICES) &
@@ -589,29 +590,29 @@ handle_to_service(VCHIQ_SERVICE_HANDLE_T handle) 
	return state->services[handle & (VCHIQ_MAX_SERVICES - 1)];

}



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

find_service_by_handle(VCHIQ_SERVICE_HANDLE_T handle);



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

find_service_by_port(VCHIQ_STATE_T *state, int localport);



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

find_service_for_instance(VCHIQ_INSTANCE_T instance,

	VCHIQ_SERVICE_HANDLE_T handle);



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

find_closed_service_for_instance(VCHIQ_INSTANCE_T instance,

	VCHIQ_SERVICE_HANDLE_T handle);



extern VCHIQ_SERVICE_T *

extern struct vchiq_service *

next_service_by_instance(VCHIQ_STATE_T *state, VCHIQ_INSTANCE_T instance,

	int *pidx);



extern void

lock_service(VCHIQ_SERVICE_T *service);

lock_service(struct vchiq_service *service);



extern void

unlock_service(VCHIQ_SERVICE_T *service);

unlock_service(struct vchiq_service *service);



/* The following functions are called from vchiq_core, and external

** implementations must be provided. */
@@ -649,13 +650,13 @@ vchiq_dump_platform_instances(void *dump_context); 


extern void

vchiq_dump_platform_service_state(void *dump_context,

	VCHIQ_SERVICE_T *service);

	struct vchiq_service *service);



extern VCHIQ_STATUS_T

vchiq_use_service_internal(VCHIQ_SERVICE_T *service);

vchiq_use_service_internal(struct vchiq_service *service);



extern VCHIQ_STATUS_T

vchiq_release_service_internal(VCHIQ_SERVICE_T *service);

vchiq_release_service_internal(struct vchiq_service *service);



extern void

vchiq_on_remote_use(VCHIQ_STATE_T *state);
@@ -667,7 +668,7 @@ extern VCHIQ_STATUS_T 
vchiq_platform_init_state(VCHIQ_STATE_T *state);



extern VCHIQ_STATUS_T

vchiq_check_service(VCHIQ_SERVICE_T *service);

vchiq_check_service(struct vchiq_service *service);



extern void

vchiq_on_remote_use_active(VCHIQ_STATE_T *state);