Commit 3a8895a9 authored by Nicolas Saenz Julienne's avatar Nicolas Saenz Julienne Committed by Greg Kroah-Hartman
Browse files

staging: vchi: Get rid of struct vchi_service 



The structure only contains a single parameter, which is the underlying
vchiq handle. Get rid of the struct and directly pass the handle around.

Signed-off-by: default avatarNicolas Saenz Julienne <nsaenzjulienne@suse.de>
Link: https://lore.kernel.org/r/20200629150945.10720-32-nsaenzjulienne@suse.de


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

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

+12 −11
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ 


struct bcm2835_audio_instance {

	struct device *dev;

	struct vchi_service *service;

	unsigned service_handle;

	struct completion msg_avail_comp;

	struct mutex vchi_mutex;

	struct bcm2835_alsa_stream *alsa_stream;
@@ -25,12 +25,12 @@ 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);

	vchi_service_use(instance->service);

	vchi_service_use(instance->service_handle);

}



static void bcm2835_audio_unlock(struct bcm2835_audio_instance *instance)

{

	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);

	mutex_unlock(&instance->vchi_mutex);

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

	}



	status = vchi_queue_kernel_message(instance->service,

	status = vchi_queue_kernel_message(instance->service_handle,

					   m, sizeof(*m));

	if (status) {

		dev_err(instance->dev,
@@ -133,7 +133,7 @@ vc_vchi_audio_init(struct vchiq_instance *vchiq_instance, 


	/* Open the VCHI service connections */

	status = vchi_service_open(vchiq_instance, &params,

				   &instance->service);

				   &instance->service_handle);



	if (status) {

		dev_err(instance->dev,
@@ -143,7 +143,7 @@ vc_vchi_audio_init(struct vchiq_instance *vchiq_instance, 
	}



	/* Finished with the service for now */

	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);



	return 0;

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



	mutex_lock(&instance->vchi_mutex);

	vchi_service_use(instance->service);

	vchi_service_use(instance->service_handle);



	/* Close all VCHI service connections */

	status = vchi_service_close(instance->service);

	status = vchi_service_close(instance->service_handle);

	if (status) {

		dev_err(instance->dev,

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



	bcm2835_audio_lock(instance);

	vchi_get_peer_version(instance->service, &instance->peer_version);

	vchi_get_peer_version(instance->service_handle,

			      &instance->peer_version);

	bcm2835_audio_unlock(instance);

	if (instance->peer_version < 2 || force_bulk)

		instance->max_packet = 0; /* bulk transfer */
@@ -342,7 +343,7 @@ int bcm2835_audio_write(struct bcm2835_alsa_stream *alsa_stream, 
	count = size;

	if (!instance->max_packet) {

		/* Send the message to the videocore */

		status = vchi_bulk_queue_transmit(instance->service,

		status = vchi_bulk_queue_transmit(instance->service_handle,

						  src, count,

						  VCHIQ_BULK_MODE_BLOCKING,

						  NULL);
@@ -350,7 +351,7 @@ int bcm2835_audio_write(struct bcm2835_alsa_stream *alsa_stream, 
		while (count > 0) {

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



			status = vchi_queue_kernel_message(instance->service,

			status = vchi_queue_kernel_message(instance->service_handle,

							   src, bytes);

			src += bytes;

			count -= bytes;

drivers/staging/vc04_services/interface/vchi/vchi.h

+10 −15
Original line number Diff line number Diff line
@@ -21,10 +21,6 @@ struct vchi_held_msg { 
	void *message;

};



struct vchi_service {

	unsigned int handle;

};



// Opaque handle for a VCHIQ instance

struct vchiq_instance;
@@ -46,24 +42,23 @@ extern int32_t vchi_disconnect(struct vchiq_instance *instance); 
 * Global service API

 *****************************************************************************/

// Routine to open a named service

extern int32_t vchi_service_open(struct vchiq_instance *instance,

				 struct vchiq_service_params *setup,

				 struct vchi_service **service);

extern int vchi_service_open(struct vchiq_instance *instance,

			    struct vchiq_service_params *params,

			    unsigned *handle);



extern int32_t vchi_get_peer_version(struct vchi_service *service,

				     short *peer_version);

extern int32_t vchi_get_peer_version(unsigned handle, short *peer_version);



// Routine to close a named service

extern int32_t vchi_service_close(struct vchi_service *service);

extern int32_t vchi_service_close(unsigned handle);



// Routine to increment ref count on a named service

extern int32_t vchi_service_use(struct vchi_service *service);

extern int32_t vchi_service_use(unsigned handle);



// Routine to decrement ref count on a named service

extern int32_t vchi_service_release(struct vchi_service *service);

extern int32_t vchi_service_release(unsigned handle);



/* Routine to send a message from kernel memory across a service */

extern int vchi_queue_kernel_message(struct vchi_service *service, void *data,

extern int vchi_queue_kernel_message(unsigned handle, void *data,

				     unsigned int size);



// Routine to look at a message in place.
@@ -87,14 +82,14 @@ extern int32_t vchi_held_msg_release(struct vchi_held_msg *message); 
 *****************************************************************************/



// Routine to prepare interface for a transfer from the other side

extern int32_t vchi_bulk_queue_receive(struct vchi_service *service,

extern int32_t vchi_bulk_queue_receive(unsigned handle,

				       void *data_dst,

				       uint32_t data_size,

				       enum vchiq_bulk_mode mode,

				       void *transfer_handle);



// Routine to queue up data ready for transfer to the other (once they have signalled they are ready)

extern int32_t vchi_bulk_queue_transmit(struct vchi_service *service,

extern int32_t vchi_bulk_queue_transmit(unsigned handle,

					const void *data_src,

					uint32_t data_size,

				        enum vchiq_bulk_mode mode,

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

+23 −76
Original line number Diff line number Diff line
@@ -10,14 +10,12 @@ 
#include "vchiq.h"

#include "vchiq_core.h"



int vchi_queue_kernel_message(struct vchi_service *service, void *data,

			      unsigned int size)

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

{

	enum vchiq_status status;



	while (1) {

		status = vchiq_queue_kernel_message(service->handle, data,

						    size);

		status = vchiq_queue_kernel_message(handle, data, size);



		/*

		 * vchiq_queue_message() may return VCHIQ_RETRY, so we need to
@@ -48,15 +46,15 @@ EXPORT_SYMBOL(vchi_queue_kernel_message); 
 * Returns: int32_t - success == 0

 *

 ***********************************************************/

int32_t vchi_bulk_queue_receive(struct vchi_service *service, void *data_dst,

int32_t vchi_bulk_queue_receive(unsigned handle, void *data_dst,

				uint32_t data_size, enum vchiq_bulk_mode mode,

				void *bulk_handle)

{

	enum vchiq_status status;



	while (1) {

		status = vchiq_bulk_receive(service->handle, data_dst,

			data_size, bulk_handle, mode);

		status = vchiq_bulk_receive(handle, data_dst, data_size,

					    bulk_handle, mode);

		/*

		 * vchiq_bulk_receive() may return VCHIQ_RETRY, so we need to

		 * implement a retry mechanism since this function is supposed
@@ -86,17 +84,15 @@ EXPORT_SYMBOL(vchi_bulk_queue_receive); 
 * Returns: int32_t - success == 0

 *

 ***********************************************************/

int32_t vchi_bulk_queue_transmit(struct vchi_service *service,

				 const void *data_src,

				 uint32_t data_size,

				 enum vchiq_bulk_mode mode,

int32_t vchi_bulk_queue_transmit(unsigned handle, const void *data_src,

				 uint32_t data_size, enum vchiq_bulk_mode mode,

				 void *bulk_handle)

{

	enum vchiq_status status;



	while (1) {

		status = vchiq_bulk_transmit(service->handle, data_src,

			data_size, bulk_handle, mode);

		status = vchiq_bulk_transmit(handle, data_src, data_size,

					     bulk_handle, mode);



		/*

		 * vchiq_bulk_transmit() may return VCHIQ_RETRY, so we need to
@@ -245,7 +241,7 @@ EXPORT_SYMBOL(vchi_disconnect); 
 *

 * Arguments: struct vchiq_instance *instance

 *            struct service_creation *setup,

 *            struct vchi_service **service

 *            unsigned *handle

 *

 * Description: Routine to open a service

 *
@@ -253,103 +249,54 @@ EXPORT_SYMBOL(vchi_disconnect); 
 *

 ***********************************************************/



static struct vchi_service *service_alloc(void)

{

	return kzalloc(sizeof(struct vchi_service), GFP_KERNEL);

}



static void service_free(struct vchi_service *service)

{

	if (service)

		kfree(service);

}



int32_t vchi_service_open(struct vchiq_instance *instance,

		      struct vchiq_service_params *params,

	struct vchi_service **service)

		      unsigned *handle)

{



	*service = service_alloc();

	if (*service) {

		enum vchiq_status status;



		status = vchiq_open_service(instance, params,

			&((*service)->handle));

		if (status != VCHIQ_SUCCESS) {

			service_free(*service);

			*service = NULL;

		}

	}



	return *service ? 0 : -1;

	return vchiq_open_service(instance, params, handle);

}

EXPORT_SYMBOL(vchi_service_open);



int32_t vchi_service_close(struct vchi_service *service)

int32_t vchi_service_close(unsigned handle)

{

	int32_t ret = -1;



	if (service) {

		enum vchiq_status status = vchiq_close_service(service->handle);

		if (status == VCHIQ_SUCCESS)

			service_free(service);



		ret = status;

	}

	return ret;

	return vchiq_close_service(handle);

}

EXPORT_SYMBOL(vchi_service_close);



int32_t vchi_get_peer_version(struct vchi_service *service, short *peer_version)

int32_t vchi_get_peer_version(unsigned handle, short *peer_version)

{

	int32_t ret = -1;



	if (service) {

		enum vchiq_status status;



		status = vchiq_get_peer_version(service->handle, peer_version);

		ret = status;

	}

	return ret;

	return vchiq_get_peer_version(handle, peer_version);

}

EXPORT_SYMBOL(vchi_get_peer_version);



/***********************************************************

 * Name: vchi_service_use

 *

 * Arguments: struct vchi_service *service

 * Arguments: unsigned handle

 *

 * Description: Routine to increment refcount on a service

 *

 * Returns: void

 *

 ***********************************************************/

int32_t vchi_service_use(struct vchi_service *service)

int32_t vchi_service_use(unsigned handle)

{

	int32_t ret = -1;



	if (service)

		ret = vchiq_use_service(service->handle);

	return ret;

	return vchiq_use_service(handle);

}

EXPORT_SYMBOL(vchi_service_use);



/***********************************************************

 * Name: vchi_service_release

 *

 * Arguments: struct vchi_service *service

 * Arguments: unsigned handle

 *

 * Description: Routine to decrement refcount on a service

 *

 * Returns: void

 *

 ***********************************************************/

int32_t vchi_service_release(struct vchi_service *service)

int32_t vchi_service_release(unsigned handle)

{

	int32_t ret = -1;



	if (service)

		ret = vchiq_release_service(service->handle);

	return ret;

	return vchiq_release_service(handle);

}

EXPORT_SYMBOL(vchi_service_release);

drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c

+28 −27
Original line number Diff line number Diff line
@@ -165,7 +165,7 @@ struct mmal_msg_context { 
};



struct vchiq_mmal_instance {

	struct vchi_service *service;

	unsigned service_handle;



	/* ensure serialised access to service */

	struct mutex vchiq_mutex;
@@ -294,8 +294,8 @@ static void buffer_to_host_work_cb(struct work_struct *work) 
		/* Dummy receive to ensure the buffers remain in order */

		len = 8;

	/* queue the bulk submission */

	vchi_service_use(instance->service);

	ret = vchi_bulk_queue_receive(instance->service,

	vchi_service_use(instance->service_handle);

	ret = vchi_bulk_queue_receive(instance->service_handle,

				      msg_context->u.bulk.buffer->buffer,

				      /* Actual receive needs to be a multiple

				       * of 4 bytes
@@ -304,7 +304,7 @@ static void buffer_to_host_work_cb(struct work_struct *work) 
				      VCHIQ_BULK_MODE_CALLBACK,

				      msg_context);



	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);



	if (ret != 0)

		pr_err("%s: ctx: %p, vchi_bulk_queue_receive failed %d\n",
@@ -383,7 +383,7 @@ buffer_from_host(struct vchiq_mmal_instance *instance, 
	if (!port->enabled)

		return -EINVAL;



	pr_debug("instance:%p buffer:%p\n", instance->service, buf);

	pr_debug("instance:%u buffer:%p\n", instance->service_handle, buf);



	/* get context */

	if (!buf->msg_context) {
@@ -438,14 +438,14 @@ buffer_from_host(struct vchiq_mmal_instance *instance, 
	/* no payload in message */

	m.u.buffer_from_host.payload_in_message = 0;



	vchi_service_use(instance->service);

	vchi_service_use(instance->service_handle);



	ret = vchi_queue_kernel_message(instance->service,

	ret = vchi_queue_kernel_message(instance->service_handle,

					&m,

					sizeof(struct mmal_msg_header) +

					sizeof(m.u.buffer_from_host));



	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);



	return ret;

}
@@ -679,14 +679,14 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance, 
	DBG_DUMP_MSG(msg, (sizeof(struct mmal_msg_header) + payload_len),

		     ">>> sync message");



	vchi_service_use(instance->service);

	vchi_service_use(instance->service_handle);



	ret = vchi_queue_kernel_message(instance->service,

	ret = vchi_queue_kernel_message(instance->service_handle,

					msg,

					sizeof(struct mmal_msg_header) +

					payload_len);



	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);



	if (ret) {

		pr_err("error %d queuing message\n", ret);
@@ -826,7 +826,7 @@ static int port_info_set(struct vchiq_mmal_instance *instance, 
		 port->component->handle, port->handle);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -921,7 +921,7 @@ release_msg: 
	pr_debug("%s:result:%d component:0x%x port:%d\n",

		 __func__, ret, port->component->handle, port->handle);



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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -969,7 +969,7 @@ static int create_component(struct vchiq_mmal_instance *instance, 
		 component->inputs, component->outputs, component->clocks);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1002,7 +1002,7 @@ static int destroy_component(struct vchiq_mmal_instance *instance, 


release_msg:



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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1034,7 +1034,7 @@ static int enable_component(struct vchiq_mmal_instance *instance, 
	ret = -rmsg->u.component_enable_reply.status;



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1067,7 +1067,7 @@ static int disable_component(struct vchiq_mmal_instance *instance, 


release_msg:



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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1099,7 +1099,7 @@ static int get_version(struct vchiq_mmal_instance *instance, 
	*minor_out = rmsg->u.version.minor;



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1141,7 +1141,7 @@ static int port_action_port(struct vchiq_mmal_instance *instance, 
		 port_action_type_names[action_type], action_type);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1189,7 +1189,7 @@ static int port_action_handle(struct vchiq_mmal_instance *instance, 
		 action_type, connect_component_handle, connect_port_handle);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1230,7 +1230,7 @@ static int port_parameter_set(struct vchiq_mmal_instance *instance, 
		 ret, port->component->handle, port->handle, parameter_id);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1289,7 +1289,7 @@ static int port_parameter_get(struct vchiq_mmal_instance *instance, 
		 ret, port->component->handle, port->handle, parameter_id);



release_msg:

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

	vchiq_release_message(instance->service_handle, rmsg_handle);



	return ret;

}
@@ -1834,9 +1834,9 @@ int vchiq_mmal_finalise(struct vchiq_mmal_instance *instance) 
	if (mutex_lock_interruptible(&instance->vchiq_mutex))

		return -EINTR;



	vchi_service_use(instance->service);

	vchi_service_use(instance->service_handle);



	status = vchi_service_close(instance->service);

	status = vchi_service_close(instance->service_handle);

	if (status != 0)

		pr_err("mmal-vchiq: VCHIQ close failed\n");
@@ -1914,21 +1914,22 @@ int vchiq_mmal_init(struct vchiq_mmal_instance **out_instance) 
	if (!instance->bulk_wq)

		goto err_free;



	status = vchi_service_open(vchiq_instance, &params, &instance->service);

	status = vchi_service_open(vchiq_instance, &params,

				   &instance->service_handle);

	if (status) {

		pr_err("Failed to open VCHI service connection (status=%d)\n",

		       status);

		goto err_close_services;

	}



	vchi_service_release(instance->service);

	vchi_service_release(instance->service_handle);



	*out_instance = instance;



	return 0;



err_close_services:

	vchi_service_close(instance->service);

	vchi_service_close(instance->service_handle);

	destroy_workqueue(instance->bulk_wq);

err_free:

	vfree(instance->bulk_scratch);

CRA Git | Maintained and supported by SUSTech CRA and CCSE