staging: vchi: Unify struct shim_service and struct vchi_service_handle

[linux-2.6-microblaze.git] / drivers / staging / vc04_services / interface / vchiq_arm / vchiq_shim.c

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
index 75d87b6..3950278 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
@@ -9,7 +9,7 @@
 
 #include "vchiq_util.h"
 
-struct shim_service {
+struct vchi_service {
        unsigned int handle;
 
        struct vchiu_queue queue;
@@ -18,74 +18,9 @@ struct shim_service {
        void *callback_param;
 };
 
-/***********************************************************
- * Name: vchi_msg_peek
- *
- * Arguments:  struct vchi_service_handle *handle,
- *             void **data,
- *             uint32_t *msg_size,
-
- *             enum vchi_flags flags
- *
- * Description: Routine to return a pointer to the current message (to allow in
- *              place processing). The message can be removed using
- *              vchi_msg_remove when you're finished
- *
- * Returns: int32_t - success == 0
- *
- ***********************************************************/
-int32_t vchi_msg_peek(struct vchi_service_handle *handle,
-                     void **data,
-                     uint32_t *msg_size,
-                     enum vchi_flags flags)
-{
-       struct shim_service *service = (struct shim_service *)handle;
-       struct vchiq_header *header;
-
-       WARN_ON((flags != VCHI_FLAGS_NONE) &&
-               (flags != VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE));
-
-       if (flags == VCHI_FLAGS_NONE)
-               if (vchiu_queue_is_empty(&service->queue))
-                       return -1;
-
-       header = vchiu_queue_peek(&service->queue);
-
-       *data = header->data;
-       *msg_size = header->size;
-
-       return 0;
-}
-EXPORT_SYMBOL(vchi_msg_peek);
-
-/***********************************************************
- * Name: vchi_msg_remove
- *
- * Arguments:  struct vchi_service_handle *handle,
- *
- * Description: Routine to remove a message (after it has been read with
- *              vchi_msg_peek)
- *
- * Returns: int32_t - success == 0
- *
- ***********************************************************/
-int32_t vchi_msg_remove(struct vchi_service_handle *handle)
-{
-       struct shim_service *service = (struct shim_service *)handle;
-       struct vchiq_header *header;
-
-       header = vchiu_queue_pop(&service->queue);
-
-       vchiq_release_message(service->handle, header);
-
-       return 0;
-}
-EXPORT_SYMBOL(vchi_msg_remove);
-
-int vchi_queue_kernel_message(struct vchi_service_handle *handle, void *data,
-                              unsigned int size)
+int vchi_queue_kernel_message(struct vchi_service *service, void *data,
+                             unsigned int size)
 {
-       struct shim_service *service = (struct shim_service *)handle;
        enum vchiq_status status;
 
        while (1) {
@@ -121,11 +56,10 @@ EXPORT_SYMBOL(vchi_queue_kernel_message);
  * Returns: int32_t - success == 0
  *
  ***********************************************************/
-int32_t vchi_bulk_queue_receive(struct vchi_service_handle *handle, void *data_dst,
+int32_t vchi_bulk_queue_receive(struct vchi_service *service, void *data_dst,
                                uint32_t data_size, enum vchi_flags flags,
                                void *bulk_handle)
 {
-       struct shim_service *service = (struct shim_service *)handle;
        enum vchiq_bulk_mode mode;
        enum vchiq_status status;
 
@@ -179,13 +113,12 @@ EXPORT_SYMBOL(vchi_bulk_queue_receive);
  * Returns: int32_t - success == 0
  *
  ***********************************************************/
-int32_t vchi_bulk_queue_transmit(struct vchi_service_handle *handle,
+int32_t vchi_bulk_queue_transmit(struct vchi_service *service,
                                 const void *data_src,
                                 uint32_t data_size,
                                 enum vchi_flags flags,
                                 void *bulk_handle)
 {
-       struct shim_service *service = (struct shim_service *)handle;
        enum vchiq_bulk_mode mode;
        enum vchiq_status status;
 
@@ -230,7 +163,7 @@ EXPORT_SYMBOL(vchi_bulk_queue_transmit);
 /***********************************************************
  * Name: vchi_msg_dequeue
  *
- * Arguments:  struct vchi_service_handle *handle,
+ * Arguments:  struct vchi_service *service,
  *             void *data,
  *             uint32_t max_data_size_to_read,
  *             uint32_t *actual_msg_size
@@ -241,11 +174,10 @@ EXPORT_SYMBOL(vchi_bulk_queue_transmit);
  * Returns: int32_t - success == 0
  *
  ***********************************************************/
-int32_t vchi_msg_dequeue(struct vchi_service_handle *handle, void *data,
+int32_t vchi_msg_dequeue(struct vchi_service *service, void *data,
                         uint32_t max_data_size_to_read,
                         uint32_t *actual_msg_size, enum vchi_flags flags)
 {
-       struct shim_service *service = (struct shim_service *)handle;
        struct vchiq_header *header;
 
        WARN_ON((flags != VCHI_FLAGS_NONE) &&
@@ -299,7 +231,7 @@ EXPORT_SYMBOL(vchi_held_msg_release);
 /***********************************************************
  * Name: vchi_msg_hold
  *
- * Arguments:  struct vchi_service_handle *handle,
+ * Arguments:  struct vchi_service *service,
  *             void **data,
  *             uint32_t *msg_size,
  *             enum vchi_flags flags,
@@ -313,11 +245,10 @@ EXPORT_SYMBOL(vchi_held_msg_release);
  * Returns: int32_t - success == 0
  *
  ***********************************************************/
-int32_t vchi_msg_hold(struct vchi_service_handle *handle, void **data,
+int32_t vchi_msg_hold(struct vchi_service *service, void **data,
                      uint32_t *msg_size, enum vchi_flags flags,
                      struct vchi_held_msg *message_handle)
 {
-       struct shim_service *service = (struct shim_service *)handle;
        struct vchiq_header *header;
 
        WARN_ON((flags != VCHI_FLAGS_NONE) &&
@@ -351,7 +282,7 @@ EXPORT_SYMBOL(vchi_msg_hold);
 /***********************************************************
  * Name: vchi_initialise
  *
- * Arguments: struct vchi_instance_handle **instance_handle
+ * Arguments: struct vchiq_instance **instance
  *
  * Description: Initialises the hardware but does not transmit anything
  *              When run as a Host App this will be called twice hence the need
@@ -361,23 +292,16 @@ EXPORT_SYMBOL(vchi_msg_hold);
  *
  ***********************************************************/
 
-int32_t vchi_initialise(struct vchi_instance_handle **instance_handle)
+int32_t vchi_initialise(struct vchiq_instance **instance)
 {
-       struct vchiq_instance *instance;
-       enum vchiq_status status;
-
-       status = vchiq_initialise(&instance);
-
-       *instance_handle = (struct vchi_instance_handle *)instance;
-
-       return status;
+       return vchiq_initialise(instance);
 }
 EXPORT_SYMBOL(vchi_initialise);
 
 /***********************************************************
  * Name: vchi_connect
  *
- * Arguments: struct vchi_instance_handle *instance_handle
+ * Arguments: struct vchiq_instance *instance
  *
  * Description: Starts the command service on each connection,
  *              causing INIT messages to be pinged back and forth
@@ -385,10 +309,8 @@ EXPORT_SYMBOL(vchi_initialise);
  * Returns: 0 if successful, failure otherwise
  *
  ***********************************************************/
-int32_t vchi_connect(struct vchi_instance_handle *instance_handle)
+int32_t vchi_connect(struct vchiq_instance *instance)
 {
-       struct vchiq_instance *instance = (struct vchiq_instance *)instance_handle;
-
        return vchiq_connect(instance);
 }
 EXPORT_SYMBOL(vchi_connect);
@@ -396,7 +318,7 @@ EXPORT_SYMBOL(vchi_connect);
 /***********************************************************
  * Name: vchi_disconnect
  *
- * Arguments: struct vchi_instance_handle *instance_handle
+ * Arguments: struct vchiq_instance *instance
  *
  * Description: Stops the command service on each connection,
  *              causing DE-INIT messages to be pinged back and forth
@@ -404,10 +326,8 @@ EXPORT_SYMBOL(vchi_connect);
  * Returns: 0 if successful, failure otherwise
  *
  ***********************************************************/
-int32_t vchi_disconnect(struct vchi_instance_handle *instance_handle)
+int32_t vchi_disconnect(struct vchiq_instance *instance)
 {
-       struct vchiq_instance *instance = (struct vchiq_instance *)instance_handle;
-
        return vchiq_shutdown(instance);
 }
 EXPORT_SYMBOL(vchi_disconnect);
@@ -416,9 +336,9 @@ EXPORT_SYMBOL(vchi_disconnect);
  * Name: vchi_service_open
  * Name: vchi_service_create
  *
- * Arguments: struct vchi_instance_handle *instance_handle
+ * Arguments: struct vchiq_instance *instance
  *            struct service_creation *setup,
- *            struct vchi_service_handle **handle
+ *            struct vchi_service **service
  *
  * Description: Routine to open a service
  *
@@ -431,8 +351,8 @@ static enum vchiq_status shim_callback(enum vchiq_reason reason,
                                    unsigned int handle,
                                    void *bulk_user)
 {
-       struct shim_service *service =
-               (struct shim_service *)VCHIQ_GET_SERVICE_USERDATA(handle);
+       struct vchi_service *service =
+               (struct vchi_service *)VCHIQ_GET_SERVICE_USERDATA(handle);
 
        if (!service->callback)
                goto release;
@@ -482,10 +402,10 @@ release:
        return VCHIQ_SUCCESS;
 }
 
-static struct shim_service *service_alloc(struct vchiq_instance *instance,
+static struct vchi_service *service_alloc(struct vchiq_instance *instance,
        struct service_creation *setup)
 {
-       struct shim_service *service = kzalloc(sizeof(struct shim_service), GFP_KERNEL);
+       struct vchi_service *service = kzalloc(sizeof(struct vchi_service), GFP_KERNEL);
 
        (void)instance;
 
@@ -502,7 +422,7 @@ static struct shim_service *service_alloc(struct vchiq_instance *instance,
        return service;
 }
 
-static void service_free(struct shim_service *service)
+static void service_free(struct vchi_service *service)
 {
        if (service) {
                vchiu_queue_delete(&service->queue);
@@ -510,43 +430,38 @@ static void service_free(struct shim_service *service)
        }
 }
 
-int32_t vchi_service_open(struct vchi_instance_handle *instance_handle,
+int32_t vchi_service_open(struct vchiq_instance *instance,
        struct service_creation *setup,
-       struct vchi_service_handle **handle)
+       struct vchi_service **service)
 {
-       struct vchiq_instance *instance = (struct vchiq_instance *)instance_handle;
-       struct shim_service *service = service_alloc(instance, setup);
-
-       *handle = (struct vchi_service_handle *)service;
 
-       if (service) {
+       *service = service_alloc(instance, setup);
+       if (*service) {
                struct vchiq_service_params params;
                enum vchiq_status status;
 
                memset(&params, 0, sizeof(params));
                params.fourcc = setup->service_id;
                params.callback = shim_callback;
-               params.userdata = service;
+               params.userdata = *service;
                params.version = setup->version.version;
                params.version_min = setup->version.version_min;
 
                status = vchiq_open_service(instance, &params,
-                       &service->handle);
+                       &((*service)->handle));
                if (status != VCHIQ_SUCCESS) {
-                       service_free(service);
-                       service = NULL;
-                       *handle = NULL;
+                       service_free(*service);
+                       *service = NULL;
                }
        }
 
-       return service ? 0 : -1;
+       return *service ? 0 : -1;
 }
 EXPORT_SYMBOL(vchi_service_open);
 
-int32_t vchi_service_close(const struct vchi_service_handle *handle)
+int32_t vchi_service_close(struct vchi_service *service)
 {
        int32_t ret = -1;
-       struct shim_service *service = (struct shim_service *)handle;
 
        if (service) {
                enum vchiq_status status = vchiq_close_service(service->handle);
@@ -559,10 +474,9 @@ int32_t vchi_service_close(const struct vchi_service_handle *handle)
 }
 EXPORT_SYMBOL(vchi_service_close);
 
-int32_t vchi_get_peer_version(const struct vchi_service_handle *handle, short *peer_version)
+int32_t vchi_get_peer_version(struct vchi_service *service, short *peer_version)
 {
        int32_t ret = -1;
-       struct shim_service *service = (struct shim_service *)handle;
 
        if (service) {
                enum vchiq_status status;
@@ -577,18 +491,17 @@ EXPORT_SYMBOL(vchi_get_peer_version);
 /***********************************************************
  * Name: vchi_service_use
  *
- * Arguments: const struct vchi_service_handle *handle
+ * Arguments: struct vchi_service *service
  *
  * Description: Routine to increment refcount on a service
  *
  * Returns: void
  *
  ***********************************************************/
-int32_t vchi_service_use(const struct vchi_service_handle *handle)
+int32_t vchi_service_use(struct vchi_service *service)
 {
        int32_t ret = -1;
 
-       struct shim_service *service = (struct shim_service *)handle;
        if (service)
                ret = vchiq_use_service(service->handle);
        return ret;
@@ -598,18 +511,17 @@ EXPORT_SYMBOL(vchi_service_use);
 /***********************************************************
  * Name: vchi_service_release
  *
- * Arguments: const struct vchi_service_handle *handle
+ * Arguments: struct vchi_service *service
  *
  * Description: Routine to decrement refcount on a service
  *
  * Returns: void
  *
  ***********************************************************/
-int32_t vchi_service_release(const struct vchi_service_handle *handle)
+int32_t vchi_service_release(struct vchi_service *service)
 {
        int32_t ret = -1;
 
-       struct shim_service *service = (struct shim_service *)handle;
        if (service)
                ret = vchiq_release_service(service->handle);
        return ret;