redonkable/alistair23-linux
redonkable/alistair23-linux
1
0
Fork 0
Code Releases Activity

staging: vchi: Get rid of struct vchi_service

Browse source 
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: Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
Link: https://lore.kernel.org/r/20200629150945.10720-32-nsaenzjulienne@suse.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Nicolas Saenz Julienne 2020-06-29 17:09:29 +02:00 committed by Greg Kroah-Hartman
parent 65c7536672
commit 3a8895a921
4 changed files with 73 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c
View file

@ -9,7 +9,7 @@
struct bcm2835_audio_instance { struct bcm2835_audio_instance {
struct device *dev; struct device *dev;
struct vchi_service *service; unsigned service_handle;
struct completion msg_avail_comp; struct completion msg_avail_comp;
struct mutex vchi_mutex; struct mutex vchi_mutex;
struct bcm2835_alsa_stream *alsa_stream; 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) static void bcm2835_audio_lock(struct bcm2835_audio_instance *instance)
{ {
mutex_lock(&instance->vchi_mutex); 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) 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); 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); init_completion(&instance->msg_avail_comp);
} }
status = vchi_queue_kernel_message(instance->service, status = vchi_queue_kernel_message(instance->service_handle,
m, sizeof(*m)); m, sizeof(*m));
if (status) { if (status) {
dev_err(instance->dev, dev_err(instance->dev,
@ -133,7 +133,7 @@ vc_vchi_audio_init(struct vchiq_instance *vchiq_instance,
/* Open the VCHI service connections */ /* Open the VCHI service connections */
status = vchi_service_open(vchiq_instance, &params, status = vchi_service_open(vchiq_instance, &params,
&instance->service); &instance->service_handle);
if (status) { if (status) {
dev_err(instance->dev, dev_err(instance->dev,
@ -143,7 +143,7 @@ vc_vchi_audio_init(struct vchiq_instance *vchiq_instance,
} }
/* Finished with the service for now */ /* Finished with the service for now */
vchi_service_release(instance->service); vchi_service_release(instance->service_handle);
return 0; return 0;
} }
@ -153,10 +153,10 @@ static void vc_vchi_audio_deinit(struct bcm2835_audio_instance *instance)
int status; int status;
mutex_lock(&instance->vchi_mutex); mutex_lock(&instance->vchi_mutex);
vchi_service_use(instance->service); vchi_service_use(instance->service_handle);
/* Close all VCHI service connections */ /* Close all VCHI service connections */
status = vchi_service_close(instance->service); status = vchi_service_close(instance->service_handle);
if (status) { if (status) {
dev_err(instance->dev, dev_err(instance->dev,
"failed to close VCHI service connection (status=%d)\n", "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; goto deinit;
bcm2835_audio_lock(instance); 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); bcm2835_audio_unlock(instance);
if (instance->peer_version < 2 || force_bulk) if (instance->peer_version < 2 || force_bulk)
instance->max_packet = 0; /* bulk transfer */ instance->max_packet = 0; /* bulk transfer */
@ -342,7 +343,7 @@ int bcm2835_audio_write(struct bcm2835_alsa_stream *alsa_stream,
count = size; count = size;
if (!instance->max_packet) { if (!instance->max_packet) {
/* Send the message to the videocore */ /* Send the message to the videocore */
status = vchi_bulk_queue_transmit(instance->service, status = vchi_bulk_queue_transmit(instance->service_handle,
src, count, src, count,
VCHIQ_BULK_MODE_BLOCKING, VCHIQ_BULK_MODE_BLOCKING,
NULL); NULL);
@ -350,7 +351,7 @@ int bcm2835_audio_write(struct bcm2835_alsa_stream *alsa_stream,
while (count > 0) { while (count > 0) {
int bytes = min(instance->max_packet, count); 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);
src += bytes; src += bytes;
count -= bytes; count -= bytes;

25
drivers/staging/vc04_services/interface/vchi/vchi.h
View file

@ -21,10 +21,6 @@ struct vchi_held_msg {
void *message; void *message;
}; };
struct vchi_service {
unsigned int handle;
};
// Opaque handle for a VCHIQ instance // Opaque handle for a VCHIQ instance
struct vchiq_instance; struct vchiq_instance;
@ -46,24 +42,23 @@ extern int32_t vchi_disconnect(struct vchiq_instance *instance);
* Global service API * Global service API
*****************************************************************************/ *****************************************************************************/
// Routine to open a named service // Routine to open a named service
extern int32_t vchi_service_open(struct vchiq_instance *instance, extern int vchi_service_open(struct vchiq_instance *instance,
struct vchiq_service_params *setup, struct vchiq_service_params *params,
struct vchi_service **service); unsigned *handle);
extern int32_t vchi_get_peer_version(struct vchi_service *service, extern int32_t vchi_get_peer_version(unsigned handle, short *peer_version);
short *peer_version);
// Routine to close a named service // 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 // 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 // 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 */ /* 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); unsigned int size);
// Routine to look at a message in place. // 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 // 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, void *data_dst,
uint32_t data_size, uint32_t data_size,
enum vchiq_bulk_mode mode, enum vchiq_bulk_mode mode,
void *transfer_handle); void *transfer_handle);
// Routine to queue up data ready for transfer to the other (once they have signalled they are ready) // 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, const void *data_src,
uint32_t data_size, uint32_t data_size,
enum vchiq_bulk_mode mode, enum vchiq_bulk_mode mode,

97
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
View file

@ -10,14 +10,12 @@
#include "vchiq.h" #include "vchiq.h"
#include "vchiq_core.h" #include "vchiq_core.h"
int vchi_queue_kernel_message(struct vchi_service *service, void *data, int vchi_queue_kernel_message(unsigned handle, void *data, unsigned int size)
unsigned int size)
{ {
enum vchiq_status status; enum vchiq_status status;
while (1) { while (1) {
status = vchiq_queue_kernel_message(service->handle, data, status = vchiq_queue_kernel_message(handle, data, size);
size);
/* /*
* vchiq_queue_message() may return VCHIQ_RETRY, so we need to * 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 * 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, uint32_t data_size, enum vchiq_bulk_mode mode,
void *bulk_handle) void *bulk_handle)
{ {
enum vchiq_status status; enum vchiq_status status;
while (1) { while (1) {
status = vchiq_bulk_receive(service->handle, data_dst, status = vchiq_bulk_receive(handle, data_dst, data_size,
data_size, bulk_handle, mode); bulk_handle, mode);
/* /*
* vchiq_bulk_receive() may return VCHIQ_RETRY, so we need to * vchiq_bulk_receive() may return VCHIQ_RETRY, so we need to
* implement a retry mechanism since this function is supposed * implement a retry mechanism since this function is supposed
@ -86,17 +84,15 @@ EXPORT_SYMBOL(vchi_bulk_queue_receive);
* Returns: int32_t - success == 0 * Returns: int32_t - success == 0
* *
***********************************************************/ ***********************************************************/
int32_t vchi_bulk_queue_transmit(struct vchi_service *service, int32_t vchi_bulk_queue_transmit(unsigned handle, const void *data_src,
const void *data_src, uint32_t data_size, enum vchiq_bulk_mode mode,
uint32_t data_size,
enum vchiq_bulk_mode mode,
void *bulk_handle) void *bulk_handle)
{ {
enum vchiq_status status; enum vchiq_status status;
while (1) { while (1) {
status = vchiq_bulk_transmit(service->handle, data_src, status = vchiq_bulk_transmit(handle, data_src, data_size,
data_size, bulk_handle, mode); bulk_handle, mode);
/* /*
* vchiq_bulk_transmit() may return VCHIQ_RETRY, so we need to * vchiq_bulk_transmit() may return VCHIQ_RETRY, so we need to
@ -245,7 +241,7 @@ EXPORT_SYMBOL(vchi_disconnect);
* *
* Arguments: struct vchiq_instance *instance * Arguments: struct vchiq_instance *instance
* struct service_creation *setup, * struct service_creation *setup,
* struct vchi_service **service * unsigned *handle
* *
* Description: Routine to open a service * 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, int32_t vchi_service_open(struct vchiq_instance *instance,
struct vchiq_service_params *params, struct vchiq_service_params *params,
struct vchi_service **service) unsigned *handle)
{ {
return vchiq_open_service(instance, params, 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;
} }
EXPORT_SYMBOL(vchi_service_open); 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; return vchiq_close_service(handle);
if (service) {
enum vchiq_status status = vchiq_close_service(service->handle);
if (status == VCHIQ_SUCCESS)
service_free(service);
ret = status;
}
return ret;
} }
EXPORT_SYMBOL(vchi_service_close); 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; return vchiq_get_peer_version(handle, peer_version);
if (service) {
enum vchiq_status status;
status = vchiq_get_peer_version(service->handle, peer_version);
ret = status;
}
return ret;
} }
EXPORT_SYMBOL(vchi_get_peer_version); EXPORT_SYMBOL(vchi_get_peer_version);
/*********************************************************** /***********************************************************
* Name: vchi_service_use * Name: vchi_service_use
* *
* Arguments: struct vchi_service *service * Arguments: unsigned handle
* *
* Description: Routine to increment refcount on a service * Description: Routine to increment refcount on a service
* *
* Returns: void * Returns: void
* *
***********************************************************/ ***********************************************************/
int32_t vchi_service_use(struct vchi_service *service) int32_t vchi_service_use(unsigned handle)
{ {
int32_t ret = -1; return vchiq_use_service(handle);
if (service)
ret = vchiq_use_service(service->handle);
return ret;
} }
EXPORT_SYMBOL(vchi_service_use); EXPORT_SYMBOL(vchi_service_use);
/*********************************************************** /***********************************************************
* Name: vchi_service_release * Name: vchi_service_release
* *
* Arguments: struct vchi_service *service * Arguments: unsigned handle
* *
* Description: Routine to decrement refcount on a service * Description: Routine to decrement refcount on a service
* *
* Returns: void * Returns: void
* *
***********************************************************/ ***********************************************************/
int32_t vchi_service_release(struct vchi_service *service) int32_t vchi_service_release(unsigned handle)
{ {
int32_t ret = -1; return vchiq_release_service(handle);
if (service)
ret = vchiq_release_service(service->handle);
return ret;
} }
EXPORT_SYMBOL(vchi_service_release); EXPORT_SYMBOL(vchi_service_release);

55
drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c
View file

@ -165,7 +165,7 @@ struct mmal_msg_context {
}; };
struct vchiq_mmal_instance { struct vchiq_mmal_instance {
struct vchi_service *service; unsigned service_handle;
/* ensure serialised access to service */ /* ensure serialised access to service */
struct mutex vchiq_mutex; 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 */ /* Dummy receive to ensure the buffers remain in order */
len = 8; len = 8;
/* queue the bulk submission */ /* queue the bulk submission */
vchi_service_use(instance->service); vchi_service_use(instance->service_handle);
ret = vchi_bulk_queue_receive(instance->service, ret = vchi_bulk_queue_receive(instance->service_handle,
msg_context->u.bulk.buffer->buffer, msg_context->u.bulk.buffer->buffer,
/* Actual receive needs to be a multiple /* Actual receive needs to be a multiple
* of 4 bytes * of 4 bytes
@ -304,7 +304,7 @@ static void buffer_to_host_work_cb(struct work_struct *work)
VCHIQ_BULK_MODE_CALLBACK, VCHIQ_BULK_MODE_CALLBACK,
msg_context); msg_context);
vchi_service_release(instance->service); vchi_service_release(instance->service_handle);
if (ret != 0) if (ret != 0)
pr_err("%s: ctx: %p, vchi_bulk_queue_receive failed %d\n", 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) if (!port->enabled)
return -EINVAL; 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 */ /* get context */
if (!buf->msg_context) { if (!buf->msg_context) {
@ -438,14 +438,14 @@ buffer_from_host(struct vchiq_mmal_instance *instance,
/* no payload in message */ /* no payload in message */
m.u.buffer_from_host.payload_in_message = 0; 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, &m,
sizeof(struct mmal_msg_header) + sizeof(struct mmal_msg_header) +
sizeof(m.u.buffer_from_host)); sizeof(m.u.buffer_from_host));
vchi_service_release(instance->service); vchi_service_release(instance->service_handle);
return ret; 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), DBG_DUMP_MSG(msg, (sizeof(struct mmal_msg_header) + payload_len),
">>> sync message"); ">>> 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, msg,
sizeof(struct mmal_msg_header) + sizeof(struct mmal_msg_header) +
payload_len); payload_len);
vchi_service_release(instance->service); vchi_service_release(instance->service_handle);
if (ret) { if (ret) {
pr_err("error %d queuing message\n", 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); port->component->handle, port->handle);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -921,7 +921,7 @@ release_msg:
pr_debug("%s:result:%d component:0x%x port:%d\n", pr_debug("%s:result:%d component:0x%x port:%d\n",
__func__, ret, port->component->handle, port->handle); __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; return ret;
} }
@ -969,7 +969,7 @@ static int create_component(struct vchiq_mmal_instance *instance,
component->inputs, component->outputs, component->clocks); component->inputs, component->outputs, component->clocks);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1002,7 +1002,7 @@ static int destroy_component(struct vchiq_mmal_instance *instance,
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1034,7 +1034,7 @@ static int enable_component(struct vchiq_mmal_instance *instance,
ret = -rmsg->u.component_enable_reply.status; ret = -rmsg->u.component_enable_reply.status;
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1067,7 +1067,7 @@ static int disable_component(struct vchiq_mmal_instance *instance,
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1099,7 +1099,7 @@ static int get_version(struct vchiq_mmal_instance *instance,
*minor_out = rmsg->u.version.minor; *minor_out = rmsg->u.version.minor;
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1141,7 +1141,7 @@ static int port_action_port(struct vchiq_mmal_instance *instance,
port_action_type_names[action_type], action_type); port_action_type_names[action_type], action_type);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1189,7 +1189,7 @@ static int port_action_handle(struct vchiq_mmal_instance *instance,
action_type, connect_component_handle, connect_port_handle); action_type, connect_component_handle, connect_port_handle);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1230,7 +1230,7 @@ static int port_parameter_set(struct vchiq_mmal_instance *instance,
ret, port->component->handle, port->handle, parameter_id); ret, port->component->handle, port->handle, parameter_id);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1289,7 +1289,7 @@ static int port_parameter_get(struct vchiq_mmal_instance *instance,
ret, port->component->handle, port->handle, parameter_id); ret, port->component->handle, port->handle, parameter_id);
release_msg: release_msg:
vchiq_release_message(instance->service->handle, rmsg_handle); vchiq_release_message(instance->service_handle, rmsg_handle);
return ret; return ret;
} }
@ -1834,9 +1834,9 @@ int vchiq_mmal_finalise(struct vchiq_mmal_instance *instance)
if (mutex_lock_interruptible(&instance->vchiq_mutex)) if (mutex_lock_interruptible(&instance->vchiq_mutex))
return -EINTR; 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) if (status != 0)
pr_err("mmal-vchiq: VCHIQ close failed\n"); 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) if (!instance->bulk_wq)
goto err_free; goto err_free;
status = vchi_service_open(vchiq_instance, &params, &instance->service); status = vchi_service_open(vchiq_instance, &params,
&instance->service_handle);
if (status) { if (status) {
pr_err("Failed to open VCHI service connection (status=%d)\n", pr_err("Failed to open VCHI service connection (status=%d)\n",
status); status);
goto err_close_services; goto err_close_services;
} }
vchi_service_release(instance->service); vchi_service_release(instance->service_handle);
*out_instance = instance; *out_instance = instance;
return 0; return 0;
err_close_services: err_close_services:
vchi_service_close(instance->service); vchi_service_close(instance->service_handle);
destroy_workqueue(instance->bulk_wq); destroy_workqueue(instance->bulk_wq);
err_free: err_free:
vfree(instance->bulk_scratch); vfree(instance->bulk_scratch);