VCOSPRE_ VCOS_STATUS_T VCOSPOST_ vcos_thread_create_classic(VCOS_THREAD_T *thread,
const char *name,
void *(*entry)(void *arg),
void *arg,
void *stack,
VCOS_UNSIGNED stacksz,
VCOS_UNSIGNED priaff,
VCOS_UNSIGNED timeslice,
VCOS_UNSIGNED autostart)
{
VCOS_THREAD_ATTR_T attrs;
vcos_thread_attr_init(&attrs);
vcos_thread_attr_setstacksize(&attrs, stacksz);
vcos_thread_attr_setpriority(&attrs, priaff & ~_VCOS_AFFINITY_MASK);
vcos_thread_attr_setaffinity(&attrs, priaff & _VCOS_AFFINITY_MASK);
(void)timeslice;
(void)autostart;
if (VCOS_CAN_SET_STACK_ADDR)
{
vcos_thread_attr_setstack(&attrs, stack, stacksz);
}
return vcos_thread_create(thread, name, &attrs, entry, arg);
}
VCOS_STATUS_T vcos_thread_create_classic(VCOS_THREAD_T *thread,
const char *name,
void *(*entry)(void* arg),
void *arg,
void *stack,
VCOS_UNSIGNED stacksz,
VCOS_UNSIGNED priaff,
VCOS_UNSIGNED timeslice,
VCOS_UNSIGNED autostart)
{
VCOS_STATUS_T status;
VCOS_THREAD_ATTR_T attrs;
VCOS_UNSIGNED priority = priaff & ~VCOS_AFFINITY_MASK;
VCOS_UNSIGNED affinity = priaff & VCOS_AFFINITY_MASK;
vcos_thread_attr_init(&attrs);
#if VCOS_CAN_SET_STACK_ADDR
vcos_thread_attr_setstack(&attrs, stack, stacksz);
#else
vcos_assert(stack == 0);
#endif
vcos_assert((autostart == VCOS_START) || (autostart == VCOS_NO_START));
vcos_thread_attr_setpriority(&attrs, priority);
vcos_thread_attr_setaffinity(&attrs, affinity);
vcos_thread_attr_settimeslice(&attrs, timeslice);
vcos_thread_attr_setautostart(&attrs, autostart);
status = vcos_thread_create(thread, name, &attrs, entry, arg);
return status;
}
/***********************************************************
* Name: os_thread_begin
*
* Arguments: VCOS_THREAD_T *thread
* OS_THREAD_FUNC_T func
* int stack
* void *data
* const char *name
*
* Description: Routine to create and start a thread or task for VCHIQ
* Thread function has different arguments (void*) to os_thread_start (int,void*).
*
*
* Returns: int32_t - success == 0
*
***********************************************************/
void os_thread_begin(VCOS_THREAD_T *thread, void (*func)(void*), int stack, void *data, const char *name)
{
VCOS_THREAD_ATTR_T attrs;
VCOS_STATUS_T status;
vcos_thread_attr_init(&attrs);
vcos_thread_attr_setstacksize(&attrs, stack);
vcos_thread_attr_setpriority(&attrs, 5); /* FIXME: should not be hardcoded */
vcos_thread_attr_settimeslice(&attrs, 20); /* FIXME: should not be hardcoded */
status = vcos_thread_create(thread, name, &attrs, (VCOS_THREAD_ENTRY_FN_T)func, data);
vcos_assert(status == VCOS_SUCCESS);
}
void vchiq_init_state(VCHIQ_STATE_T *state, VCHIQ_CHANNEL_T *local, VCHIQ_CHANNEL_T *remote)
{
VCOS_THREAD_ATTR_T attrs;
char threadname[8];
static int id = 0;
vcos_assert(is_pow2(VCHIQ_CHANNEL_SIZE));
vcos_assert(is_pow2(VCHIQ_NUM_CURRENT_BULKS));
vcos_assert(is_pow2(VCHIQ_NUM_SERVICE_BULKS));
vcos_assert(sizeof(VCHIQ_HEADER_T) == 8); /* we require this for consistency between endpoints */
memset(state, 0, sizeof(VCHIQ_STATE_T));
state->id = id++;
/*
initialize events and mutex
*/
vcos_event_create(&state->connect, "vchiq");
vcos_mutex_create(&state->mutex, "vchiq");
/*
initialize channel pointers
*/
state->local = local;
state->remote = remote;
vchiq_init_channel(local);
/*
bring up slot handler thread
*/
vcos_thread_attr_init(&attrs);
vcos_thread_attr_setstacksize(&attrs, VCHIQ_SLOT_HANDLER_STACK);
vcos_thread_attr_setpriority(&attrs, 5); /* FIXME: should not be hardcoded */
vcos_thread_attr_settimeslice(&attrs, 20); /* FIXME: should not be hardcoded */
strcpy(threadname, "VCHIQ-0");
threadname[6] += state->id % 10;
vcos_thread_create(&state->slot_handler_thread, threadname,
&attrs, slot_handler_func, state);
/* Indicate readiness to the other side */
local->initialised = 1;
}
bool khrn_worker_init(void)
{
#ifndef KHRN_WORKER_USE_LLAT
VCOS_THREAD_ATTR_T attr;
#endif
vcos_assert(!inited);
khrn_worker_enter_pos = 0;
khrn_worker_exit_pos_0 = 0;
khrn_worker_exit_pos_1 = 0;
khrn_worker_msg.post = msgs;
khrn_worker_msg.done_it = msgs;
khrn_worker_msg.cleanup = msgs;
#ifdef KHRN_WORKER_USE_LLAT
llat_i = khrn_llat_register(khrn_worker_llat_callback);
vcos_assert(llat_i != -1);
#else
if (vcos_event_create(&event, "khrn_worker_event") != VCOS_SUCCESS) {
return false;
}
exit_thread = false;
vcos_thread_attr_init(&attr);
vcos_thread_attr_setpriority(&attr, THREAD_PRIORITY);
#if !defined(V3D_LEAN)
switch (vcos_thread_get_affinity(vcos_thread_current())) {
case VCOS_AFFINITY_CPU0: vcos_thread_attr_setaffinity(&attr, VCOS_AFFINITY_CPU1); break;
case VCOS_AFFINITY_CPU1: vcos_thread_attr_setaffinity(&attr, VCOS_AFFINITY_CPU0); break;
}
vcos_thread_attr_setstacksize(&attr, THREAD_STACK_SIZE);
#endif /* V3D_LEAN */
if (vcos_thread_create(&thread, "khrn_worker_thread", &attr, khrn_worker_main, NULL) != VCOS_SUCCESS) {
vcos_event_delete(&event);
return false;
}
#endif
inited = true;
return true;
}
