A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-13 16:16:15 -04:00
Code Issues Projects Releases Packages Wiki Activity

staging: vc04_services: Remove VCHIQ_HEADER_T typedef

Browse source 
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>
This commit is contained in:
Dominic Braun 2018-12-14 13:04:57 +01:00 • committed by Greg Kroah-Hartman
commit e896852528
7 changed files with 71 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

20
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
View file

@ -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)
{

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

@ -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);

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

@ -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);

2
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_ioctl.h
View file

@ -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;
};

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

@ -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);

11
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.c
View file

@ -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))

8
drivers/staging/vc04_services/interface/vchiq_arm/vchiq_util.h
View file

@ -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