staging: vc04_services: Remove VCHIQ_HEADER_T typedef

Typedefing structs is not encouraged in the kernel.

Signed-off-by: Dominic Braun <inf.braun@fau.de>
Signed-off-by: Tobias Büttner <tobias.buettner@fau.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

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 14f638f59668be84225f82a380fb1ecc16dfbdce..7271d8071b45a31435bd129e92fd2bf7877204f8 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
@@ -122,7 +122,7 @@ struct user_service {
        struct completion insert_event;
        struct completion remove_event;
        struct completion close_event;
-       VCHIQ_HEADER_T * msg_queue[MSG_QUEUE_SIZE];
+       struct vchiq_header *msg_queue[MSG_QUEUE_SIZE];
 };
 
 struct bulk_waiter_node {
@@ -545,8 +545,8 @@ vchiq_blocking_bulk_transfer(VCHIQ_SERVICE_HANDLE_T handle, void *data,
 
 static VCHIQ_STATUS_T
 add_completion(VCHIQ_INSTANCE_T instance, VCHIQ_REASON_T reason,
-       VCHIQ_HEADER_T *header, struct user_service *user_service,
-       void *bulk_userdata)
+              struct vchiq_header *header, struct user_service *user_service,
+              void *bulk_userdata)
 {
        struct vchiq_completion_data *completion;
        int insert;
@@ -610,8 +610,8 @@ add_completion(VCHIQ_INSTANCE_T instance, VCHIQ_REASON_T reason,
 ***************************************************************************/
 
 static VCHIQ_STATUS_T
-service_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header,
-       VCHIQ_SERVICE_HANDLE_T handle, void *bulk_userdata)
+service_callback(VCHIQ_REASON_T reason, struct vchiq_header *header,
+                VCHIQ_SERVICE_HANDLE_T handle, void *bulk_userdata)
 {
        /* How do we ensure the callback goes to the right client?
        ** The service_user data points to a user_service record
@@ -1203,7 +1203,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                struct vchiq_completion_data *completion;
                                VCHIQ_SERVICE_T *service;
                                struct user_service *user_service;
-                               VCHIQ_HEADER_T *header;
+                               struct vchiq_header *header;
 
                                if (remove == instance->completion_insert)
                                        break;
@@ -1228,7 +1228,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                        int msglen;
 
                                        msglen = header->size +
-                                               sizeof(VCHIQ_HEADER_T);
+                                               sizeof(struct vchiq_header);
                                        /* This must be a VCHIQ-style service */
                                        if (args.msgbufsize < msglen) {
                                                vchiq_log_error(
@@ -1320,7 +1320,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        case VCHIQ_IOC_DEQUEUE_MESSAGE: {
                struct vchiq_dequeue_message args;
                struct user_service *user_service;
-               VCHIQ_HEADER_T *header;
+               struct vchiq_header *header;
 
                DEBUG_TRACE(DEQUEUE_MESSAGE_LINE);
                if (copy_from_user
@@ -2041,7 +2041,7 @@ static int vchiq_release(struct inode *inode, struct file *file)
                spin_lock(&msg_queue_spinlock);
 
                while (user_service->msg_remove != user_service->msg_insert) {
-                       VCHIQ_HEADER_T *header;
+                       struct vchiq_header *header;
                        int m = user_service->msg_remove & (MSG_QUEUE_SIZE - 1);
 
                        header = user_service->msg_queue[m];
@@ -2309,7 +2309,7 @@ vchiq_videocore_wanted(VCHIQ_STATE_T *state)
 
 static VCHIQ_STATUS_T
 vchiq_keepalive_vchiq_callback(VCHIQ_REASON_T reason,
-       VCHIQ_HEADER_T *header,
+       struct vchiq_header *header,
        VCHIQ_SERVICE_HANDLE_T service_user,
        void *bulk_user)
 {

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 a0ca2d154db3d6d613d9eeb395349a701800792d..628b0adacc573ad2ab2f8f64371e5671250b645a 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -72,8 +72,8 @@ enum {
 };
 
 /* we require this for consistency between endpoints */
-vchiq_static_assert(sizeof(VCHIQ_HEADER_T) == 8);
-vchiq_static_assert(IS_POW2(sizeof(VCHIQ_HEADER_T)));
+vchiq_static_assert(sizeof(struct vchiq_header) == 8);
+vchiq_static_assert(IS_POW2(sizeof(struct vchiq_header)));
 vchiq_static_assert(IS_POW2(VCHIQ_NUM_CURRENT_BULKS));
 vchiq_static_assert(IS_POW2(VCHIQ_NUM_SERVICE_BULKS));
 vchiq_static_assert(IS_POW2(VCHIQ_MAX_SERVICES));
@@ -127,7 +127,7 @@ static const char *const conn_state_names[] = {
 };
 
 static void
-release_message_sync(VCHIQ_STATE_T *state, VCHIQ_HEADER_T *header);
+release_message_sync(VCHIQ_STATE_T *state, struct vchiq_header *header);
 
 static const char *msg_type_str(unsigned int msg_type)
 {
@@ -386,7 +386,7 @@ mark_service_closing(VCHIQ_SERVICE_T *service)
 
 static inline VCHIQ_STATUS_T
 make_service_callback(VCHIQ_SERVICE_T *service, VCHIQ_REASON_T reason,
-       VCHIQ_HEADER_T *header, void *bulk_userdata)
+       struct vchiq_header *header, void *bulk_userdata)
 {
        VCHIQ_STATUS_T status;
 
@@ -474,11 +474,11 @@ static inline size_t
 calc_stride(size_t size)
 {
        /* Allow room for the header */
-       size += sizeof(VCHIQ_HEADER_T);
+       size += sizeof(struct vchiq_header);
 
        /* Round up */
-       return (size + sizeof(VCHIQ_HEADER_T) - 1) & ~(sizeof(VCHIQ_HEADER_T)
-               - 1);
+       return (size + sizeof(struct vchiq_header) - 1) &
+               ~(sizeof(struct vchiq_header) - 1);
 }
 
 /* Called by the slot handler thread */
@@ -552,7 +552,7 @@ request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type)
 
 /* Called from queue_message, by the slot handler and application threads,
 ** with slot_mutex held */
-static VCHIQ_HEADER_T *
+static struct vchiq_header *
 reserve_space(VCHIQ_STATE_T *state, size_t space, int is_blocking)
 {
        VCHIQ_SHARED_STATE_T *local = state->local;
@@ -560,13 +560,13 @@ reserve_space(VCHIQ_STATE_T *state, size_t space, int is_blocking)
        int slot_space = VCHIQ_SLOT_SIZE - (tx_pos & VCHIQ_SLOT_MASK);
 
        if (space > slot_space) {
-               VCHIQ_HEADER_T *header;
+               struct vchiq_header *header;
                /* Fill the remaining space with padding */
                WARN_ON(state->tx_data == NULL);
-               header = (VCHIQ_HEADER_T *)
+               header = (struct vchiq_header *)
                        (state->tx_data + (tx_pos & VCHIQ_SLOT_MASK));
                header->msgid = VCHIQ_MSGID_PADDING;
-               header->size = slot_space - sizeof(VCHIQ_HEADER_T);
+               header->size = slot_space - sizeof(struct vchiq_header);
 
                tx_pos += slot_space;
        }
@@ -608,7 +608,8 @@ reserve_space(VCHIQ_STATE_T *state, size_t space, int is_blocking)
 
        state->local_tx_pos = tx_pos + space;
 
-       return (VCHIQ_HEADER_T *)(state->tx_data + (tx_pos & VCHIQ_SLOT_MASK));
+       return (struct vchiq_header *)(state->tx_data +
+                                               (tx_pos & VCHIQ_SLOT_MASK));
 }
 
 /* Called by the recycle thread. */
@@ -653,8 +654,8 @@ process_free_queue(VCHIQ_STATE_T *state, BITSET_T *service_found, size_t length)
                pos = 0;
 
                while (pos < VCHIQ_SLOT_SIZE) {
-                       VCHIQ_HEADER_T *header =
-                               (VCHIQ_HEADER_T *)(data + pos);
+                       struct vchiq_header *header =
+                               (struct vchiq_header *)(data + pos);
                        int msgid = header->msgid;
 
                        if (VCHIQ_MSG_TYPE(msgid) == VCHIQ_MSG_DATA) {
@@ -808,7 +809,7 @@ queue_message(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
 {
        VCHIQ_SHARED_STATE_T *local;
        VCHIQ_SERVICE_QUOTA_T *service_quota = NULL;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
        int type = VCHIQ_MSG_TYPE(msgid);
 
        size_t stride;
@@ -1057,7 +1058,7 @@ queue_message_sync(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
        int is_blocking)
 {
        VCHIQ_SHARED_STATE_T *local;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
        ssize_t callback_result;
 
        local = state->local;
@@ -1070,7 +1071,7 @@ queue_message_sync(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
 
        rmb();
 
-       header = (VCHIQ_HEADER_T *)SLOT_DATA_FROM_INDEX(state,
+       header = (struct vchiq_header *)SLOT_DATA_FROM_INDEX(state,
                local->slot_sync);
 
        {
@@ -1149,7 +1150,7 @@ claim_slot(VCHIQ_SLOT_INFO_T *slot)
 
 static void
 release_slot(VCHIQ_STATE_T *state, VCHIQ_SLOT_INFO_T *slot_info,
-       VCHIQ_HEADER_T *header, VCHIQ_SERVICE_T *service)
+       struct vchiq_header *header, VCHIQ_SERVICE_T *service)
 {
        int release_count;
 
@@ -1403,7 +1404,7 @@ abort_outstanding_bulks(VCHIQ_SERVICE_T *service,
 }
 
 static int
-parse_open(VCHIQ_STATE_T *state, VCHIQ_HEADER_T *header)
+parse_open(VCHIQ_STATE_T *state, struct vchiq_header *header)
 {
        VCHIQ_SERVICE_T *service = NULL;
        int msgid, size;
@@ -1536,7 +1537,7 @@ parse_rx_slots(VCHIQ_STATE_T *state)
        tx_pos = remote->tx_pos;
 
        while (state->rx_pos != tx_pos) {
-               VCHIQ_HEADER_T *header;
+               struct vchiq_header *header;
                int msgid, size;
                int type;
                unsigned int localport, remoteport;
@@ -1560,7 +1561,7 @@ parse_rx_slots(VCHIQ_STATE_T *state)
                        state->rx_info->release_count = 0;
                }
 
-               header = (VCHIQ_HEADER_T *)(state->rx_data +
+               header = (struct vchiq_header *)(state->rx_data +
                        (state->rx_pos & VCHIQ_SLOT_MASK));
                DEBUG_VALUE(PARSE_HEADER, (int)(long)header);
                msgid = header->msgid;
@@ -1987,8 +1988,9 @@ sync_func(void *v)
 {
        VCHIQ_STATE_T *state = (VCHIQ_STATE_T *) v;
        VCHIQ_SHARED_STATE_T *local = state->local;
-       VCHIQ_HEADER_T *header = (VCHIQ_HEADER_T *)SLOT_DATA_FROM_INDEX(state,
-               state->remote->slot_sync);
+       struct vchiq_header *header =
+               (struct vchiq_header *)SLOT_DATA_FROM_INDEX(state,
+                       state->remote->slot_sync);
 
        while (1) {
                VCHIQ_SERVICE_T *service;
@@ -2230,8 +2232,9 @@ vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_SLOT_ZERO_T *slot_zero)
        remote_event_create(&state->sync_release_event, &local->sync_release);
 
        /* At start-of-day, the slot is empty and available */
-       ((VCHIQ_HEADER_T *)SLOT_DATA_FROM_INDEX(state, local->slot_sync))->msgid
-               = VCHIQ_MSGID_PADDING;
+       ((struct vchiq_header *)
+               SLOT_DATA_FROM_INDEX(state, local->slot_sync))->msgid =
+                                                       VCHIQ_MSGID_PADDING;
        remote_event_signal_local(&state->sync_release_event, &local->sync_release);
 
        local->debug[DEBUG_ENTRIES] = DEBUG_MAX;
@@ -2482,8 +2485,8 @@ release_service_messages(VCHIQ_SERVICE_T *service)
        /* Release any claimed messages aimed at this service */
 
        if (service->sync) {
-               VCHIQ_HEADER_T *header =
-                       (VCHIQ_HEADER_T *)SLOT_DATA_FROM_INDEX(state,
+               struct vchiq_header *header =
+                       (struct vchiq_header *)SLOT_DATA_FROM_INDEX(state,
                                                state->remote->slot_sync);
                if (VCHIQ_MSG_DSTPORT(header->msgid) == service->localport)
                        release_message_sync(state, header);
@@ -2508,8 +2511,8 @@ release_service_messages(VCHIQ_SERVICE_T *service)
                        pos = 0;
 
                        while (pos < end) {
-                               VCHIQ_HEADER_T *header =
-                                       (VCHIQ_HEADER_T *)(data + pos);
+                               struct vchiq_header *header =
+                                       (struct vchiq_header *)(data + pos);
                                int msgid = header->msgid;
                                int port = VCHIQ_MSG_DSTPORT(msgid);
 
@@ -3214,7 +3217,8 @@ error_exit:
 }
 
 void
-vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle, VCHIQ_HEADER_T *header)
+vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle,
+                     struct vchiq_header *header)
 {
        VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
        VCHIQ_SHARED_STATE_T *remote;
@@ -3246,7 +3250,7 @@ vchiq_release_message(VCHIQ_SERVICE_HANDLE_T handle, VCHIQ_HEADER_T *header)
 }
 
 static void
-release_message_sync(VCHIQ_STATE_T *state, VCHIQ_HEADER_T *header)
+release_message_sync(VCHIQ_STATE_T *state, struct vchiq_header *header)
 {
        header->msgid = VCHIQ_MSGID_PADDING;
        remote_event_signal(&state->remote->sync_release);

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_if.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_if.h
index 0014715e0aca909b89b63c66920b31f860039480..e5410df15c8177d62cf9644c9ba90c412539b56c 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_if.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_if.h
@@ -37,7 +37,7 @@
 #define VCHIQ_SERVICE_HANDLE_INVALID 0
 
 #define VCHIQ_SLOT_SIZE     4096
-#define VCHIQ_MAX_MSG_SIZE  (VCHIQ_SLOT_SIZE - sizeof(VCHIQ_HEADER_T))
+#define VCHIQ_MAX_MSG_SIZE  (VCHIQ_SLOT_SIZE - sizeof(struct vchiq_header))
 #define VCHIQ_CHANNEL_SIZE  VCHIQ_MAX_MSG_SIZE /* For backwards compatibility */
 
 #define VCHIQ_MAKE_FOURCC(x0, x1, x2, x3) \
@@ -76,7 +76,7 @@ typedef enum {
        VCHIQ_SERVICE_OPTION_TRACE
 } VCHIQ_SERVICE_OPTION_T;
 
-typedef struct vchiq_header_struct {
+struct vchiq_header {
        /* The message identifier - opaque to applications. */
        int msgid;
 
@@ -84,7 +84,7 @@ typedef struct vchiq_header_struct {
        unsigned int size;
 
        char data[0];           /* message */
-} VCHIQ_HEADER_T;
+};
 
 struct vchiq_element {
        const void __user *data;
@@ -93,8 +93,9 @@ struct vchiq_element {
 
 typedef unsigned int VCHIQ_SERVICE_HANDLE_T;
 
-typedef VCHIQ_STATUS_T (*VCHIQ_CALLBACK_T)(VCHIQ_REASON_T, VCHIQ_HEADER_T *,
-       VCHIQ_SERVICE_HANDLE_T, void *);
+typedef VCHIQ_STATUS_T (*VCHIQ_CALLBACK_T)(VCHIQ_REASON_T,
+                                          struct vchiq_header *,
+                                          VCHIQ_SERVICE_HANDLE_T, void *);
 
 typedef struct vchiq_service_base_struct {
        int fourcc;
@@ -146,7 +147,7 @@ vchiq_queue_message(VCHIQ_SERVICE_HANDLE_T handle,
                    void *context,
                    size_t size);
 extern void           vchiq_release_message(VCHIQ_SERVICE_HANDLE_T service,
-       VCHIQ_HEADER_T *header);
+       struct vchiq_header *header);
 extern VCHIQ_STATUS_T vchiq_bulk_transmit(VCHIQ_SERVICE_HANDLE_T service,
        const void *data, unsigned int size, void *userdata,
        VCHIQ_BULK_MODE_T mode);

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_ioctl.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
index 6de2dd3c37d176dc3da12ea5c37ee06771b9123d..976f230158ad6fd29e62bd5d4790dad447a47c88 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
@@ -63,7 +63,7 @@ typedef struct {
 
 struct vchiq_completion_data {
        VCHIQ_REASON_T reason;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
        void *service_userdata;
        void *bulk_userdata;
 };

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 6e66a2a43782897c49036f8d9ecd8caea5529b12..022af529c664f7874ca231e492f8490281e88b46 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_shim.c
@@ -72,7 +72,7 @@ int32_t vchi_msg_peek(VCHI_SERVICE_HANDLE_T handle,
        VCHI_FLAGS_T flags)
 {
        struct shim_service *service = (struct shim_service *)handle;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
 
        WARN_ON((flags != VCHI_FLAGS_NONE) &&
                (flags != VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE));
@@ -104,7 +104,7 @@ EXPORT_SYMBOL(vchi_msg_peek);
 int32_t vchi_msg_remove(VCHI_SERVICE_HANDLE_T handle)
 {
        struct shim_service *service = (struct shim_service *)handle;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
 
        header = vchiu_queue_pop(&service->queue);
 
@@ -357,7 +357,7 @@ int32_t vchi_msg_dequeue(VCHI_SERVICE_HANDLE_T handle,
        VCHI_FLAGS_T flags)
 {
        struct shim_service *service = (struct shim_service *)handle;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
 
        WARN_ON((flags != VCHI_FLAGS_NONE) &&
                (flags != VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE));
@@ -401,7 +401,7 @@ int32_t vchi_held_msg_release(struct vchi_held_msg *message)
         */
 
        vchiq_release_message((VCHIQ_SERVICE_HANDLE_T)(long)message->service,
-                             (VCHIQ_HEADER_T *)message->message);
+                             (struct vchiq_header *)message->message);
 
        return 0;
 }
@@ -431,7 +431,7 @@ int32_t vchi_msg_hold(VCHI_SERVICE_HANDLE_T handle,
        struct vchi_held_msg *message_handle)
 {
        struct shim_service *service = (struct shim_service *)handle;
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
 
        WARN_ON((flags != VCHI_FLAGS_NONE) &&
                (flags != VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE));
@@ -540,7 +540,9 @@ EXPORT_SYMBOL(vchi_disconnect);
  ***********************************************************/
 
 static VCHIQ_STATUS_T shim_callback(VCHIQ_REASON_T reason,
-       VCHIQ_HEADER_T *header, VCHIQ_SERVICE_HANDLE_T handle, void *bulk_user)
+                                   struct vchiq_header *header,
+                                   VCHIQ_SERVICE_HANDLE_T handle,
+                                   void *bulk_user)
 {
        struct shim_service *service =
                (struct shim_service *)VCHIQ_GET_SERVICE_USERDATA(handle);

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.c
index 248a3170b42c388636fb716ee939fa21620f3181..b087173a60f0f7e2cf89ed036d9c2b83105761c3 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.c
@@ -50,7 +50,8 @@ int vchiu_queue_init(VCHIU_QUEUE_T *queue, int size)
        init_completion(&queue->pop);
        init_completion(&queue->push);
 
-       queue->storage = kcalloc(size, sizeof(VCHIQ_HEADER_T *), GFP_KERNEL);
+       queue->storage = kcalloc(size, sizeof(struct vchiq_header *),
+                                GFP_KERNEL);
        if (!queue->storage) {
                vchiu_queue_delete(queue);
                return 0;
@@ -73,7 +74,7 @@ int vchiu_queue_is_full(VCHIU_QUEUE_T *queue)
        return queue->write == queue->read + queue->size;
 }
 
-void vchiu_queue_push(VCHIU_QUEUE_T *queue, VCHIQ_HEADER_T *header)
+void vchiu_queue_push(VCHIU_QUEUE_T *queue, struct vchiq_header *header)
 {
        if (!queue->initialized)
                return;
@@ -89,7 +90,7 @@ void vchiu_queue_push(VCHIU_QUEUE_T *queue, VCHIQ_HEADER_T *header)
        complete(&queue->push);
 }
 
-VCHIQ_HEADER_T *vchiu_queue_peek(VCHIU_QUEUE_T *queue)
+struct vchiq_header *vchiu_queue_peek(VCHIU_QUEUE_T *queue)
 {
        while (queue->write == queue->read) {
                if (wait_for_completion_killable(&queue->push))
@@ -101,9 +102,9 @@ VCHIQ_HEADER_T *vchiu_queue_peek(VCHIU_QUEUE_T *queue)
        return queue->storage[queue->read & (queue->size - 1)];
 }
 
-VCHIQ_HEADER_T *vchiu_queue_pop(VCHIU_QUEUE_T *queue)
+struct vchiq_header *vchiu_queue_pop(VCHIU_QUEUE_T *queue)
 {
-       VCHIQ_HEADER_T *header;
+       struct vchiq_header *header;
 
        while (queue->write == queue->read) {
                if (wait_for_completion_killable(&queue->push))

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.h
index b226227fe5bc200f5496b8f2fee432fb8e7816c8..ba8d5f778426d9fe487187205f23e8bfb0a358c2 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.h
@@ -63,7 +63,7 @@ typedef struct {
        struct completion pop;
        struct completion push;
 
-       VCHIQ_HEADER_T **storage;
+       struct vchiq_header **storage;
 } VCHIU_QUEUE_T;
 
 extern int  vchiu_queue_init(VCHIU_QUEUE_T *queue, int size);
@@ -72,9 +72,9 @@ extern void vchiu_queue_delete(VCHIU_QUEUE_T *queue);
 extern int vchiu_queue_is_empty(VCHIU_QUEUE_T *queue);
 extern int vchiu_queue_is_full(VCHIU_QUEUE_T *queue);
 
-extern void vchiu_queue_push(VCHIU_QUEUE_T *queue, VCHIQ_HEADER_T *header);
+extern void vchiu_queue_push(VCHIU_QUEUE_T *queue, struct vchiq_header *header);
 
-extern VCHIQ_HEADER_T *vchiu_queue_peek(VCHIU_QUEUE_T *queue);
-extern VCHIQ_HEADER_T *vchiu_queue_pop(VCHIU_QUEUE_T *queue);
+extern struct vchiq_header *vchiu_queue_peek(VCHIU_QUEUE_T *queue);
+extern struct vchiq_header *vchiu_queue_pop(VCHIU_QUEUE_T *queue);
 
 #endif