int main (int argc, const char **argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
int success = -1;
char response[ 128 ];
if (!is_filed_running())
{
printf("vcfiled not running\n");
exit(-1);
}
vcos_init();
vcos_set_args(argc, argv);
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
return -1;
}
// initialise the OS abstraction layer
os_init();
vcos_log("vchi_initialise");
success = vchi_initialise( &global_initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vcos_log("vchi_connect");
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_gencmd_init (global_initialise_instance, &global_connection, 1);
vc_vchi_dispmanx_init (global_initialise_instance, &global_connection, 1);
vc_vchi_tv_init (global_initialise_instance, &global_connection, 1);
vc_vchi_cec_init (global_initialise_instance, &global_connection, 1);
vc_vchi_bufman_init (global_initialise_instance, &global_connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
vcos_log("VMCS services initialized.");
message_queue_init ();
host_app_message_handler (PLATFORM_MSG_INIT, 0, 0);
dispatch_messages ();
vcos_deinit ();
return 0;
}
int32_t vc_gpuserv_init( void )
{
VCHIQ_SERVICE_PARAMS_T vchiq_params;
VCOS_STATUS_T status = VCOS_ENXIO;
VCHIQ_STATUS_T vchiq_status;
vcos_once(&gpuserv_client_once, init_once);
vcos_mutex_lock(&gpuserv_client.lock);
if (gpuserv_client.refcount++ > 0)
{
/* Already initialised so nothing to do */
vcos_mutex_unlock(&gpuserv_client.lock);
return VCOS_SUCCESS;
}
vcos_log_set_level(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE);
vcos_log_register("gpuserv", VCOS_LOG_CATEGORY);
vcos_log_trace("%s: starting initialisation", VCOS_FUNCTION);
/* Initialise a VCHIQ instance */
vchiq_status = vchiq_initialise(&gpuserv_client_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: failed to initialise vchiq: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
vchiq_status = vchiq_connect(gpuserv_client_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: failed to connect to vchiq: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
memset(&vchiq_params, 0, sizeof(vchiq_params));
vchiq_params.fourcc = VCHIQ_MAKE_FOURCC('G','P','U','S');
vchiq_params.callback = gpuserv_callback;
vchiq_params.userdata = NULL;
vchiq_params.version = 1;
vchiq_params.version_min = 1;
vchiq_status = vchiq_open_service(gpuserv_client_vchiq_instance, &vchiq_params, &gpuserv_client.service);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: could not open vchiq service: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
vcos_mutex_unlock(&gpuserv_client.lock);
return 0;
error:
vcos_mutex_unlock(&gpuserv_client.lock);
return -1;
}
int32_t vchi_initialise(VCHI_INSTANCE_T *instance_handle)
{
VCHIQ_INSTANCE_T instance;
VCHIQ_STATUS_T status;
status = vchiq_initialise(&instance);
*instance_handle = (VCHI_INSTANCE_T)instance;
return vchiq_status_to_vchi(status);
}
int main(int argc, char *const *argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
int success;
progname = argv[0];
const char *sep = strrchr(progname, '/');
if (sep)
progname = sep+1;
parse_args(argc, argv);
if (!foreground)
{
log_stderr = 0; // must log to syslog if we're a daemon
daemonize();
}
vcfile_lock();
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
logmsg(LOG_ERR, "%s: failed to open vchiq instance\n", argv[0]);
return -1;
}
// initialise the OS abstraction layer
os_init();
success = vchi_initialise( &global_initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_filesys_init (global_initialise_instance, &global_connection, 1);
for (;;)
{
sleep(INT_MAX);
}
vcos_deinit ();
return 0;
}
void vc_vchi_khronos_init()
{
VCOS_STATUS_T status = vcos_event_create(&bulk_event, NULL);
assert(status == VCOS_SUCCESS);
if (vchiq_initialise(&khrn_vchiq_instance) != VCHIQ_SUCCESS)
{
KHRONOS_CLIENT_LOG("* failed to open vchiq device\n");
exit(1);
}
KHRONOS_CLIENT_LOG("gldemo: connecting\n");
if (vchiq_connect(khrn_vchiq_instance) != VCHIQ_SUCCESS)
{
KHRONOS_CLIENT_LOG("* failed to connect\n");
exit(1);
}
if (vchiq_open_service(khrn_vchiq_instance, FOURCC_KHAN, khan_callback, NULL, &vchiq_khan_service) != VCHIQ_SUCCESS ||
vchiq_open_service(khrn_vchiq_instance, FOURCC_KHRN, khrn_callback, NULL, &vchiq_khrn_service) != VCHIQ_SUCCESS ||
vchiq_open_service(khrn_vchiq_instance, FOURCC_KHHN, khhn_callback, NULL, &vchiq_khhn_service) != VCHIQ_SUCCESS)
{
KHRONOS_CLIENT_LOG("* failed to add service - already in use?\n");
exit(1);
}
vchiu_queue_init(&khrn_queue, 64);
vchiu_queue_init(&khhn_queue, 64);
KHRONOS_CLIENT_LOG("gldemo: connected\n");
/*
attach to process (there's just one)
*/
// bool success = client_process_attach();
// assert(success);
}
void bcm_host_init(void)
{
VCHIQ_INSTANCE_T vchiq_instance;
static int initted;
int success = -1;
char response[ 128 ];
if (initted)
return;
initted = 1;
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
exit(-1);
}
vcos_log("vchi_initialise");
success = vchi_initialise( &global_initialise_instance);
vcos_assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vcos_log("vchi_connect");
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_gencmd_init (global_initialise_instance, &global_connection, 1);
vc_vchi_dispmanx_init (global_initialise_instance, &global_connection, 1);
vc_vchi_tv_init (global_initialise_instance, &global_connection, 1);
vc_vchi_cec_init (global_initialise_instance, &global_connection, 1);
//vc_vchi_bufman_init (global_initialise_instance, &global_connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
}
MMAL_STATUS_T mmal_vc_init(void)
{
VCHIQ_SERVICE_PARAMS_T vchiq_params;
MMAL_BOOL_T vchiq_initialised = 0, waitpool_initialised = 0;
MMAL_BOOL_T service_initialised = 0;
MMAL_STATUS_T status = MMAL_EIO;
VCHIQ_STATUS_T vchiq_status;
int count;
vcos_once(&once, init_once);
vcos_mutex_lock(&client.lock);
count = client.refcount++;
if (count > 0)
{
/* Already initialised so nothing to do */
vcos_mutex_unlock(&client.lock);
return MMAL_SUCCESS;
}
vcos_log_register("mmalipc", VCOS_LOG_CATEGORY);
/* Initialise a VCHIQ instance */
vchiq_status = vchiq_initialise(&mmal_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
LOG_ERROR("failed to initialise vchiq");
status = MMAL_EIO;
goto error;
}
vchiq_initialised = 1;
vchiq_status = vchiq_connect(mmal_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
LOG_ERROR("failed to connect to vchiq");
status = MMAL_EIO;
goto error;
}
memset(&vchiq_params,0,sizeof(vchiq_params));
vchiq_params.fourcc = MMAL_CONTROL_FOURCC();
vchiq_params.callback = mmal_vc_vchiq_callback;
vchiq_params.userdata = &client;
vchiq_params.version = WORKER_VER_MAJOR;
vchiq_params.version_min = WORKER_VER_MINIMUM;
vchiq_status = vchiq_open_service(mmal_vchiq_instance, &vchiq_params, &client.service);
if (vchiq_status != VCHIQ_SUCCESS)
{
LOG_ERROR("could not open vchiq service");
status = MMAL_EIO;
goto error;
}
client.usecount = 1; /* usecount set to 1 by the open call. */
service_initialised = 1;
status = create_waitpool(&client.waitpool);
if (status != MMAL_SUCCESS)
{
LOG_ERROR("could not create wait pool");
goto error;
}
waitpool_initialised = 1;
if (vcos_mutex_create(&client.bulk_lock, "mmal client bulk lock") != VCOS_SUCCESS)
{
LOG_ERROR("could not create bulk lock");
status = MMAL_ENOSPC;
goto error;
}
client.inited = 1;
vcos_mutex_unlock(&client.lock);
/* assume we're not using VC immediately. Do this outside the lock */
mmal_vc_release();
return MMAL_SUCCESS;
error:
if (waitpool_initialised)
destroy_waitpool(&client.waitpool);
if (service_initialised)
{
client.usecount = 0;
vchiq_close_service(client.service);
}
if (vchiq_initialised)
vchiq_shutdown(mmal_vchiq_instance);
vcos_log_unregister(VCOS_LOG_CATEGORY);
client.refcount--;
vcos_mutex_unlock(&client.lock);
return status;
}
int main(int argc, char **argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
VCHI_INSTANCE_T initialise_instance;
VCHI_CONNECTION_T *connection;
int success = -1;
ILCS_CONFIG_T config;
char response[ 128 ];
printf("vcos_init\n");
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
return -1;
}
// initialise the OS abstraction layer
os_init();
// initialise the mphi driver
// mphi_get_func_table()->init();
// initialise the vchi layer
printf("vchi_initialise\n");
success = vchi_initialise( &initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)initialise_instance;
connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
printf("vchi_connect\n");
vchi_connect(&connection, 1, initialise_instance);
vc_vchi_gencmd_init(initialise_instance, &connection, 1);
vc_vchi_filesys_init(initialise_instance, &connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
printf("vcilcs_config\n");
vcilcs_config(&config);
printf("ilcs_init\n");
il_service_global = ilcs_init(vchiq_instance, &config, 0, host_OMX_SetILCSState);
printf("do_stripes\n");
do_stripes_default();
printf("do_blocks_test\n");
do_blocks_test();
printf("do_playback_api_test\n");
do_playback_api_test();
return 0;
}
static int
vc_watchdog_thread_func(void *v)
{
while (1) {
long rc;
unsigned long msg = WDOG_PING_MSG;
VCHIQ_ELEMENT_T elem = {
.data = (void *)&msg,
.size = sizeof(msg)
};
int time_remaining =
msecs_to_jiffies(WATCHDOG_PING_RATE_MS);
LOG_DBG("%s: waiting on disable blocker...", __func__);
if (wait_for_completion_interruptible(
&vc_wdog_state->wdog_disable_blocker) != 0) {
flush_signals(current);
continue;
}
LOG_DBG("%s: Waiting for VC to be awake...", __func__);
/* Ensure we only ping videocore when it's awake. Call use
* service in a mode which will not initiate a wakeup */
vchiq_use_service_no_resume(vc_wdog_state->service_handle);
if (!atomic_read(&vc_wdog_state->wdog_enabled)) {
vchiq_release_service(vc_wdog_state->service_handle);
LOG_DBG("%s: VC watchdog disabled", __func__);
continue;
}
if (mutex_lock_interruptible(&vc_wdog_state->wdog_ping_mutex)
!= 0) {
vchiq_release_service(vc_wdog_state->service_handle);
LOG_DBG("%s: Interrupted waiting for ping", __func__);
continue;
}
LOG_DBG("%s: Pinging videocore", __func__);
/* ping vc... */
vchiq_queue_message(vc_wdog_state->service_handle, &elem, 1);
LOG_DBG("%s: Waiting for ping response", __func__);
/* ...and wait for the response with a timeout */
rc = wait_for_completion_interruptible_timeout(
&vc_wdog_state->wdog_ping_response,
msecs_to_jiffies(VC_PING_RESPONSE_TIMEOUT_MS));
if (rc == 0) {
/* Timed out... BANG! */
vc_wdog_state->failed_pings++;
LOG_ERR("%s VideoCore Watchdog timed out!! (%d)",
__func__, vc_wdog_state->failed_pings);
if (vc_wdog_state->failed_pings >=
WATCHDOG_NO_RESPONSE_COUNT)
BUG();
} else if (rc < 0)
LOG_ERR("%s: Interrupted waiting for ping", __func__);
else {
LOG_DBG("%s: Ping response received", __func__);
vc_wdog_state->failed_pings = 0;
}
mutex_unlock(&vc_wdog_state->wdog_ping_mutex);
vchiq_release_service(vc_wdog_state->service_handle);
LOG_DBG("%s: waiting before pinging again...", __func__);
/* delay before running again */
do {
set_current_state(TASK_INTERRUPTIBLE);
time_remaining = schedule_timeout(time_remaining);
if (time_remaining) {
LOG_ERR("%s interrupted", __func__);
flush_signals(current);
}
} while (time_remaining > 0);
}
return 0;
}
static void vc_watchdog_connected_init(void)
{
int ret = 0;
VCHIQ_SERVICE_PARAMS_T vchiq_params = {
.fourcc = VCHIQ_MAKE_FOURCC('W', 'D', 'O', 'G'),
.callback = vc_watchdog_vchiq_callback,
.version = VC_WDOG_VERSION,
.version_min = VC_WDOG_VERSION_MIN
};
LOG_INFO("%s: start", __func__);
/* Initialize and create a VCHIQ connection */
ret = vchiq_initialise(&vc_wdog_state->initialise_instance);
if (ret != 0) {
LOG_ERR("%s: failed to initialise VCHIQ instance (ret=%d)",
__func__, ret);
ret = -EIO;
goto out;
}
ret = vchiq_connect(vc_wdog_state->initialise_instance);
if (ret != 0) {
LOG_ERR("%s: failed to connect VCHIQ instance (ret=%d)",
__func__, ret);
ret = -EIO;
goto out;
}
ret = vchiq_open_service(vc_wdog_state->initialise_instance,
&vchiq_params, &vc_wdog_state->service_handle);
if (ret != 0 || (vc_wdog_state->service_handle == 0)) {
LOG_ERR("%s: failed to add WDOG service: error %d",
__func__, ret);
ret = -EPERM;
goto out;
}
vchiq_release_service(vc_wdog_state->service_handle);
init_completion(&vc_wdog_state->wdog_ping_response);
mutex_init(&vc_wdog_state->wdog_ping_mutex);
init_completion(&vc_wdog_state->wdog_disable_blocker);
#ifdef ENABLE_VC_WATCHDOG
complete_all(&vc_wdog_state->wdog_disable_blocker);
atomic_set(&vc_wdog_state->wdog_enabled, 1);
#else
atomic_set(&vc_wdog_state->wdog_enabled, 0);
#endif
vc_wdog_state->wdog_thread = kthread_create(
&vc_watchdog_thread_func, NULL, "vc-watchdog");
if (vc_wdog_state->wdog_thread == NULL)
LOG_ERR("FATAL: couldn't create thread vc-watchdog");
else
wake_up_process(vc_wdog_state->wdog_thread);
out:
LOG_INFO("%s: end (ret=%d)", __func__, ret);
}
static int vc_watchdog_probe(struct platform_device *p_dev)
{
int ret = 0;
LOG_INFO("%s: start", __func__);
vc_wdog_state = kzalloc(sizeof(struct vc_watchdog_state), GFP_KERNEL);
if (!vc_wdog_state) {
ret = -ENOMEM;
goto exit;
}
vc_wdog_state->p_dev = p_dev;
vc_wdog_state->proc_entry = create_proc_entry(DRIVER_NAME, 0444, NULL);
if (vc_wdog_state->proc_entry == NULL) {
ret = -EFAULT;
goto out_efault;
}
vc_wdog_state->proc_entry->data = (void *)vc_wdog_state;
vc_wdog_state->proc_entry->write_proc = vc_watchdog_proc_write;
vchiq_add_connected_callback(vc_watchdog_connected_init);
goto exit;
out_efault:
kfree(vc_wdog_state);
vc_wdog_state = NULL;
exit:
LOG_INFO("%s: end, ret=%d", __func__, ret);
return ret;
}
