Commit 14780bb1 authored by Adrien Thierry's avatar Adrien Thierry Committed by Greg Kroah-Hartman
Browse files

staging: vchiq_arm: pass vchiq instance to 'find_service_by_handle' 



In order to remove the 'vchiq_states' global array, we need to pass the
vchiq_instance reference to the 'handle_to_service' function, as well as
to all functions that call 'handle_to_service'. This will allow
accessing the vchiq state through the vchiq instance instead of through
the global array.

'handle_to_service' is called by 'find_service_by_handle'. Therefore,
pass the vchiq instance reference to 'find_service_by_handle' and to its
callers.

Tested-by: default avatarStefan Wahren <stefan.wahren@i2se.com>
Signed-off-by: default avatarAdrien Thierry <athierry@redhat.com>
Link: https://lore.kernel.org/r/20220518191126.60396-5-athierry@redhat.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 726e79f8

drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c

+16 −11
Original line number Diff line number Diff line
@@ -25,12 +25,14 @@ MODULE_PARM_DESC(force_bulk, "Force use of vchiq bulk for audio"); 
static void bcm2835_audio_lock(struct bcm2835_audio_instance *instance)

{

	mutex_lock(&instance->vchi_mutex);

	vchiq_use_service(instance->service_handle);

	vchiq_use_service(instance->alsa_stream->chip->vchi_ctx->instance,

			  instance->service_handle);

}



static void bcm2835_audio_unlock(struct bcm2835_audio_instance *instance)

{

	vchiq_release_service(instance->service_handle);

	vchiq_release_service(instance->alsa_stream->chip->vchi_ctx->instance,

			      instance->service_handle);

	mutex_unlock(&instance->vchi_mutex);

}
@@ -44,8 +46,8 @@ static int bcm2835_audio_send_msg_locked(struct bcm2835_audio_instance *instance 
		init_completion(&instance->msg_avail_comp);

	}



	status = vchiq_queue_kernel_message(instance->service_handle,

					    m, sizeof(*m));

	status = vchiq_queue_kernel_message(instance->alsa_stream->chip->vchi_ctx->instance,

					    instance->service_handle, m, sizeof(*m));

	if (status) {

		dev_err(instance->dev,

			"vchi message queue failed: %d, msg=%d\n",
@@ -115,7 +117,7 @@ static enum vchiq_status audio_vchi_callback(struct vchiq_instance *vchiq_instan 
		dev_err(instance->dev, "unexpected callback type=%d\n", m->type);

	}



	vchiq_release_message(handle, header);

	vchiq_release_message(vchiq_instance, instance->service_handle, header);

	return VCHIQ_SUCCESS;

}
@@ -144,7 +146,8 @@ vc_vchi_audio_init(struct vchiq_instance *vchiq_instance, 
	}



	/* Finished with the service for now */

	vchiq_release_service(instance->service_handle);

	vchiq_release_service(instance->alsa_stream->chip->vchi_ctx->instance,

			      instance->service_handle);



	return 0;

}
@@ -154,10 +157,12 @@ static void vc_vchi_audio_deinit(struct bcm2835_audio_instance *instance) 
	int status;



	mutex_lock(&instance->vchi_mutex);

	vchiq_use_service(instance->service_handle);

	vchiq_use_service(instance->alsa_stream->chip->vchi_ctx->instance,

			  instance->service_handle);



	/* Close all VCHI service connections */

	status = vchiq_close_service(instance->service_handle);

	status = vchiq_close_service(instance->alsa_stream->chip->vchi_ctx->instance,

				     instance->service_handle);

	if (status) {

		dev_err(instance->dev,

			"failed to close VCHI service connection (status=%d)\n",
@@ -227,7 +232,7 @@ int bcm2835_audio_open(struct bcm2835_alsa_stream *alsa_stream) 
		goto deinit;



	bcm2835_audio_lock(instance);

	vchiq_get_peer_version(instance->service_handle,

	vchiq_get_peer_version(vchi_ctx->instance, instance->service_handle,

			       &instance->peer_version);

	bcm2835_audio_unlock(instance);

	if (instance->peer_version < 2 || force_bulk)
@@ -352,8 +357,8 @@ int bcm2835_audio_write(struct bcm2835_alsa_stream *alsa_stream, 
		while (count > 0) {

			int bytes = min(instance->max_packet, count);



			status = vchiq_queue_kernel_message(instance->service_handle,

							    src, bytes);

			status = vchiq_queue_kernel_message(vchiq_instance,

							    instance->service_handle, src, bytes);

			src += bytes;

			count -= bytes;

		}

drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h

+15 −11
Original line number Diff line number Diff line
@@ -92,14 +92,17 @@ extern enum vchiq_status vchiq_connect(struct vchiq_instance *instance); 
extern enum vchiq_status vchiq_open_service(struct vchiq_instance *instance,

	const struct vchiq_service_params_kernel *params,

	unsigned int *pservice);

extern enum vchiq_status vchiq_close_service(unsigned int service);

extern enum vchiq_status vchiq_use_service(unsigned int service);

extern enum vchiq_status vchiq_release_service(unsigned int service);

extern void vchiq_msg_queue_push(unsigned int handle, struct vchiq_header *header);

extern void           vchiq_release_message(unsigned int service,

extern enum vchiq_status vchiq_close_service(struct vchiq_instance *instance,

					     unsigned int service);

extern enum vchiq_status vchiq_use_service(struct vchiq_instance *instance, unsigned int service);

extern enum vchiq_status vchiq_release_service(struct vchiq_instance *instance,

					       unsigned int service);

extern void vchiq_msg_queue_push(struct vchiq_instance *instance, unsigned int handle,

				 struct vchiq_header *header);

extern int vchiq_queue_kernel_message(unsigned int handle, void *data,

				      unsigned int size);

extern void vchiq_release_message(struct vchiq_instance *instance, unsigned int service,

				  struct vchiq_header *header);

extern int vchiq_queue_kernel_message(struct vchiq_instance *instance, unsigned int handle,

				      void *data, unsigned int size);

extern enum vchiq_status vchiq_bulk_transmit(struct vchiq_instance *instance, unsigned int service,

					     const void *data, unsigned int size, void *userdata,

					     enum vchiq_bulk_mode mode);
@@ -107,8 +110,9 @@ extern enum vchiq_status vchiq_bulk_receive(struct vchiq_instance *instance, uns 
					    void *data, unsigned int size, void *userdata,

					    enum vchiq_bulk_mode mode);

extern void *vchiq_get_service_userdata(unsigned int service);

extern enum vchiq_status vchiq_get_peer_version(unsigned int handle,

extern enum vchiq_status vchiq_get_peer_version(struct vchiq_instance *instance,

						unsigned int handle,

						short *peer_version);

extern struct vchiq_header *vchiq_msg_hold(unsigned int handle);

extern struct vchiq_header *vchiq_msg_hold(struct vchiq_instance *instance, unsigned int handle);



#endif /* VCHIQ_H */

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

+8 −8
Original line number Diff line number Diff line
@@ -819,7 +819,7 @@ vchiq_open_service(struct vchiq_instance *instance, 
		*phandle = service->handle;

		status = vchiq_open_service_internal(service, current->pid);

		if (status != VCHIQ_SUCCESS) {

			vchiq_remove_service(service->handle);

			vchiq_remove_service(instance, service->handle);

			*phandle = VCHIQ_SERVICE_HANDLE_INVALID;

		}

	}
@@ -914,7 +914,7 @@ vchiq_blocking_bulk_transfer(struct vchiq_instance *instance, unsigned int handl 
	enum vchiq_status status;

	struct bulk_waiter_node *waiter = NULL, *iter;



	service = find_service_by_handle(handle);

	service = find_service_by_handle(instance, handle);

	if (!service)

		return VCHIQ_ERROR;
@@ -1381,14 +1381,14 @@ vchiq_keepalive_thread_func(void *v) 
		 */

		while (uc--) {

			atomic_inc(&arm_state->ka_use_ack_count);

			status = vchiq_use_service(ka_handle);

			status = vchiq_use_service(instance, ka_handle);

			if (status != VCHIQ_SUCCESS) {

				vchiq_log_error(vchiq_susp_log_level,

						"%s vchiq_use_service error %d", __func__, status);

			}

		}

		while (rc--) {

			status = vchiq_release_service(ka_handle);

			status = vchiq_release_service(instance, ka_handle);

			if (status != VCHIQ_SUCCESS) {

				vchiq_log_error(vchiq_susp_log_level,

						"%s vchiq_release_service error %d", __func__,
@@ -1584,10 +1584,10 @@ vchiq_instance_set_trace(struct vchiq_instance *instance, int trace) 
}



enum vchiq_status

vchiq_use_service(unsigned int handle)

vchiq_use_service(struct vchiq_instance *instance, unsigned int handle)

{

	enum vchiq_status ret = VCHIQ_ERROR;

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);



	if (service) {

		ret = vchiq_use_internal(service->state, service, USE_TYPE_SERVICE);
@@ -1598,10 +1598,10 @@ vchiq_use_service(unsigned int handle) 
EXPORT_SYMBOL(vchiq_use_service);



enum vchiq_status

vchiq_release_service(unsigned int handle)

vchiq_release_service(struct vchiq_instance *instance, unsigned int handle)

{

	enum vchiq_status ret = VCHIQ_ERROR;

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);



	if (service) {

		ret = vchiq_release_internal(service->state, service);

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

+2 −2
Original line number Diff line number Diff line
@@ -86,10 +86,10 @@ extern struct vchiq_state * 
vchiq_get_state(void);



enum vchiq_status

vchiq_use_service(unsigned int handle);

vchiq_use_service(struct vchiq_instance *instance, unsigned int handle);



extern enum vchiq_status

vchiq_release_service(unsigned int handle);

vchiq_release_service(struct vchiq_instance *instance, unsigned int handle);



extern enum vchiq_status

vchiq_check_service(struct vchiq_service *service);

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

+25 −22
Original line number Diff line number Diff line
@@ -235,7 +235,7 @@ set_service_state(struct vchiq_service *service, int newstate) 
}



struct vchiq_service *

find_service_by_handle(unsigned int handle)

find_service_by_handle(struct vchiq_instance *instance, unsigned int handle)

{

	struct vchiq_service *service;
@@ -476,7 +476,7 @@ make_service_callback(struct vchiq_service *service, enum vchiq_reason reason, 
	}



	if (reason != VCHIQ_MESSAGE_AVAILABLE)

		vchiq_release_message(service->handle, header);

		vchiq_release_message(service->instance, service->handle, header);



	return status;

}
@@ -2290,9 +2290,10 @@ vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero, s 
	return ret;

}



void vchiq_msg_queue_push(unsigned int handle, struct vchiq_header *header)

void vchiq_msg_queue_push(struct vchiq_instance *instance, unsigned int handle,

			  struct vchiq_header *header)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	int pos;



	if (!service)
@@ -2312,9 +2313,9 @@ void vchiq_msg_queue_push(unsigned int handle, struct vchiq_header *header) 
}

EXPORT_SYMBOL(vchiq_msg_queue_push);



struct vchiq_header *vchiq_msg_hold(unsigned int handle)

struct vchiq_header *vchiq_msg_hold(struct vchiq_instance *instance, unsigned int handle)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	struct vchiq_header *header;

	int pos;
@@ -2869,16 +2870,16 @@ vchiq_shutdown_internal(struct vchiq_state *state, struct vchiq_instance *instan 
	/* Find all services registered to this client and remove them. */

	i = 0;

	while ((service = next_service_by_instance(state, instance, &i)) != NULL) {

		(void)vchiq_remove_service(service->handle);

		(void)vchiq_remove_service(instance, service->handle);

		vchiq_service_put(service);

	}

}



enum vchiq_status

vchiq_close_service(unsigned int handle)

vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)

{

	/* Unregister the service */

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	enum vchiq_status status = VCHIQ_SUCCESS;



	if (!service)
@@ -2933,10 +2934,10 @@ vchiq_close_service(unsigned int handle) 
EXPORT_SYMBOL(vchiq_close_service);



enum vchiq_status

vchiq_remove_service(unsigned int handle)

vchiq_remove_service(struct vchiq_instance *instance, unsigned int handle)

{

	/* Unregister the service */

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	enum vchiq_status status = VCHIQ_SUCCESS;



	if (!service)
@@ -3003,7 +3004,7 @@ enum vchiq_status vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned 
				      void *offset, void __user *uoffset, int size, void *userdata,

				      enum vchiq_bulk_mode mode, enum vchiq_bulk_dir dir)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	struct vchiq_bulk_queue *queue;

	struct vchiq_bulk *bulk;

	struct vchiq_state *state;
@@ -3153,13 +3154,13 @@ enum vchiq_status vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned 
}



enum vchiq_status

vchiq_queue_message(unsigned int handle,

vchiq_queue_message(struct vchiq_instance *instance, unsigned int handle,

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

					     size_t offset, size_t maxsize),

		    void *context,

		    size_t size)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	enum vchiq_status status = VCHIQ_ERROR;

	int data_id;
@@ -3202,12 +3203,13 @@ vchiq_queue_message(unsigned int handle, 
	return status;

}



int vchiq_queue_kernel_message(unsigned int handle, void *data, unsigned int size)

int vchiq_queue_kernel_message(struct vchiq_instance *instance, unsigned int handle, void *data,

			       unsigned int size)

{

	enum vchiq_status status;



	while (1) {

		status = vchiq_queue_message(handle, memcpy_copy_callback,

		status = vchiq_queue_message(instance, handle, memcpy_copy_callback,

					     data, size);



		/*
@@ -3226,10 +3228,10 @@ int vchiq_queue_kernel_message(unsigned int handle, void *data, unsigned int siz 
EXPORT_SYMBOL(vchiq_queue_kernel_message);



void

vchiq_release_message(unsigned int handle,

vchiq_release_message(struct vchiq_instance *instance, unsigned int handle,

		      struct vchiq_header *header)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	struct vchiq_shared_state *remote;

	struct vchiq_state *state;

	int slot_index;
@@ -3268,10 +3270,10 @@ release_message_sync(struct vchiq_state *state, struct vchiq_header *header) 
}



enum vchiq_status

vchiq_get_peer_version(unsigned int handle, short *peer_version)

vchiq_get_peer_version(struct vchiq_instance *instance, unsigned int handle, short *peer_version)

{

	enum vchiq_status status = VCHIQ_ERROR;

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);



	if (!service)

		goto exit;
@@ -3303,9 +3305,10 @@ void vchiq_get_config(struct vchiq_config *config) 
}



int

vchiq_set_service_option(unsigned int handle, enum vchiq_service_option option, int value)

vchiq_set_service_option(struct vchiq_instance *instance, unsigned int handle,

			 enum vchiq_service_option option, int value)

{

	struct vchiq_service *service = find_service_by_handle(handle);

	struct vchiq_service *service = find_service_by_handle(instance, handle);

	struct vchiq_service_quota *quota;

	int ret = -EINVAL;