mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-02 07:04:24 +00:00
Code Issues Releases Wiki Activity

staging: vchi: Move vchi_queue_kernel_message() into vchiq

Browse source 
We can't really merge it with vchiq_queue_message() as it has internal
users that will not benefit from the retry mechanism
vchiq_queue_kernel_message() uses. So, for the sake of getting rid of
vchi, move it into vchiq.

Signed-off-by: Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
Link: https://lore.kernel.org/r/20200629150945.10720-43-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:40 +02:00 committed by Greg Kroah-Hartman
parent 0bda14fd49
commit 5c01fc5c00
6 changed files with 32 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -44,8 +44,8 @@ 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_handle,
m, sizeof(*m));
status = vchiq_queue_kernel_message(instance->service_handle,
m, sizeof(*m));
if (status) {
dev_err(instance->dev,
"vchi message queue failed: %d, msg=%d\n",
@ -350,8 +350,8 @@ 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_handle,
src, bytes);
status = vchiq_queue_kernel_message(instance->service_handle,
src, bytes);
src += bytes;
count -= bytes;
}

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

@ -37,10 +37,6 @@ extern int32_t vchi_service_use(unsigned handle);
// Routine to decrement ref count on a named 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(unsigned handle, void *data,
unsigned int size);
// Routine to look at a message in place.
// The message is dequeued, so the caller is left holding it; the descriptor is
// filled in and must be released when the user has finished with the message.

23
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
View file

@ -3213,11 +3213,28 @@ vchiq_queue_message(unsigned int handle,
return status;
}
enum vchiq_status vchiq_queue_kernel_message(unsigned int handle, void *context,
size_t size)
int vchiq_queue_kernel_message(unsigned handle, void *data, unsigned size)
{
return vchiq_queue_message(handle, memcpy_copy_callback, context, size);
enum vchiq_status status;
while (1) {
status = vchiq_queue_message(handle, memcpy_copy_callback,
data, size);
/*
* vchiq_queue_message() may return VCHIQ_RETRY, so we need to
* implement a retry mechanism since this function is supposed
* to block until queued
*/
if (status != VCHIQ_RETRY)
break;
msleep(1);
}
return status;
}
EXPORT_SYMBOL(vchiq_queue_kernel_message);
void
vchiq_release_message(unsigned int handle,

4
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_if.h
View file

@ -89,8 +89,8 @@ extern enum vchiq_status vchiq_open_service(struct vchiq_instance *instance,
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 enum vchiq_status vchiq_queue_kernel_message(unsigned int handle,
void *context, size_t size);
extern int vchiq_queue_kernel_message(unsigned handle, void *data,
unsigned size);
extern void vchiq_msg_queue_push(unsigned handle, struct vchiq_header *header);
extern void vchiq_release_message(unsigned int service,
struct vchiq_header *header);

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

@ -9,28 +9,6 @@
#include "../vchi/vchi.h"
#include "vchiq.h"
int vchi_queue_kernel_message(unsigned handle, void *data, unsigned int size)
{
enum vchiq_status status;
while (1) {
status = vchiq_queue_kernel_message(handle, data, size);
/*
* vchiq_queue_message() may return VCHIQ_RETRY, so we need to
* implement a retry mechanism since this function is supposed
* to block until queued
*/
if (status != VCHIQ_RETRY)
break;
msleep(1);
}
return status;
}
EXPORT_SYMBOL(vchi_queue_kernel_message);
/***********************************************************
* Name: vchi_held_msg_release
*

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

@ -440,10 +440,9 @@ buffer_from_host(struct vchiq_mmal_instance *instance,
vchi_service_use(instance->service_handle);
ret = vchi_queue_kernel_message(instance->service_handle,
&m,
sizeof(struct mmal_msg_header) +
sizeof(m.u.buffer_from_host));
ret = vchiq_queue_kernel_message(instance->service_handle, &m,
sizeof(struct mmal_msg_header) +
sizeof(m.u.buffer_from_host));
vchi_service_release(instance->service_handle);
@ -681,10 +680,9 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance,
vchi_service_use(instance->service_handle);
ret = vchi_queue_kernel_message(instance->service_handle,
msg,
sizeof(struct mmal_msg_header) +
payload_len);
ret = vchiq_queue_kernel_message(instance->service_handle, msg,
sizeof(struct mmal_msg_header) +
payload_len);
vchi_service_release(instance->service_handle);