static int basic_timeout(void)
{
int delay = 10;
#ifdef VCOS_TIMER_MARGIN_EARLY
int margin_early = VCOS_TIMER_MARGIN_EARLY;
int margin_late = VCOS_TIMER_MARGIN_LATE;
#else
int margin_early = SLACK;
int margin_late = SLACK;
#endif
VCOS_EVENT_FLAGS_T flags;
VCOS_STATUS_T st = vcos_event_flags_create(&flags, "test");
VCOS_UNSIGNED elapsed_time = vcos_get_ms(), actual;
st = vcos_event_flags_get(&flags, 1, VCOS_OR, delay, &actual);
if (st == VCOS_EAGAIN)
{
elapsed_time = vcos_get_ms()-elapsed_time;
if (((int) elapsed_time >= (delay - margin_early)) && ((int) elapsed_time <= (delay + margin_late)))
{
vcos_log("Good delay: %d ms", elapsed_time);
vcos_event_flags_delete(&flags);
return 1;
}
vcos_log("Wrong delay: %d ms, expected %d ms", elapsed_time, delay);
}
vcos_event_flags_delete(&flags);
return 0;
}
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;
}
static int simple_pingpong(void)
{
static VCOS_THREAD_T server, clients[N_CLIENTS];
unsigned long sent, received = 0;
void *psent = &sent;
int i;
VCOS_STATUS_T st;
VCOS_MSG_ENDPOINT_T self;
st = vcos_msgq_endpoint_create(&self,"test");
st = vcos_thread_create(&server, "server", NULL, simple_server, NULL);
for (i=0; i<N_CLIENTS; i++)
{
st = vcos_thread_create(&clients[i], "client", NULL, simple_client, NULL);
}
// wait for the clients to quit
for (i=0; i<N_CLIENTS; i++)
{
unsigned long rx;
void *prx = ℞
vcos_thread_join(&clients[i],prx);
received += rx;
}
// tell the server to quit
{
VCOS_MSG_T quit;
VCOS_MSGQUEUE_T *serverq = vcos_msgq_find("server");
vcos_assert(serverq != NULL);
vcos_log("client: sending quit");
vcos_msg_sendwait(serverq, VCOS_MSG_N_QUIT, &quit);
vcos_thread_join(&server,psent);
}
vcos_msgq_endpoint_delete(&self);
if (sent == received)
return 1;
else
{
vcos_log("bad: sent %d, received %d", sent, received);
return 0;
}
}
static int read_level(VCOS_LOG_LEVEL_T *level, const char **pstr, char sep)
{
char buf[16];
int ret = 1;
if (read_tok(buf,sizeof(buf),pstr,sep))
{
if (strcmp(buf,"error") == 0)
*level = VCOS_LOG_ERROR;
else if (strcmp(buf,"warn") == 0)
*level = VCOS_LOG_WARN;
else if (strcmp(buf,"warning") == 0)
*level = VCOS_LOG_WARN;
else if (strcmp(buf,"info") == 0)
*level = VCOS_LOG_INFO;
else if (strcmp(buf,"trace") == 0)
*level = VCOS_LOG_TRACE;
else
{
vcos_log("Invalid trace level '%s'\n", buf);
ret = 0;
}
}
else
{
ret = 0;
}
return ret;
}
static int multiple_timer_test(void)
{
int passed;
VCOS_TIMER_T timers[32];
int i;
memset(results,0,sizeof(results));
for (i=0; i<32; i++)
{
VCOS_STATUS_T st = vcos_timer_create(timers+i,"test",multi_pfn,&results[i]);
if (st != VCOS_SUCCESS)
return 0;
}
for (i=0; i<32; i++)
{
vcos_timer_set(timers+i,1+i*10);
}
vcos_sleep(i*20);
/* check each timer fired */
passed = 1;
for (i=0; i<32; i++)
{
if (!results[i])
{
vcos_log("timer %d failed to go off", i);
passed = 0;
}
vcos_timer_delete(timers+i);
}
return passed;
}
static int single_waiter_test()
{
VCOS_EVENT_FLAGS_T event;
WAITER_T waiter;
int passed = 1;
vcos_log("%s", __FUNCTION__);
if(vcos_event_flags_create(&event,"test") != VCOS_SUCCESS)
passed = 0;
if(passed && waiter_init(&waiter, &event, 1) < 0)
{
vcos_event_flags_delete(&event);
passed = 0;
}
if(passed)
{
run_waiter(&waiter, 0, 1, VCOS_OR_CONSUME, VCOS_EVENT_FLAGS_SUSPEND, 10, 1, VCOS_SUCCESS, 0, &passed);
run_waiter(&waiter, 10, 1, VCOS_OR_CONSUME, VCOS_EVENT_FLAGS_SUSPEND, 0, 1, VCOS_SUCCESS, 0, &passed);
run_waiter(&waiter, 0, 1, VCOS_OR_CONSUME, VCOS_EVENT_FLAGS_SUSPEND, 10, 3, VCOS_SUCCESS, 2, &passed);
run_waiter(&waiter, 0, 1, VCOS_OR_CONSUME, 20, 10, 2, VCOS_EAGAIN, 2, &passed);
run_waiter(&waiter, 10, 1, VCOS_OR_CONSUME, 10, 0, 2, VCOS_EAGAIN, 2, &passed);
waiter_deinit(&waiter, &passed);
vcos_event_flags_delete(&event);
}
return passed;
}
static int multiple_waiters_test()
{
WAITER_T waiter[3];
VCOS_EVENT_FLAGS_T event;
int i;
int passed = 1;
vcos_log("%s", __FUNCTION__);
if(vcos_event_flags_create(&event,"test") != VCOS_SUCCESS)
passed = 0;
i=0;
while(passed && (i < 3) && waiter_init(waiter+(i), &event, i) == 0)
{
i++;
}
if(i < 3) // tidy up if we failed to create all the waiter threads
{
while(--i >= 0)
{
waiter_deinit(waiter+i, &passed);
}
passed = 0;
}
if(passed)
{
for(i=0; i<sizeof(specs) / sizeof(specs[0]); i++)
{
vcos_log("running multiple test spec %d", i);
run_waiters(waiter, 3, NULL, specs[i].bitmask, specs[i].operation, specs[i].suspend,
specs[i].set_sleep, specs[i].set_bitmask, specs[i].expected, specs[i].after, &passed);
}
for(i=0; i<3; i++)
{
waiter_deinit(waiter+i, &passed);
}
vcos_event_flags_delete(&event);
}
return passed;
}
static void run_waiters(WAITER_T *waiter, int num, int *sleep, uint32_t *bitmask, VCOS_EVENTGROUP_OPERATION_T *operation,
int32_t *suspend, int set_sleep, uint32_t set_bitmask, VCOS_STATUS_T *expected, uint32_t after, int *passed)
{
int i;
uint32_t set;
VCOS_STATUS_T st;
for(i=0; i<num; i++)
{
waiter[i].sleep_first = sleep ? sleep[i] : 0;
waiter[i].bitmask = bitmask[i];
waiter[i].operation = operation[i];
waiter[i].suspend = suspend[i];
vcos_semaphore_post(&waiter[i].go);
}
if(set_sleep)
vcos_sleep(set_sleep);
vcos_log("ORring in 0x%x", set_bitmask);
vcos_event_flags_set(waiter[0].event, set_bitmask, VCOS_OR);
for(i=0; i<num; i++)
{
vcos_semaphore_wait(&waiter[i].done);
if(waiter[i].result != expected[i] || (waiter[i].result == VCOS_SUCCESS && waiter[i].retrieved_bits != set_bitmask))
*passed = 0;
}
st = vcos_event_flags_get(waiter[0].event, -1, VCOS_OR_CONSUME, 0, &set);
if (after == 0 && st != VCOS_EAGAIN)
{
// we were expecting to retrieve nothing this time, but instead we got something!
*passed = 0;
vcos_log("run_waiters: got unexpected events back afterwards");
}
else if (after && (st != VCOS_SUCCESS) && (set != after))
{
// we were expecting to retrieve something, but instead got nothing, or not the right thing!
vcos_log("run_waiters: got wrong events back afterwards");
*passed = 0;
}
}
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 );
}
}
void _vcos_assert(const char *file, int line, const char *fmt, ...)
{
char desc[512];
va_list ap;
va_start(ap,fmt);
vsprintf(desc, fmt, ap);
desc[sizeof(desc) - 1] = '\0'; /* The message may be too long, but we're aborting anyway */
vcos_log("assertion failed: %s:%d: %s", file, line, desc);
va_end(ap);
#if defined(_MSC_VER) // Visual C define equivalent types
__asm { int 3 }
#endif //#if defined(_MSC_VER) // Visual C define equivalent types
abort();
}
static void *simple_server(void *cxt)
{
int count = 0;
int alive = 1;
int refcount = 0;
VCOS_MSG_ENDPOINT_T self;
VCOS_STATUS_T st = vcos_msgq_endpoint_create(&self, "server");
vcos_assert(st == VCOS_SUCCESS);
while (alive)
{
VCOS_MSG_T *msg = vcos_msg_wait();
switch (msg->code)
{
case VCOS_MSG_N_OPEN:
refcount++;
vcos_msg_reply(msg);
break;
case VCOS_MSG_N_CLOSE:
refcount--;
vcos_msg_reply(msg);
break;
case MSG_N_MY_MSG:
{
struct my_msg_t *body = VCOS_MSG_DATA(msg);
body->i++;
vcos_msg_reply(msg);
count++;
}
break;
case VCOS_MSG_N_QUIT:
vcos_log("server: got quit request");
vcos_assert(refcount == 0);
vcos_msg_reply(msg);
alive = 0;
break;
default:
vcos_assert(0);
// keep things going
if ((msg->code & VCOS_MSG_REPLY_BIT) == 0)
vcos_msg_reply(msg);
}
}
vcos_msgq_endpoint_delete(&self);
return (void*)count;
}
static int read_level(VCOS_LOG_LEVEL_T *level, const char **pstr, char sep)
{
char buf[16];
int ret = 1;
if (read_tok(buf,sizeof(buf),pstr,sep))
{
if (vcos_string_to_log_level(buf,level) != VCOS_SUCCESS)
{
vcos_log("Invalid trace level '%s'\n", buf);
ret = 0;
}
}
else
{
ret = 0;
}
return ret;
}
static int sleeping(void)
{
int duration;
int ret = 1;
for (duration = 10; duration < 1000; duration *=2)
{
unsigned ticks = vcos_get_ms();
int delta;
vcos_sleep(duration);
ticks = vcos_get_ms()-ticks;
delta = ticks-duration;
if (abs(delta) > SLACK*(1000/VCOS_TICKS_PER_SECOND))
{
vcos_log("Got %d ticks, expected %d", ticks, duration);
ret = 0;
}
}
return ret;
}
void vcos_log_register(const char *name, VCOS_LOG_CAT_T *category)
{
const char *env;
VCOS_LOG_CAT_T *i;
memset(category, 0, sizeof(*category));
category->name = name;
category->level = VCOS_LOG_ERROR;
category->flags.want_prefix = 1;
vcos_mutex_lock(&lock);
/* is it already registered? */
for (i = vcos_logging_categories; i ; i = i->next )
{
if (i == category)
break;
}
if (!i)
{
/* not yet registered */
category->next = vcos_logging_categories;
vcos_logging_categories = category;
}
vcos_mutex_unlock(&lock);
/* Check to see if this log level has been enabled. Look for
* (<category:level>,)*
*
* VC_LOGLEVEL=ilcs:info,vchiq:warn
*/
env = _VCOS_LOG_LEVEL();
if (env)
{
do
{
char env_name[64];
VCOS_LOG_LEVEL_T level;
if (read_tok(env_name, sizeof(env_name), &env, ':') &&
read_level(&level, &env, ','))
{
if (strcmp(env_name, name) == 0)
{
category->level = level;
break;
}
}
else
{
if (!warned_loglevel)
{
vcos_log("VC_LOGLEVEL format invalid at %s\n", env);
warned_loglevel = 1;
}
return;
}
} while (env[0] != '\0');
}
}
void vcos_log_register(const char *name, VCOS_LOG_CAT_T *category)
{
const char *env;
VCOS_LOG_CAT_T *i;
category->name = name;
if ( category->level == VCOS_LOG_UNINITIALIZED )
{
category->level = VCOS_LOG_ERROR;
}
category->flags.want_prefix = (category != &dflt_log_category );
vcos_mutex_lock(&lock);
/* is it already registered? */
for (i = vcos_logging_categories; i ; i = i->next )
{
if (i == category)
{
i->refcount++;
break;
}
}
if (!i)
{
/* not yet registered */
category->next = vcos_logging_categories;
vcos_logging_categories = category;
category->refcount++;
vcos_log_platform_register(category);
}
vcos_mutex_unlock(&lock);
/* Check to see if this log level has been enabled. Look for
* (<category:level>,)*
*
* VC_LOGLEVEL=ilcs:info,vchiq:warn
*/
env = _VCOS_LOG_LEVEL();
if (env)
{
do
{
char env_name[64];
VCOS_LOG_LEVEL_T level;
if (read_tok(env_name, sizeof(env_name), &env, ':') &&
read_level(&level, &env, ','))
{
if (strcmp(env_name, name) == 0)
{
category->level = level;
break;
}
}
else
{
if (!warned_loglevel)
{
vcos_log("VC_LOGLEVEL format invalid at %s\n", env);
warned_loglevel = 1;
}
return;
}
} while (env[0] != '\0');
}
vcos_log_info( "Registered log category '%s' with level %s",
category->name,
vcos_log_level_to_string( category->level ));
}
void vcos_win32_report_error(void)
{
vcos_log("vcos: error %d", GetLastError());
}
