Qortal
/
Brooklyn
mirror of https://github.com/Qortal/Brooklyn
3
0
Fork 1
Code Issues Projects Releases Wiki Activity
QortalOS Brooklyn for Raspberry Pi 4
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
38 Commits
1 Branch
22 Tags
720 MiB
 
 
 
 
 
 
Tree: 3c2979fb97
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3c2979fb97'
${ noResults }
Brooklyn/userland/interface/vmcs_host/vcilcs.c

1071 lines
34 KiB
Raw Blame History

/*
Copyright (c) 2012, Broadcom Europe Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
/* Project includes */
#include "vcinclude/common.h"
#include "interface/vchiq_arm/vchiq.h"
#include "interface/vmcs_host/khronos/IL/OMX_Component.h"
#include "interface/vmcs_host/vc_ilcs_defs.h"
#include "interface/vmcs_host/vcilcs.h"
#ifdef USE_VCHI
#include "interface/vchi/vchiq_wrapper.h"
#endif
#ifdef _VIDEOCORE
#include "applications/vmcs/ilcs/ilcs_common.h"
#endif
/******************************************************************************
Private types and defines.
******************************************************************************/
// number of threads that can use ilcs
#define ILCS_MAX_WAITING 8
// maximum number of retries to grab a wait slot,
// before the message is discarded and failure returned.
#define ILCS_WAIT_TIMEOUT 250
// maximum number of concurrent function calls that can
// be going at once. Each function call requires to copy
// the message data so we can dequeue the message from vchi
// before executing the function, otherwise ILCS may cause
// a deadlock. Must be larger than ILCS_MAX_WAITING
#define ILCS_MAX_NUM_MSGS (ILCS_MAX_WAITING+1)
#define ILCS_MSG_INUSE_MASK ((1<<ILCS_MAX_NUM_MSGS)-1)
typedef struct {
int xid;
void *resp;
int *rlen;
VCOS_EVENT_T event;
} ILCS_WAIT_T;
typedef enum {
NORMAL_SERVICE = 0, // process all messages
ABORTED_BULK = 1, // reject incoming calls
CLOSED_CALLBACK = 2, // quit thread and cleanup, use reaper, VC only
DEINIT_CALLED = 3, // quit thread and cleanup, no reaper
} ILCS_QUIT_T;
struct ILCS_SERVICE_T {
char name[12];
#ifdef USE_VCHIQ_ARM
VCHIQ_INSTANCE_T vchiq;
VCHIQ_SERVICE_HANDLE_T service;
#else
VCHIQ_STATE_T *vchiq;
#endif
int fourcc;
VCOS_TIMER_T timer;
volatile int timer_expired;
VCOS_THREAD_T thread;
int timer_needed;
ILCS_QUIT_T kill_service;
int use_memmgr;
ILCS_COMMON_T *ilcs_common;
ILCS_CONFIG_T config;
VCHIU_QUEUE_T queue;
VCOS_EVENT_T bulk_rx;
VCOS_SEMAPHORE_T send_sem; // for making control+bulk serialised
VCOS_MUTEX_T wait_mtx; // for protecting ->wait and ->next_xid
ILCS_WAIT_T wait[ILCS_MAX_WAITING];
int next_xid;
VCOS_EVENT_T wait_event; // for signalling when a wait becomes free
// don't need locking around msg_inuse as only touched by
// the server thread in ilcs_process_message
unsigned int msg_inuse;
unsigned char msg[ILCS_MAX_NUM_MSGS][VCHIQ_SLOT_SIZE];
uint32_t header_array[(sizeof(VCHIQ_HEADER_T)+8)/4];
};
/******************************************************************************
Private functions in this file.
Define as static.
******************************************************************************/
#ifdef USE_VCHIQ_ARM
static VCHIQ_STATUS_T ilcs_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header, VCHIQ_SERVICE_HANDLE_T service_user, void *bulk_user);
#else
static int ilcs_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header, void *service_user, void *bulk_user);
#endif
static void *ilcs_task(void *param);
static void ilcs_response(ILCS_SERVICE_T *st, uint32_t xid, const unsigned char *msg, int len );
static void ilcs_transmit(ILCS_SERVICE_T *st, uint32_t cmd, uint32_t xid,
const unsigned char *msg, int len,
const unsigned char *msg2, int len2);
static void ilcs_command(ILCS_SERVICE_T *st, uint32_t cmd, uint32_t xid, unsigned char *msg, int len);
static void ilcs_timer(void *param);
static int ilcs_process_message(ILCS_SERVICE_T *st, int block);
/* ----------------------------------------------------------------------
* initialise OpenMAX IL component service
* -------------------------------------------------------------------- */
#ifdef USE_VCHIQ_ARM
ILCS_SERVICE_T *ilcs_init(VCHIQ_INSTANCE_T state, void **connection, ILCS_CONFIG_T *config, int use_memmgr)
#else
ILCS_SERVICE_T *ilcs_init(VCHIQ_STATE_T *state, void **connection, ILCS_CONFIG_T *config, int use_memmgr)
#endif
{
int32_t i;
VCOS_THREAD_ATTR_T thread_attrs;
ILCS_SERVICE_T *st;
VCHIQ_SERVICE_PARAMS_T params;
st = vcos_malloc(sizeof(ILCS_SERVICE_T), "ILCS State");
if(!st)
goto fail_alloc;
memset(st, 0, sizeof(ILCS_SERVICE_T));
st->vchiq = state;
st->fourcc = VCHIQ_MAKE_FOURCC('I', 'L', 'C', 'S');
st->config = *config;
// setting this to true implies we have relocatable handles as
// buffer pointers, otherwise we interpret them to be real pointers
st->use_memmgr = use_memmgr;
// create semaphore for protecting wait/xid structures
if(vcos_mutex_create(&st->wait_mtx, "ILCS") != VCOS_SUCCESS)
goto fail_all;
// create smaphore for control+bulk protection
if(vcos_semaphore_create(&st->send_sem, "ILCS", 1) != VCOS_SUCCESS)
goto fail_send_sem;
// create event group for signalling when a waiting slot becomes free
if(vcos_event_create(&st->wait_event, "ILCS") != VCOS_SUCCESS)
goto fail_wait_event;
for(i=0; i<ILCS_MAX_WAITING; i++)
if(vcos_event_create(&st->wait[i].event, "ILCS") != VCOS_SUCCESS)
{
while(--i >= 0)
vcos_event_delete(&st->wait[i].event);
goto fail_wait_events;
}
if(vcos_timer_create(&st->timer, "ILCS", ilcs_timer, st) != VCOS_SUCCESS)
goto fail_timer;
// create the queue of incoming messages
if(!vchiu_queue_init(&st->queue, 256))
goto fail_queue;
// create the bulk receive event
if(vcos_event_create(&st->bulk_rx, "ILCS") != VCOS_SUCCESS)
goto fail_bulk_event;
// create an 'ILCS' service
#ifdef USE_VCHIQ_ARM
/* VCHIQ_ARM distinguishes between servers and clients. Use use_memmgr
parameter to detect usage by the client.
*/
memset(&params,0,sizeof(params));
params.fourcc = st->fourcc;
params.callback = ilcs_callback;
params.userdata = st;
params.version = VC_ILCS_VERSION;
params.version_min = VC_ILCS_VERSION;
if (use_memmgr == 0)
{
// Host side, which will connect to a listening VideoCore side
if (vchiq_open_service(st->vchiq, &params, &st->service) != VCHIQ_SUCCESS)
goto fail_service;
}
else
{
// VideoCore side, a listening service not connected
if (vchiq_add_service(st->vchiq, &params, &st->service) != VCHIQ_SUCCESS)
goto fail_service;
// On VC shutdown we defer calling vchiq_remove_service until after the callback has
// returned, so we require not to have the autoclose behaviour
vchiq_set_service_option(st->service, VCHIQ_SERVICE_OPTION_AUTOCLOSE, 0);
}
#else
#ifdef USE_VCHI
if(!vchiq_wrapper_add_service(st->vchiq, connection, st->fourcc, ilcs_callback, st))
goto fail_service;
#else
if(!vchiq_add_service(st->vchiq, st->fourcc, ilcs_callback, st))
goto fail_service;
#endif
#endif
if((st->ilcs_common = st->config.ilcs_common_init(st)) == NULL)
goto fail_ilcs_common;
vcos_thread_attr_init(&thread_attrs);
vcos_thread_attr_setstacksize(&thread_attrs, 4096);
snprintf(st->name, sizeof(st->name), "ILCS_%s", use_memmgr ? "VC" : "HOST");
if(vcos_thread_create(&st->thread, st->name, &thread_attrs, ilcs_task, st) != VCOS_SUCCESS)
goto fail_thread;
return st;
fail_thread:
st->config.ilcs_common_deinit(st->ilcs_common);
fail_ilcs_common:
#ifdef USE_VCHIQ_ARM
vchiq_remove_service(st->service);
#endif
fail_service:
vcos_event_delete(&st->bulk_rx);
fail_bulk_event:
vchiu_queue_delete(&st->queue);
fail_queue:
vcos_timer_delete(&st->timer);
fail_timer:
for(i=0; i<ILCS_MAX_WAITING; i++)
vcos_event_delete(&st->wait[i].event);
fail_wait_events:
vcos_event_delete(&st->wait_event);
fail_wait_event:
vcos_semaphore_delete(&st->send_sem);
fail_send_sem:
vcos_mutex_delete(&st->wait_mtx);
fail_all:
vcos_free(st);
fail_alloc:
return NULL;
}
/* ----------------------------------------------------------------------
* sends a message to the thread to quit
* -------------------------------------------------------------------- */
static void ilcs_send_quit(ILCS_SERVICE_T *st)
{
// We're closing, so tell the task to cleanup
VCHIQ_HEADER_T *header = (VCHIQ_HEADER_T *)st->header_array;
char *msg;
int i;
header->size = 8;
msg = header->data;
msg[0] = IL_SERVICE_QUIT & 0xff;
msg[1] = (IL_SERVICE_QUIT >> 8) & 0xff;
msg[2] = (IL_SERVICE_QUIT >> 16) & 0xff;
msg[3] = IL_SERVICE_QUIT >> 24;
vchiu_queue_push(&st->queue, header);
// force all currently waiting clients to wake up
for(i=0; i<ILCS_MAX_WAITING; i++)
if(st->wait[i].resp)
vcos_event_signal(&st->wait[i].event);
vcos_event_signal(&st->wait_event);
}
/* ----------------------------------------------------------------------
* deinitialises the OpenMAX IL Component Service.
* This is the usual way that the host side service shuts down, called
* from OMX_Deinit().
* -------------------------------------------------------------------- */
void ilcs_deinit(ILCS_SERVICE_T *st)
{
void *data;
st->kill_service = DEINIT_CALLED;
ilcs_send_quit(st);
vcos_thread_join(&st->thread, &data);
vcos_free(st);
}
/* ----------------------------------------------------------------------
* sets the wait event, to timeout blocked threads
* -------------------------------------------------------------------- */
static void ilcs_timer(void *param)
{
ILCS_SERVICE_T *st = (ILCS_SERVICE_T *) param;
vcos_assert(st->timer_expired == 0);
st->timer_expired = 1;
vcos_event_signal(&st->wait_event);
}
/* ----------------------------------------------------------------------
* returns pointer to common object
* -------------------------------------------------------------------- */
ILCS_COMMON_T *ilcs_get_common(ILCS_SERVICE_T *st)
{
return st->ilcs_common;
}
/* ----------------------------------------------------------------------
* whether the ilcsg thread is currently running
* returns 1 if the ilcsg is the current thread, 0 otherwise
* -------------------------------------------------------------------- */
int ilcs_thread_current(void *param)
{
ILCS_SERVICE_T *st = (ILCS_SERVICE_T *) param;
return vcos_thread_current() == &st->thread;
}
/* ----------------------------------------------------------------------
* called from the vchiq layer whenever an event happens.
* here, we are only interested in the 'message available' callback
* -------------------------------------------------------------------- */
#ifdef USE_VCHIQ_ARM
static VCHIQ_STATUS_T ilcs_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header, VCHIQ_SERVICE_HANDLE_T service_user, void *bulk_user)
{
ILCS_SERVICE_T *st = (ILCS_SERVICE_T *)VCHIQ_GET_SERVICE_USERDATA(service_user);
#else
static int ilcs_callback(VCHIQ_REASON_T reason, VCHIQ_HEADER_T *header, void *service_user, void *bulk_user)
{
ILCS_SERVICE_T *st = (ILCS_SERVICE_T *) service_user;
#endif
switch(reason) {
#ifdef USE_VCHIQ_ARM
case VCHIQ_SERVICE_OPENED:
{
#ifdef _VIDEOCORE
// We're on the VideoCore side and we've been connected to, so we need to spawn another
// listening service. Create another ILCS instance.
ILCS_CONFIG_T config;
ilcs_config(&config);
ilcs_init(st->vchiq, NULL, &config, st->use_memmgr);
#else
vcos_abort();
#endif
}
break;
case VCHIQ_SERVICE_CLOSED:
if(st && st->kill_service < CLOSED_CALLBACK)
{
st->kill_service = CLOSED_CALLBACK;
ilcs_send_quit(st);
}
break;
case VCHIQ_BULK_RECEIVE_ABORTED:
// bulk rx only aborted if we're about to close the service,
// so signal this now so that the person waiting for this
// bulk rx can return a failure to the user
st->kill_service = ABORTED_BULK;
vcos_event_signal(&st->bulk_rx);
break;
#endif
case VCHIQ_MESSAGE_AVAILABLE:
#ifndef _VIDEOCORE
{
static int queue_warn = 0;
int queue_len = st->queue.write - st->queue.read;
if (!queue_warn)
queue_warn = getenv("ILCS_WARN") ? (st->queue.size/2) : st->queue.size;
if (queue_len >= queue_warn)
{
if (queue_len == st->queue.size)
VCOS_ALERT("ILCS queue full");
else
VCOS_ALERT("ILCS queue len = %d", queue_len);
queue_warn = queue_warn + (st->queue.size - queue_warn)/2;
}
}
#endif
vchiu_queue_push(&st->queue, header);
break;
case VCHIQ_BULK_RECEIVE_DONE:
vcos_event_signal(&st->bulk_rx);
break;
default:
break;
}
#ifdef USE_VCHIQ_ARM
return VCHIQ_SUCCESS;
#else
return 1;
#endif
}
/* ----------------------------------------------------------------------
* send a message and wait for reply.
* repeats continuously, on each connection
* -------------------------------------------------------------------- */
static void *ilcs_task(void *param)
{
ILCS_SERVICE_T *st = (ILCS_SERVICE_T *) param;
int i;
st->config.ilcs_thread_init(st->ilcs_common);
while(st->kill_service < CLOSED_CALLBACK)
ilcs_process_message(st, 1);
// tidy up after ourselves
st->config.ilcs_common_deinit(st->ilcs_common);
#ifdef USE_VCHIQ_ARM
vchiq_remove_service(st->service);
#endif
vcos_event_delete(&st->bulk_rx);
vchiu_queue_delete(&st->queue);
vcos_timer_delete(&st->timer);
for(i=0; i<ILCS_MAX_WAITING; i++)
vcos_event_delete(&st->wait[i].event);
vcos_event_delete(&st->wait_event);
vcos_semaphore_delete(&st->send_sem);
vcos_mutex_delete(&st->wait_mtx);
if(st->kill_service == CLOSED_CALLBACK)
{
#ifdef _VIDEOCORE
// need vcos reaper thread to do join/free for us
vcos_thread_reap(&st->thread, vcos_free, st);
#else
// we've got a CLOSED callback from vchiq without ilcs_deinit being called.
// this shouldn't really happen, so we just want to abort at this point.
vcos_abort();
#endif
}
return 0;
}
/* ----------------------------------------------------------------------
* check to see if there are any pending messages
*
* if there are no messages, return 0
*
* otherwise, fetch and process the first queued message (which will
* be either a command or response from host)
* -------------------------------------------------------------------- */
#define UINT32(p) ((p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24))
static int ilcs_process_message(ILCS_SERVICE_T *st, int block)
{
unsigned char *msg;
VCHIQ_HEADER_T *header;
uint32_t i, msg_len, cmd, xid;
if(!block && vchiu_queue_is_empty(&st->queue))
return 0; // no more messages
header = vchiu_queue_pop(&st->queue);
msg = (unsigned char *) header->data;
cmd = UINT32(msg);
xid = UINT32(msg+4);
msg += 8;
msg_len = header->size - 8;
if(cmd == IL_RESPONSE)
{
ilcs_response(st, xid, msg, msg_len);
#ifdef USE_VCHIQ_ARM
vchiq_release_message(st->service, header);
#else
vchiq_release_message(st->vchiq, header);
#endif
}
else if(cmd == IL_SERVICE_QUIT)
{
return 1;
}
else
{
// we can only handle commands if we have space to copy the message first
if(st->msg_inuse == ILCS_MSG_INUSE_MASK)
{
// this shouldn't happen, since we have more msg slots than the
// remote side is allowed concurrent clients. this is classed
// as a failure case, so we discard the message knowing that things
// will surely lock up fairly soon after.
vcos_assert(0);
return 1;
}
i = 0;
while(st->msg_inuse & (1<<i))
i++;
st->msg_inuse |= (1<<i);
memcpy(st->msg[i], msg, msg_len);
#ifdef USE_VCHIQ_ARM
vchiq_release_message(st->service, header);
#else
vchiq_release_message(st->vchiq, header);
#endif
ilcs_command(st, cmd, xid, st->msg[i], msg_len);
// mark the message copy as free
st->msg_inuse &= ~(1<<i);
}
return 1;
}
/* ----------------------------------------------------------------------
* received response to an ILCS command
* -------------------------------------------------------------------- */
static void ilcs_response(ILCS_SERVICE_T *st, uint32_t xid, const unsigned char *msg, int len)
{
ILCS_WAIT_T *wait = NULL;
int i, copy = len;
// atomically retrieve given ->wait entry
vcos_mutex_lock(&st->wait_mtx);
for (i=0; i<ILCS_MAX_WAITING; i++) {
wait = &st->wait[i];
if(wait->resp && wait->xid == xid)
break;
}
vcos_mutex_unlock(&st->wait_mtx);
if(i == ILCS_MAX_WAITING) {
// something bad happened, someone has sent a response back
// when the caller said they weren't expecting a response
vcos_assert(0);
return;
}
// check that we have enough space to copy into.
// if we haven't the user can tell by the updated rlen value.
if(len > *wait->rlen)
copy = *wait->rlen;
*wait->rlen = len;
// extract command from fifo and place in response buffer.
memcpy(wait->resp, msg, copy);
vcos_event_signal(&wait->event);
}
/* ----------------------------------------------------------------------
* helper function to transmit an ilcs command/response + payload
* -------------------------------------------------------------------- */
static void ilcs_transmit(ILCS_SERVICE_T *st, uint32_t cmd, uint32_t xid,
const unsigned char *msg, int len,
const unsigned char *msg2, int len2)
{
VCHIQ_ELEMENT_T vec[4];
int32_t count = 3;
vec[0].data = &cmd;
vec[0].size = sizeof(cmd);
vec[1].data = &xid;
vec[1].size = sizeof(xid);
vec[2].data = msg;
vec[2].size = len;
if(msg2)
{
vec[3].data = msg2;
vec[3].size = len2;
count++;
}
#ifdef USE_VCHIQ_ARM
vchiq_queue_message(st->service, vec, count);
#else
vchiq_queue_message(st->vchiq, st->fourcc, vec, count);
#endif
}
/* ----------------------------------------------------------------------
* received response to an ILCS command
* -------------------------------------------------------------------- */
static void
ilcs_command(ILCS_SERVICE_T *st, uint32_t cmd, uint32_t xid, unsigned char *msg, int len)
{
// execute this function call
unsigned char resp[VC_ILCS_MAX_CMD_LENGTH];
unsigned char *rbuf = resp;
int rlen = -1;
IL_FN_T fn;
if(cmd >= IL_FUNCTION_MAX_NUM) {
vcos_assert(0);
return;
}
fn = st->config.fns[cmd];
if(!fn) {
vcos_assert(0);
return;
}
// for one method we allow the response to go in the same slot as the
// msg, since it wants to return quite a big amount of debug information
// and we know this is safe.
if(cmd == IL_GET_DEBUG_INFORMATION)
{
int max = VCHIQ_SLOT_SIZE - 8;
IL_GET_DEBUG_INFORMATION_EXECUTE_T *exe = (IL_GET_DEBUG_INFORMATION_EXECUTE_T *) msg;
if(exe->len > max)
exe->len = max;
rbuf = msg;
}
// at this point we are executing in ILCS task context
// NOTE: this can cause ilcs_execute_function() calls from within guts of openmaxil!
fn(st->ilcs_common, msg, len, rbuf, &rlen);
// make sure rlen has been initialised by the function
vcos_assert(rlen != -1);
if(rlen > 0)
ilcs_transmit(st, IL_RESPONSE, xid, rbuf, rlen, NULL, 0);
}
/**
* send a string to the host side IL component service. if resp is NULL
* then there is no response to this call, so we should not wait for one.
*
* returns 0 on successful call made, -1 on failure to send call.
* on success, the response is written to 'resp' pointer
*
* @param data function parameter data
* @param len length of function parameter data
* @param data optional second function parameter data
* @param len2 length of second function parameter data
* @param msg_mem_handle option mem handle to be sent as part of msg data
* @param msg_offset Offset with msg mem handle
* @param msg_len Length of msg mem handle
* @param bulk_mem_handle Mem handle sent using VCHI bulk transfer
* @param bulk_offset Offset within memory handle
* @param bulk_len Length of bulk transfer
*
* -------------------------------------------------------------------- */
static int ilcs_execute_function_ex(ILCS_SERVICE_T *st, IL_FUNCTION_T func,
void *data, int len,
void *data2, int len2,
VCHI_MEM_HANDLE_T bulk_mem_handle, void *bulk_offset, int bulk_len,
void *resp, int *rlen)
{
ILCS_WAIT_T *wait = NULL;
int num = 0;
uint32_t xid;
if(st->kill_service)
return -1;
// need to atomically find free ->wait entry
vcos_mutex_lock(&st->wait_mtx);
// if resp is NULL, we do not expect any response
if(resp == NULL) {
xid = st->next_xid++;
}
else
{
int i;
if(st->timer_needed++ == 0)
{
vcos_timer_set(&st->timer, 10);
}
// we try a number of times then give up with an error message
// rather than just deadlocking
// Note: the real reason for the timeout is nothing to do with hardware
// errors, but is to ensure that if the ILCS thread is calling this function
// (because the client makes an OMX call from one of the callbacks) then
// the queue of messages from VideoCore still gets serviced.
for (i=0; i<ILCS_WAIT_TIMEOUT; i++) {
num = 0;
while(num < ILCS_MAX_WAITING && st->wait[num].resp != NULL)
num++;
if(num < ILCS_MAX_WAITING || i == ILCS_WAIT_TIMEOUT-1)
break;
// the previous time round this loop, we woke up because the timer
// expired, so restart it
if (st->timer_expired)
{
st->timer_expired = 0;
vcos_timer_set(&st->timer, 10);
}
// might be a fatal error if another thread is relying
// on this call completing before it can complete
// we'll pause until we can carry on and hope that's sufficient.
vcos_mutex_unlock(&st->wait_mtx);
// if we're the ilcs thread, then the waiters might need
// us to handle their response, so try and clear those now
if(vcos_thread_current() == &st->thread)
{
while (vcos_event_try(&st->wait_event) != VCOS_SUCCESS)
{
while(ilcs_process_message(st, 0))
if(st->kill_service >= CLOSED_CALLBACK)
return -1;
if (vcos_event_try(&st->wait_event) == VCOS_SUCCESS)
break;
vcos_sleep(1);
}
}
else
{
vcos_event_wait(&st->wait_event);
}
vcos_mutex_lock(&st->wait_mtx);
}
if(--st->timer_needed == 0)
{
vcos_timer_cancel(&st->timer);
st->timer_expired = 0;
}
if(num == ILCS_MAX_WAITING)
{
// failed to send message.
vcos_mutex_unlock(&st->wait_mtx);
return -1;
}
wait = &st->wait[num];
wait->resp = resp;
wait->rlen = rlen;
xid = wait->xid = st->next_xid++;
}
vcos_mutex_unlock(&st->wait_mtx);
if(bulk_len != 0)
vcos_semaphore_wait(&st->send_sem);
ilcs_transmit(st, func, xid, data, len, data2, len2);
if(bulk_len != 0)
{
#ifdef USE_VCHIQ_ARM
vchiq_queue_bulk_transmit_handle(st->service, bulk_mem_handle, bulk_offset, bulk_len, NULL);
#else
vchiq_queue_bulk_transmit(st->vchiq, st->fourcc, bulk_mem_handle, bulk_offset, bulk_len, NULL);
#endif
vcos_semaphore_post(&st->send_sem);
}
if(!wait)
{
// nothing more to do
return 0;
}
if(vcos_thread_current() != &st->thread)
{
// block waiting for response
vcos_event_wait(&wait->event);
}
else
{
// since we're the server task, to receive our own response code
// we need to keep reading messages from the other side. In
// addition, our function executing on the host may also call
// functions on VideoCore before replying, so we need to handle
// all incoming messages until our response arrives.
for (;;)
{
// wait->sem will not be released until we process the response message
// so handle one incoming message
ilcs_process_message(st, 1);
// did the last message release wait->sem ?
if(st->kill_service >= CLOSED_CALLBACK || vcos_event_try(&wait->event) == VCOS_SUCCESS)
break;
}
}
// safe to do the following - the assignment of NULL is effectively atomic
wait->resp = NULL;
vcos_event_signal(&st->wait_event);
return st->kill_service >= CLOSED_CALLBACK ? -1 : 0;
}
int ilcs_execute_function(ILCS_SERVICE_T *st, IL_FUNCTION_T func, void *data, int len, void *resp, int *rlen)
{
return ilcs_execute_function_ex(st, func, data, len, NULL, 0, VCHI_MEM_HANDLE_INVALID, 0, 0, resp, rlen);
}
/* ----------------------------------------------------------------------
* send a buffer via the IL component service.
* -------------------------------------------------------------------- */
OMX_ERRORTYPE ilcs_pass_buffer(ILCS_SERVICE_T *st, IL_FUNCTION_T func, void *reference,
OMX_BUFFERHEADERTYPE *pBuffer)
{
IL_PASS_BUFFER_EXECUTE_T exe;
IL_BUFFER_BULK_T fixup;
IL_RESPONSE_HEADER_T resp;
VCHI_MEM_HANDLE_T mem_handle = VCHI_MEM_HANDLE_INVALID;
void *ret = NULL, *data2 = NULL, *bulk_offset = NULL;
int len2 = 0, bulk_len = 0;
OMX_U8 *ptr = NULL;
int rlen = sizeof(resp);
if(st->kill_service)
return OMX_ErrorHardware;
if((func == IL_EMPTY_THIS_BUFFER && pBuffer->pInputPortPrivate == NULL) ||
(func == IL_FILL_THIS_BUFFER && pBuffer->pOutputPortPrivate == NULL))
{
// return this to pass conformance
// the actual error is using a buffer that hasn't be registered with usebuffer/allocatebuffer
return OMX_ErrorIncorrectStateOperation;
}
if((pBuffer->nFlags & OMX_BUFFERFLAG_EXTRADATA) || pBuffer->nFilledLen)
ptr = st->config.ilcs_mem_lock(pBuffer) + pBuffer->nOffset;
exe.reference = reference;
memcpy(&exe.bufferHeader, pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
exe.bufferLen = pBuffer->nFilledLen;
if(pBuffer->nFlags & OMX_BUFFERFLAG_EXTRADATA)
{
// walk down extra-data's appended to the buffer data to work out their length
OMX_U8 *end = ptr + pBuffer->nAllocLen - pBuffer->nOffset;
OMX_OTHER_EXTRADATATYPE *extra =
(OMX_OTHER_EXTRADATATYPE *) (((uint32_t) (ptr + pBuffer->nFilledLen + 3)) & ~3);
OMX_BOOL b_corrupt = OMX_FALSE;
OMX_EXTRADATATYPE extra_type;
do
{
// sanity check the extra data before doing anything with it
if(((uint8_t *)extra) + sizeof(OMX_OTHER_EXTRADATATYPE) > end ||
((uint8_t *)extra) + extra->nSize > end ||
extra->nSize < sizeof(OMX_OTHER_EXTRADATATYPE) ||
(extra->nSize & 3))
{
// shouldn't happen. probably a problem with the component
b_corrupt = OMX_TRUE;
break;
}
extra_type = extra->eType;
extra = (OMX_OTHER_EXTRADATATYPE *) (((uint8_t *) extra) + extra->nSize);
}
while(extra_type != OMX_ExtraDataNone);
// if corrupt then drop the extra data since we can't do anything with it
if(b_corrupt)
pBuffer->nFlags &= ~OMX_BUFFERFLAG_EXTRADATA;
else
exe.bufferLen = ((uint8_t *) extra) - ptr;
}
// check that the buffer fits in the allocated region
if(exe.bufferLen + pBuffer->nOffset > pBuffer->nAllocLen)
{
if(ptr != NULL)
st->config.ilcs_mem_unlock(pBuffer);
return OMX_ErrorBadParameter;
}
if(exe.bufferLen)
{
if(exe.bufferLen + sizeof(IL_PASS_BUFFER_EXECUTE_T) <= VC_ILCS_MAX_INLINE)
{
// Pass the data in the message itself, and avoid doing a bulk transfer at all...
exe.method = IL_BUFFER_INLINE;
data2 = ptr;
len2 = exe.bufferLen;
}
else
{
// Pass the misaligned area at the start at end inline within the
// message, and the bulk of the message using a separate bulk
// transfer
const uint8_t *start = ptr;
const uint8_t *end = start + exe.bufferLen;
const uint8_t *round_start = (const OMX_U8*)ILCS_ROUND_UP(start);
const uint8_t *round_end = (const OMX_U8*)ILCS_ROUND_DOWN(end);
exe.method = IL_BUFFER_BULK;
if(st->use_memmgr)
{
bulk_offset = (void *) (round_start-(ptr-pBuffer->nOffset));
mem_handle = (VCHI_MEM_HANDLE_T) pBuffer->pBuffer;
}
else
bulk_offset = (void *) round_start;
bulk_len = round_end-round_start;
if((fixup.headerlen = round_start - start) > 0)
memcpy(fixup.header, start, fixup.headerlen);
if((fixup.trailerlen = end - round_end) > 0)
memcpy(fixup.trailer, round_end, fixup.trailerlen);
data2 = &fixup;
len2 = sizeof(fixup);
}
}
else
{
exe.method = IL_BUFFER_NONE;
}
// when used for callbacks to client, no need for response
// so only set ret when use component to component
if(func == IL_EMPTY_THIS_BUFFER || func == IL_FILL_THIS_BUFFER)
ret = &resp;
if(ilcs_execute_function_ex(st, func, &exe, sizeof(IL_PASS_BUFFER_EXECUTE_T),
data2, len2, mem_handle, bulk_offset, bulk_len, ret, &rlen) < 0 || rlen != sizeof(resp))
{
ret = &resp;
resp.err = OMX_ErrorHardware;
}
if(ptr != NULL)
st->config.ilcs_mem_unlock(pBuffer);
return ret ? resp.err : OMX_ErrorNone;
}
/* ----------------------------------------------------------------------
* receive a buffer via the IL component service.
* -------------------------------------------------------------------- */
OMX_BUFFERHEADERTYPE *ilcs_receive_buffer(ILCS_SERVICE_T *st, void *call, int clen, OMX_COMPONENTTYPE **pComp)
{
IL_PASS_BUFFER_EXECUTE_T *exe = call;
OMX_BUFFERHEADERTYPE *pHeader = exe->bufferHeader.pInputPortPrivate;
OMX_U8 *dest, *pBuffer = pHeader->pBuffer;
OMX_PTR *pAppPrivate = pHeader->pAppPrivate;
OMX_PTR *pPlatformPrivate = pHeader->pPlatformPrivate;
OMX_PTR *pInputPortPrivate = pHeader->pInputPortPrivate;
OMX_PTR *pOutputPortPrivate = pHeader->pOutputPortPrivate;
if(st->kill_service)
return NULL;
vcos_assert(pHeader);
memcpy(pHeader, &exe->bufferHeader, sizeof(OMX_BUFFERHEADERTYPE));
*pComp = exe->reference;
pHeader->pBuffer = pBuffer;
pHeader->pAppPrivate = pAppPrivate;
pHeader->pPlatformPrivate = pPlatformPrivate;
pHeader->pInputPortPrivate = pInputPortPrivate;
pHeader->pOutputPortPrivate = pOutputPortPrivate;
dest = st->config.ilcs_mem_lock(pHeader) + pHeader->nOffset;
if(exe->method == IL_BUFFER_BULK)
{
IL_BUFFER_BULK_T *fixup = (IL_BUFFER_BULK_T *) (exe+1);
VCHI_MEM_HANDLE_T mem_handle = VCHI_MEM_HANDLE_INVALID;
void *bulk_offset;
int32_t bulk_len = exe->bufferLen - fixup->headerlen - fixup->trailerlen;
vcos_assert(clen == sizeof(IL_PASS_BUFFER_EXECUTE_T) + sizeof(IL_BUFFER_BULK_T));
if(st->use_memmgr)
{
mem_handle = (VCHI_MEM_HANDLE_T) pBuffer;
bulk_offset = (void*)(pHeader->nOffset + fixup->headerlen);
}
else
bulk_offset = dest + fixup->headerlen;
#ifdef USE_VCHIQ_ARM
vchiq_queue_bulk_receive_handle(st->service, mem_handle, bulk_offset, bulk_len, NULL);
#else
vchiq_queue_bulk_receive(st->vchiq, st->fourcc, mem_handle, bulk_offset, bulk_len, NULL);
#endif
vcos_event_wait(&st->bulk_rx);
if(st->kill_service)
{
// the bulk receive was aborted, and we're about the quit, however this function
// being called means the buffer header control message made it across, so we
// need to think that this buffer is on VideoCore. So pretend this is all okay,
// but zero the buffer contents so we don't process bad data
pHeader->nFilledLen = 0;
pHeader->nFlags = 0;
}
else if(fixup->headerlen || fixup->trailerlen)
{
uint8_t *end = dest + exe->bufferLen;
if(fixup->headerlen)
memcpy(dest, fixup->header, fixup->headerlen);
if(fixup->trailerlen)
memcpy(end-fixup->trailerlen, fixup->trailer, fixup->trailerlen);
}
}
else if(exe->method == IL_BUFFER_INLINE)
{
IL_BUFFER_INLINE_T *buffer = (IL_BUFFER_INLINE_T *) (exe+1);
vcos_assert(clen == sizeof(IL_PASS_BUFFER_EXECUTE_T) + exe->bufferLen);
memcpy(dest, buffer->buffer, exe->bufferLen);
}
else if(exe->method == IL_BUFFER_NONE)
{
vcos_assert(clen == sizeof(IL_PASS_BUFFER_EXECUTE_T));
}
else
{
vcos_assert(0);
}
st->config.ilcs_mem_unlock(pHeader);
return pHeader;
}