int32_t ipc_vchi_msg_hold( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void **data,
uint32_t *msg_size,
VCHI_FLAGS_T flags,
VCHI_HELD_MSG_T *message_handle )
{
//vchi_msg_hold(handle,data,msg_size,flags,message_handle);
int32_t events;
int32_t success=0;
ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = set_vchi_handle(handle);
ipc->buffer[1] = 0;
ipc->buffer[2] = flags;
ipc->buffer[3] = 0xbabeface;
ipc_signal(IPC_VCHI_MSG_HOLD_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_HOLD_EVENT));
*msg_size = ipc->buffer[1];
// message_handle = (VCHI_HELD_MSG_T*)ipc->buffer[2];
*data = &ipc->buffer[4];
// ipc_release(IPC_SEM_ACCESS);
return success;
}
int32_t ipc_vchi_msg_hold( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void **data,
uint32_t *msg_size,
VCHI_FLAGS_T flags,
VCHI_HELD_MSG_T *message_handle )
{
//vchi_msg_hold(handle,data,msg_size,flags,message_handle);
int32_t events;
int32_t success=0;
//myIPC->buffer[1] = 0;
myIPC->buffer[2] = flags;
myIPC->buffer[3] = handle;
ipc_signal(IPC_VCHI_MSG_HOLD_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_HOLD_EVENT));
*msg_size = myIPC->buffer[0];
//message_handle = (VCHI_HELD_MSG_T*)myIPC->buffer[2];
*data = (void*)myIPC->buffer[4];
return success;
}
int32_t ipc_vchi_bulk_queue_receive(/*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void * data_dst,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * bulk_handle )
{
// vchi_bulk_queue_receive(handle,data_dst,data_size,flags,bulk_handle);
int32_t events;
int32_t success=0;
os_assert(data_size<IPC_SHARED_MEM_SIZE);
ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = set_vchi_handle(handle);
ipc->buffer[1] = data_size;
ipc->buffer[2] = flags;
ipc->buffer[3] = 0xbabeface;
ipc_signal(IPC_VCHI_BULK_RECEIVE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_BULK_RECEIVE_EVENT));
memcpy(data_dst,&ipc->buffer[4],data_size);
ipc_release(IPC_SEM_ACCESS);
return success;
}
int32_t ipc_vchi_msg_dequeue( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void *data,
uint32_t max_data_size_to_read,
uint32_t *actual_msg_size,
VCHI_FLAGS_T flags )
{
// vchi_msg_dequeue(handle,data,max_data_size_to_read,actual_msg_size,flags);
uint32_t events;
uint32_t read_size;
int32_t success=0;
os_assert(max_data_size_to_read<IPC_SHARED_MEM_SIZE);
ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = set_vchi_handle(handle);
ipc->buffer[1] = max_data_size_to_read;
ipc->buffer[2] = flags;
ipc->buffer[3] = 0xbabeface;
ipc_signal(IPC_VCHI_MSG_DEQUEUE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_DEQUEUE_EVENT));
read_size = ipc->buffer[1];
os_assert(read_size <= max_data_size_to_read);
memcpy(data,&ipc->buffer[4],read_size);
*actual_msg_size = read_size;
ipc_release(IPC_SEM_ACCESS);
return success;
}
int32_t ipc_vchi_bulk_queue_receive(/*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void * data_dst,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * bulk_handle )
{
//vchi_bulk_queue_receive(handle,data_dst,data_size,flags,bulk_handle);
int32_t events;
int32_t success=0;
os_assert(data_size<=KHDISPATCH_WORKSPACE_SIZE);
//os_assert(data_size == myIPC->bulk_buffer[0]);
myIPC->bulk_buffer[1] = data_size;
myIPC->bulk_buffer[2] = flags;
myIPC->bulk_buffer[3] = handle;
ipc_signal(IPC_VCHI_BULK_RECEIVE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_BULK_RECEIVE_EVENT));
#ifdef __linux__
os_assert(data_size<IPC_SHARED_BULK_SIZE);//make sure IPC_SHARED_MEM_SIZE <= KHDISPATCH_WORKSPACE_SIZE
#endif
memcpy(data_dst,(void*)myIPC->bulk_buffer[4],data_size);
#ifdef __linux__
ipc_signal(IPC_VCHI_BULK_WRITE_RELEASE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_BULK_WRITE_RELEASE_EVENT));
#else
vcos_semaphore_post(&myIPC->bulk_write_lock);
#endif
return success;
}
// it is probably safe not to copy bulk data into shared memory buffer
int32_t ipc_vchi_bulk_queue_transmit( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
const void * data_src,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * bulk_handle )
{
//vchi_bulk_queue_transmit(handle,data_src,data_size,flags,bulk_handle);
uint32_t events;
int32_t success=0;
os_assert(data_size<=IPC_SHARED_BULK_SIZE);
#ifdef __linux__
ipc_signal(IPC_VCHI_BULK_WRITE_LOCK_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_BULK_WRITE_LOCK_EVENT));
#else
vcos_semaphore_wait(&myIPC->bulk_write_lock);
#endif
//server should already read out data and reset this flag
assert(myIPC->client_data_bulk_available_flag == 0);
myIPC->bulk_buffer[1] = data_size;
myIPC->bulk_buffer[2] = flags;
myIPC->bulk_buffer[3] = handle;
#ifndef __linux__
myIPC->bulk_buffer[4] = (uint32_t) data_src;
#else
memcpy(&myIPC->bulk_buffer[5],data_src,data_size);
myIPC->bulk_buffer[4] = (uint32_t) &myIPC->bulk_buffer[5];
#endif
ipc_signal(IPC_VCHI_BULK_QUEUE_TRANSMIT_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_BULK_QUEUE_TRANSMIT_EVENT));
return success;
}
// data is from merge buffer and copied to shared memory buffer
// when server has release
int32_t ipc_vchi_msg_queue(/*VCHI_SERVICE_HANDLE_T*/int32_t handle,
const void * data,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * msg_handle )
{
//vchi_msg_queue(handle,data,data_size,flags,msg_handle);
uint32_t events;
int32_t success=0;
#ifdef __linux__
ipc_signal(IPC_VCHI_CLIENT_CTRL_WRITE_LOCK_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_CLIENT_CTRL_WRITE_LOCK_EVENT));
#else
vcos_semaphore_wait(&myIPC->client_write_lock);
#endif
//server should already read out data and reset this flag
assert(myIPC->client_data_ctrl_available_flag == 0);
myIPC->buffer[1] = data_size;
myIPC->buffer[2] = flags;
myIPC->buffer[3] = handle;
memcpy(&myIPC->buffer[5],data,data_size);
myIPC->buffer[4] = (uint32_t) &myIPC->buffer[5];
ipc_signal(IPC_VCHI_MSG_QUEUE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_QUEUE_EVENT));
return success;
}
int32_t ipc_vchi_held_msg_release( VCHI_HELD_MSG_T *message )
{
//vchi_held_msg_release(message);
int32_t events;
int32_t success=0;
myIPC->buffer[1] = 0;
myIPC->buffer[2] = (uint32_t)message;
myIPC->buffer[3] = 0;
ipc_signal(IPC_VCHI_MSG_RELEASE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_RELEASE_EVENT));
return success;
}
int32_t ipc_vchi_held_msg_release( VCHI_HELD_MSG_T *message )
{
// vchi_held_msg_release(message);
int32_t events;
int32_t success=0;
// ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = 0;
ipc->buffer[1] = 0;
ipc->buffer[2] = (uint32_t)message;
ipc->buffer[3] = 0xbabeface;
ipc_signal(IPC_VCHI_MSG_RELEASE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_RELEASE_EVENT));
ipc_release(IPC_SEM_ACCESS);
return success;
}
/* Handle IPC message
* This message only tells indicator that its value is changed
* Actual value is stored in sharedmem
*/
int ipc_handle(GR_EVENT * e)
{
int ret;
struct tbus_message msg;
DBGMSG("indicatord: ipc_handle\n");
ret = tbus_get_message(&msg);
if (ret < 0)
return -1;
switch (msg.type) {
case TBUS_MSG_SIGNAL:
/* we received a signal */
ipc_signal(&msg);
break;
}
tbus_msg_free(&msg);
return 0;
}
int32_t ipc_vchi_msg_queue(/*VCHI_SERVICE_HANDLE_T*/int32_t handle,
const void * data,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * msg_handle )
{
// vchi_msg_queue(handle,data,data_size,flags,msg_handle);
uint32_t events;
ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = set_vchi_handle(handle);
ipc->buffer[1] = data_size;
ipc->buffer[2] = flags;
ipc->buffer[3] = 0xbabeface;
memcpy(&ipc->buffer[4],data,data_size);
ipc_signal(IPC_VCHI_MSG_QUEUE_EVENT);
ipc_wait(&events);
ipc_release(IPC_SEM_ACCESS);
return 0;
}
int32_t ipc_vchi_msg_dequeue( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
void *data,
uint32_t max_data_size_to_read,
uint32_t *actual_msg_size,
VCHI_FLAGS_T flags )
{
//vchi_msg_dequeue(handle,data,max_data_size_to_read,actual_msg_size,flags);
uint32_t events;
uint32_t read_size;
int32_t success=0;
assert(0); //should not be here
os_assert(max_data_size_to_read<IPC_SHARED_CTRL_SIZE);
myIPC->buffer[1] = max_data_size_to_read;
myIPC->buffer[2] = flags;
myIPC->buffer[3] = handle;
myIPC->buffer[4] = (uint32_t) data; //copy to user provided address directly
ipc_signal(IPC_VCHI_MSG_DEQUEUE_EVENT);
ipc_wait(&events);
os_assert(events == (1<<IPC_VCHI_MSG_DEQUEUE_EVENT));
read_size = myIPC->buffer[0];
os_assert(read_size <= max_data_size_to_read);
#ifdef __linux__
memcpy(data,&myIPC->buffer[4],read_size);
#endif
*actual_msg_size = read_size;
return success;
}
int32_t ipc_vchi_bulk_queue_transmit( /*VCHI_SERVICE_HANDLE_T*/int32_t handle,
const void * data_src,
uint32_t data_size,
VCHI_FLAGS_T flags,
void * bulk_handle )
{
// vchi_bulk_queue_transmit(handle,data_src,data_size,flags,bulk_handle);
uint32_t events;
int32_t success=0;
os_assert(data_size<=IPC_SHARED_MEM_SIZE);
ipc_aquire(IPC_SEM_ACCESS);
ipc->buffer[0] = set_vchi_handle(handle);
ipc->buffer[1] = data_size;
ipc->buffer[2] = flags;
ipc->buffer[3] = 0xbabeface;
memcpy(&ipc->buffer[4],data_src,data_size);
ipc_signal(IPC_VCHI_BULK_QUEUE_TRANSMIT_EVENT);
ipc_wait(&events);
ipc_release(IPC_SEM_ACCESS);
return 0;
}
