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: Stefan Wahren <stefan.wahren@i2se.com>
Signed-off-by: Adrien Thierry <athierry@redhat.com>
Link: https://lore.kernel.org/r/20220518191126.60396-5-athierry@redhat.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c
index c32c8c9..aa2ab0d 100644 (file)
--- a/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c
+++ b/drivers/staging/vc04_services/bcm2835-audio/bcm2835-vchiq.c
@@ -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;
                }

diff --git a/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h b/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
index 97537d3..0d3833e 100644 (file)
--- a/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
+++ b/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
@@ -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,
-       struct vchiq_header *header);
-extern int vchiq_queue_kernel_message(unsigned int handle, void *data,
-                                     unsigned int size);
+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 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,
-       short *peer_version);
-extern struct vchiq_header *vchiq_msg_hold(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(struct vchiq_instance *instance, unsigned int handle);
 
 #endif /* VCHIQ_H */

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
index ffb2429..a5f0a75 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
@@ -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);

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
index f671c39..2851ef6 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
@@ -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);

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
index 547af55..7217e30 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -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 @@ fail_free_handler_thread:
        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 @@ error_exit:
 }
 
 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 @@ error_exit:
        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;
 

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h
index 2eca7b3..34d8fef 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.h
@@ -521,7 +521,7 @@ handle_to_service(unsigned int handle)
 }
 
 extern struct vchiq_service *
-find_service_by_handle(unsigned int handle);
+find_service_by_handle(struct vchiq_instance *instance, unsigned int handle);
 
 extern struct vchiq_service *
 find_service_by_port(struct vchiq_state *state, unsigned int localport);
@@ -549,7 +549,7 @@ extern void
 vchiq_service_put(struct vchiq_service *service);
 
 extern 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,
@@ -596,12 +596,13 @@ void vchiq_set_conn_state(struct vchiq_state *state, enum vchiq_connstate newsta
 
 void vchiq_log_dump_mem(const char *label, u32 addr, const void *void_mem, size_t num_bytes);
 
-enum vchiq_status vchiq_remove_service(unsigned int service);
+enum vchiq_status vchiq_remove_service(struct vchiq_instance *instance, unsigned int service);
 
 int vchiq_get_client_id(unsigned int service);
 
 void vchiq_get_config(struct vchiq_config *config);
 
-int vchiq_set_service_option(unsigned int service, enum vchiq_service_option option, int value);
+int vchiq_set_service_option(struct vchiq_instance *instance, unsigned int service,
+                            enum vchiq_service_option option, int value);
 
 #endif

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
index 077e3fc..adb616d 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
@@ -108,8 +108,8 @@ static ssize_t vchiq_ioc_copy_element_data(void *context, void *dest,
 }
 
 static int
-vchiq_ioc_queue_message(unsigned int handle, struct vchiq_element *elements,
-                       unsigned long count)
+vchiq_ioc_queue_message(struct vchiq_instance *instance, unsigned int handle,
+                       struct vchiq_element *elements, unsigned long count)
 {
        struct vchiq_io_copy_callback_context context;
        enum vchiq_status status = VCHIQ_SUCCESS;
@@ -127,7 +127,7 @@ vchiq_ioc_queue_message(unsigned int handle, struct vchiq_element *elements,
                total_size += elements[i].size;
        }
 
-       status = vchiq_queue_message(handle, vchiq_ioc_copy_element_data,
+       status = vchiq_queue_message(instance, handle, vchiq_ioc_copy_element_data,
                                     &context, total_size);
 
        if (status == VCHIQ_ERROR)
@@ -191,7 +191,7 @@ static int vchiq_ioc_create_service(struct vchiq_instance *instance,
        if (args->is_open) {
                status = vchiq_open_service_internal(service, instance->pid);
                if (status != VCHIQ_SUCCESS) {
-                       vchiq_remove_service(service->handle);
+                       vchiq_remove_service(instance, service->handle);
                        return (status == VCHIQ_RETRY) ?
                                -EINTR : -EIO;
                }
@@ -266,7 +266,7 @@ static int vchiq_ioc_dequeue_message(struct vchiq_instance *instance,
                /* Copy to user space if msgbuf is not NULL */
                if (!args->buf || (copy_to_user(args->buf, header->data, header->size) == 0)) {
                        ret = header->size;
-                       vchiq_release_message(service->handle, header);
+                       vchiq_release_message(instance, service->handle, header);
                } else {
                        ret = -EFAULT;
                }
@@ -529,7 +529,7 @@ static int vchiq_ioc_await_completion(struct vchiq_instance *instance,
                        }
 
                        /* Now it has been copied, the message can be released. */
-                       vchiq_release_message(service->handle, header);
+                       vchiq_release_message(instance, service->handle, header);
 
                        /* The completion must point to the msgbuf. */
                        user_completion.header = msgbuf;
@@ -596,7 +596,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                i = 0;
                while ((service = next_service_by_instance(instance->state,
                                                           instance, &i))) {
-                       status = vchiq_remove_service(service->handle);
+                       status = vchiq_remove_service(instance, service->handle);
                        vchiq_service_put(service);
                        if (status != VCHIQ_SUCCESS)
                                break;
@@ -649,7 +649,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                        break;
 
                if (put_user(args.handle, &argp->handle)) {
-                       vchiq_remove_service(args.handle);
+                       vchiq_remove_service(instance, args.handle);
                        ret = -EFAULT;
                }
        } break;
@@ -673,8 +673,8 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 */
                if (!user_service->close_pending) {
                        status = (cmd == VCHIQ_IOC_CLOSE_SERVICE) ?
-                                vchiq_close_service(service->handle) :
-                                vchiq_remove_service(service->handle);
+                                vchiq_close_service(instance, service->handle) :
+                                vchiq_remove_service(instance, service->handle);
                        if (status != VCHIQ_SUCCESS)
                                break;
                }
@@ -731,7 +731,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                        if (copy_from_user(elements, args.elements,
                                           args.count * sizeof(struct vchiq_element)) == 0)
-                               ret = vchiq_ioc_queue_message(args.handle, elements,
+                               ret = vchiq_ioc_queue_message(instance, args.handle, elements,
                                                              args.count);
                        else
                                ret = -EFAULT;
@@ -827,7 +827,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                        break;
                }
 
-               ret = vchiq_set_service_option(args.handle, args.option,
+               ret = vchiq_set_service_option(instance, args.handle, args.option,
                                               args.value);
        } break;
 
@@ -908,6 +908,7 @@ vchiq_compat_ioctl_create_service(struct file *file, unsigned int cmd,
 {
        struct vchiq_create_service args;
        struct vchiq_create_service32 args32;
+       struct vchiq_instance *instance = file->private_data;
        long ret;
 
        if (copy_from_user(&args32, ptrargs32, sizeof(args32)))
@@ -926,12 +927,12 @@ vchiq_compat_ioctl_create_service(struct file *file, unsigned int cmd,
                .handle  = args32.handle,
        };
 
-       ret = vchiq_ioc_create_service(file->private_data, &args);
+       ret = vchiq_ioc_create_service(instance, &args);
        if (ret < 0)
                return ret;
 
        if (put_user(args.handle, &ptrargs32->handle)) {
-               vchiq_remove_service(args.handle);
+               vchiq_remove_service(instance, args.handle);
                return -EFAULT;
        }
 
@@ -960,6 +961,7 @@ vchiq_compat_ioctl_queue_message(struct file *file,
        struct vchiq_queue_message args;
        struct vchiq_queue_message32 args32;
        struct vchiq_service *service;
+       struct vchiq_instance *instance = file->private_data;
        int ret;
 
        if (copy_from_user(&args32, arg, sizeof(args32)))
@@ -974,7 +976,7 @@ vchiq_compat_ioctl_queue_message(struct file *file,
        if (args32.count > MAX_ELEMENTS)
                return -EINVAL;
 
-       service = find_service_for_instance(file->private_data, args.handle);
+       service = find_service_for_instance(instance, args.handle);
        if (!service)
                return -EINVAL;
 
@@ -994,7 +996,7 @@ vchiq_compat_ioctl_queue_message(struct file *file,
                                compat_ptr(element32[count].data);
                        elements[count].size = element32[count].size;
                }
-               ret = vchiq_ioc_queue_message(args.handle, elements,
+               ret = vchiq_ioc_queue_message(instance, args.handle, elements,
                                              args.count);
        } else {
                ret = -EINVAL;
@@ -1261,7 +1263,7 @@ static int vchiq_release(struct inode *inode, struct file *file)
                        spin_unlock(&msg_queue_spinlock);
 
                        if (header)
-                               vchiq_release_message(service->handle, header);
+                               vchiq_release_message(instance, service->handle, header);
                        spin_lock(&msg_queue_spinlock);
                }
 

diff --git a/drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c b/drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c
index 55f290b..4c29cb7 100644 (file)
--- a/drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c
+++ b/drivers/staging/vc04_services/vchiq-mmal/mmal-vchiq.c
@@ -292,7 +292,7 @@ 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 */
-       vchiq_use_service(instance->service_handle);
+       vchiq_use_service(instance->vchiq_instance, instance->service_handle);
        ret = vchiq_bulk_receive(instance->vchiq_instance, instance->service_handle,
                                 msg_context->u.bulk.buffer->buffer,
                                 /* Actual receive needs to be a multiple
@@ -302,7 +302,7 @@ static void buffer_to_host_work_cb(struct work_struct *work)
                                msg_context,
                                VCHIQ_BULK_MODE_CALLBACK);
 
-       vchiq_release_service(instance->service_handle);
+       vchiq_release_service(instance->vchiq_instance, instance->service_handle);
 
        if (ret != 0)
                pr_err("%s: ctx: %p, vchiq_bulk_receive failed %d\n",
@@ -436,15 +436,15 @@ buffer_from_host(struct vchiq_mmal_instance *instance,
        /* no payload in message */
        m.u.buffer_from_host.payload_in_message = 0;
 
-       vchiq_use_service(instance->service_handle);
+       vchiq_use_service(instance->vchiq_instance, instance->service_handle);
 
-       ret = vchiq_queue_kernel_message(instance->service_handle, &m,
+       ret = vchiq_queue_kernel_message(instance->vchiq_instance, instance->service_handle, &m,
                                         sizeof(struct mmal_msg_header) +
                                         sizeof(m.u.buffer_from_host));
        if (ret)
                atomic_dec(&port->buffers_with_vpu);
 
-       vchiq_release_service(instance->service_handle);
+       vchiq_release_service(instance->vchiq_instance, instance->service_handle);
 
        return ret;
 }
@@ -573,25 +573,25 @@ static enum vchiq_status service_callback(struct vchiq_instance *vchiq_instance,
                /* handling is different for buffer messages */
                switch (msg->h.type) {
                case MMAL_MSG_TYPE_BUFFER_FROM_HOST:
-                       vchiq_release_message(handle, header);
+                       vchiq_release_message(vchiq_instance, handle, header);
                        break;
 
                case MMAL_MSG_TYPE_EVENT_TO_HOST:
                        event_to_host_cb(instance, msg, msg_len);
-                       vchiq_release_message(handle, header);
+                       vchiq_release_message(vchiq_instance, handle, header);
 
                        break;
 
                case MMAL_MSG_TYPE_BUFFER_TO_HOST:
                        buffer_to_host_cb(instance, msg, msg_len);
-                       vchiq_release_message(handle, header);
+                       vchiq_release_message(vchiq_instance, handle, header);
                        break;
 
                default:
                        /* messages dependent on header context to complete */
                        if (!msg->h.context) {
                                pr_err("received message context was null!\n");
-                               vchiq_release_message(handle, header);
+                               vchiq_release_message(vchiq_instance, handle, header);
                                break;
                        }
 
@@ -600,7 +600,7 @@ static enum vchiq_status service_callback(struct vchiq_instance *vchiq_instance,
                        if (!msg_context) {
                                pr_err("received invalid message context %u!\n",
                                       msg->h.context);
-                               vchiq_release_message(handle, header);
+                               vchiq_release_message(vchiq_instance, handle, header);
                                break;
                        }
 
@@ -679,13 +679,13 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance,
        DBG_DUMP_MSG(msg, (sizeof(struct mmal_msg_header) + payload_len),
                     ">>> sync message");
 
-       vchiq_use_service(instance->service_handle);
+       vchiq_use_service(instance->vchiq_instance, instance->service_handle);
 
-       ret = vchiq_queue_kernel_message(instance->service_handle, msg,
+       ret = vchiq_queue_kernel_message(instance->vchiq_instance, instance->service_handle, msg,
                                         sizeof(struct mmal_msg_header) +
                                         payload_len);
 
-       vchiq_release_service(instance->service_handle);
+       vchiq_release_service(instance->vchiq_instance, instance->service_handle);
 
        if (ret) {
                pr_err("error %d queuing message\n", ret);
@@ -825,7 +825,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -920,7 +920,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -968,7 +968,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1001,7 +1001,7 @@ static int destroy_component(struct vchiq_mmal_instance *instance,
 
 release_msg:
 
-       vchiq_release_message(instance->service_handle, rmsg_handle);
+       vchiq_release_message(instance->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1033,7 +1033,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1066,7 +1066,7 @@ static int disable_component(struct vchiq_mmal_instance *instance,
 
 release_msg:
 
-       vchiq_release_message(instance->service_handle, rmsg_handle);
+       vchiq_release_message(instance->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1098,7 +1098,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1140,7 +1140,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1188,7 +1188,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1229,7 +1229,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1288,7 +1288,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->vchiq_instance, instance->service_handle, rmsg_handle);
 
        return ret;
 }
@@ -1833,9 +1833,9 @@ int vchiq_mmal_finalise(struct vchiq_mmal_instance *instance)
        if (mutex_lock_interruptible(&instance->vchiq_mutex))
                return -EINTR;
 
-       vchiq_use_service(instance->service_handle);
+       vchiq_use_service(instance->vchiq_instance, instance->service_handle);
 
-       status = vchiq_close_service(instance->service_handle);
+       status = vchiq_close_service(instance->vchiq_instance, instance->service_handle);
        if (status != 0)
                pr_err("mmal-vchiq: VCHIQ close failed\n");
 
@@ -1923,14 +1923,14 @@ int vchiq_mmal_init(struct vchiq_mmal_instance **out_instance)
                goto err_close_services;
        }
 
-       vchiq_release_service(instance->service_handle);
+       vchiq_release_service(instance->vchiq_instance, instance->service_handle);
 
        *out_instance = instance;
 
        return 0;
 
 err_close_services:
-       vchiq_close_service(instance->service_handle);
+       vchiq_close_service(instance->vchiq_instance, instance->service_handle);
        destroy_workqueue(instance->bulk_wq);
 err_free:
        kfree(instance);