struct halide_thread *halide_spawn_thread(void (*f)(void *), void *closure) {
spawned_thread *t = (spawned_thread *)malloc(sizeof(spawned_thread));
t->f = f;
t->closure = closure;
t->stack = memalign(128, STACK_SIZE);
memset(&t->handle, 0, sizeof(t->handle));
qurt_thread_attr_t thread_attr;
qurt_thread_attr_init(&thread_attr);
qurt_thread_attr_set_stack_addr(&thread_attr, t->stack);
qurt_thread_attr_set_stack_size(&thread_attr, STACK_SIZE);
qurt_thread_attr_set_priority(&thread_attr, 100);
qurt_thread_create(&t->handle.val, &thread_attr, &spawn_thread_helper, t);
return (halide_thread *)t;
}
void ubootstrap_exception_handler(void)
{
qurt_thread_attr_t tattr;
unsigned int stackbase;
stackbase = (unsigned int)&uerr_task_stack_arr;
qurt_thread_attr_init (&tattr);
qurt_thread_attr_set_stack_size (&tattr, (UERR_TASK_STACK_SIZE -8));
qurt_thread_attr_set_stack_addr (&tattr, (void*)((stackbase + 7) & (~7)) );
qurt_thread_attr_set_priority (&tattr, wlPriority);
qurt_thread_attr_set_tcb_partition(&tattr, 1); // This task should reside in TCM Memory
qurt_thread_attr_set_name(&tattr, "uerr_ex");
(void)qurt_thread_create(&uerrr_task_thread_id, &tattr, uerr_exception_handler , NULL);
}
int UtimerCreateTestThread(void)
{
int ret_value = 0;
qurt_thread_attr_t tattr;
unsigned int stackbase;
stackbase = (unsigned int)&utimer_client_test_stack_arr;
qurt_thread_attr_init (&tattr);
qurt_thread_attr_set_stack_size (&tattr, (UTIMER_CLIENT_TEST_STACK_SIZE -8));
qurt_thread_attr_set_stack_addr (&tattr, (void*)((stackbase +7) &(~7)) );
qurt_thread_attr_set_tcb_partition(&tattr, 1); // This task should reside in TCM Memory
qurt_thread_attr_set_priority (&tattr, UTIMER_TEST_PRI-1);
qurt_thread_attr_set_name(&tattr,"UTIMER_TEST_CLIENT");
ret_value = qurt_thread_create(&utimer_test_id, &tattr, utimer_client_test, NULL);
return ret_value;
} /* UtimerCreateTestThread() */
int uCreateWorkerThread(unsigned int process_idx)
{
int ret_value = 0;
qurt_thread_attr_t tattr;
unsigned int stackbase;
char thread_name[20];
snprintf(thread_name, sizeof(thread_name), "UTIMER_CLIENT_%u", process_idx);
stackbase = (unsigned int)&utimer_client_stack_arr;
qurt_thread_attr_init (&tattr);
qurt_thread_attr_set_stack_size (&tattr, (UTIMER_CLIENT_STACK_SIZE -8));
qurt_thread_attr_set_stack_addr (&tattr, (void*)((stackbase + 7) & (~7)) );
qurt_thread_attr_set_priority (&tattr, UTIMER_CLIENT_PRI-1);
qurt_thread_attr_set_tcb_partition(&tattr, 1); // This task should reside in TCM Memory
qurt_thread_attr_set_name(&tattr, thread_name);
ret_value = qurt_thread_create(&utimer_worker_thread_id, &tattr, UTimerCallbackHandler, NULL);
return ret_value;
} /* uCreateWorkerThread() */
boolean CreateWaitThread(void)
{
boolean ret = TRUE;
int ret_value = 0;
qurt_thread_attr_t tattr;
unsigned int stackbase;
stackbase = (unsigned int)diag_lsm_stack;
qurt_thread_attr_init (&tattr);
qurt_thread_attr_set_stack_size (&tattr, ((4096*8) -8));
qurt_thread_attr_set_stack_addr (&tattr, (void*)((stackbase +7) &(~7)) );
qurt_thread_attr_set_priority (&tattr, DIAG_PRI-1);
qurt_thread_attr_set_name(&tattr,"DIAG_LSM");
ret_value = qurt_thread_create(&thread_id, &tattr,Diag_LSM_RxThread, NULL);
if(ret_value == QURT_EFAILED )
{
ret = FALSE;
}
return ret;
}/* CreateWaitThread() */
void qup_manager_test_init(void)
{
static qurt_anysignal_t qupm_qmi_client_sig;
static qurt_thread_attr_t qupm_qmi_client_thread_attr;
static qurt_thread_t qupm_qmi_client_tcb;
// QUP Manager Test Client
DEBUG_PRINTF("%s: Initialization...pid is %d\n", __func__, qurt_getpid());
static char qupm_qmi_client_stack[QUPM_QMI_CLNT_STACK_SIZE];
qurt_anysignal_init(&qupm_qmi_client_sig);
qurt_thread_attr_init(&qupm_qmi_client_thread_attr);
qurt_thread_attr_set_name(&qupm_qmi_client_thread_attr, "QUPMQmiTest");
qurt_thread_attr_set_priority(&qupm_qmi_client_thread_attr, 10);
qurt_thread_attr_set_stack_size(&qupm_qmi_client_thread_attr, QUPM_QMI_CLNT_STACK_SIZE);
qurt_thread_attr_set_stack_addr(&qupm_qmi_client_thread_attr, qupm_qmi_client_stack);
#ifdef QMI_TEST
qurt_thread_create(&qupm_qmi_client_tcb, &qupm_qmi_client_thread_attr,
qup_manager_qmi_client_thread, NULL);
#else
qurt_thread_create(&qupm_qmi_client_tcb, &qupm_qmi_client_thread_attr,
qup_manager_registration, NULL);
#endif
}
/**
API, Spawn Program Domain under Program Domain Monitor
*/
PD_MON_HANDLE pd_mon_spawn(PD_MON_RESTART* restart_p, PD_MON_NAME program, ...)
{
int i;
PD_MON_HANDLE rc;
va_list ap;
va_start(ap, program); // Variable Arguments Setup
qurt_pimutex_lock(&pd_mon_internal.mutex); // Callee Mutex Lock
pd_mon_internal.args_handle = PD_MON_ERROR; // Assume Failure Return Result
// Look for an unused status entry
for (i = 0; i < sizeof(pd_mon_internal.status)/sizeof(PD_MON_STATUS_T); i++)
{
if (pd_mon_internal.status[i].cid == PD_MON_STATUS_NO_CID)
{
break;
}
}
// Check if an unused status entry was located
if (sizeof(pd_mon_internal.status)/sizeof(PD_MON_STATUS_T) > i)
{
char name[PD_MON_NAME_MAX];
unsigned char* stack;
qurt_thread_t tid;
qurt_thread_attr_t attr;
// Check if we can obtain stack resource for the Program Monitor Context
if (NULL != (stack = malloc(PD_MON_STACK_SIZ))) // Attempt to allocate stack for the Program Monitor Context
{
strlcpy(name, "%", sizeof(name)); // Name the Program Monitor Context to reflect "%Program"
strlcat(name, program, sizeof(name));
qurt_thread_attr_init(&attr); // Init the Program Monitor Context
qurt_thread_attr_set_name(&attr, name);
qurt_thread_attr_set_stack_addr(&attr, stack);
qurt_thread_attr_set_stack_size(&attr, PD_MON_STACK_SIZ);
qurt_thread_attr_set_priority(&attr, qurt_thread_get_priority(qurt_thread_get_id()) - 1);
qurt_thread_attr_set_affinity(&attr, QURT_THREAD_ATTR_AFFINITY_DEFAULT);
if (NULL != restart_p)
{
pd_mon_internal.args_restart = *restart_p; // Passing Restart Argument
}
else
{
pd_mon_internal.args_restart = PD_MON_RESTART_ALWAYS; // Setting Default
}
qurt_anysignal_clear(&pd_mon_internal.signal, PD_MON_SIG_UNLOCK);
qurt_thread_create(&tid, &attr, PROGRAM_MONITOR, (void*)program); // Create Program Monitor Context
// NOTE: THIS WAIT IS UNDER MUTEX PROTECTION. THE PROGRAM MONITOR
// CONTEXT MUST RESPOND THAT IT HAS COMPLETED ITS UPDATE TO THE
// MUTEX PROTECTED INFORMATION. THE CREATION AND INITIALIZATION
// OF THE PROGRAM MONITOR CONTEXT IS CONSIDERED PROTECTED AS WELL.
qurt_anysignal_wait(&pd_mon_internal.signal, PD_MON_SIG_UNLOCK); // Wait for the Program Monitor Context to Signal it has a Return Value
}
}
rc = (PD_MON_HANDLE)pd_mon_internal.args_handle; // Return Value from Program Monitor Context
qurt_pimutex_unlock(&pd_mon_internal.mutex); // Callee Mutex Unlock
va_end(ap); // Variable Arguments End
return rc;
}
/*===========================================================================
FUNCTION uGPIOInt_ConfigureIST
DESCRIPTION This function spawns a single IST thread for handling
each GPIO interrupt.
PARAMETERS
Parameters : None.
DEPENDENCIES None.
RETURN VALUE DALResult
UGPIOINT_SUCCESS : If the IST was spawned successfully.
UGPIOINT_ERROR : If the IST Spawning encountered an error.
SIDE EFFECTS None.
==========================================================================*/
static int32 uGPIOInt_ConfigureIST(void)
{
int nResult;
unsigned int StackSize;
unsigned char * StackAddr;
nResult = 0;
/*
* Set the IST name to UGPIOIST
*/
snprintf(uGPIOIntData.aISTName,
(sizeof(unsigned char)*UGPIOIST_TASKNAME_SIZE), "UGPIOIST");
/*
* Initialize any thread attribute objects needed by the interrupt service thread.
*/
qurt_thread_attr_init (&uGPIOIntData.ThreadAttr);
/*
* Initialize any thread attribute and signal objects needed by
* the interrupt service thread.
*/
qurt_anysignal_init(&uGPIOIntData.ISTSignal);
/*
* 64 bit alignment of the stack ptr.
*/
StackAddr = (unsigned char *)
(((unsigned long)uGPIOIntData.aISTStack -1) & (~0x7)) + 0x8;
StackSize = (unsigned int)( UGPIOINT_IST_STACK_SIZE -
((unsigned long)StackAddr -
(unsigned long)uGPIOIntData.aISTStack) );
/*
* To ensure that the entire stack (start to end) is 64-bit aligned
* so the last odd bytes are dropped off.
*/
StackSize &= ~(0x7);
qurt_thread_attr_set_stack_size(&uGPIOIntData.ThreadAttr,
StackSize);
qurt_thread_attr_set_stack_addr (&uGPIOIntData.ThreadAttr,
(void *)StackAddr);
qurt_thread_attr_set_priority (&uGPIOIntData.ThreadAttr,
(unsigned short)UGPIOINT_PRIORITY);
qurt_thread_attr_set_tcb_partition(&uGPIOIntData.ThreadAttr,1); // This task should reside in TCM Memory for UGPIOInt Delivery.
qurt_thread_attr_set_name(&uGPIOIntData.ThreadAttr,
uGPIOIntData.aISTName);
nResult = qurt_thread_create((qurt_thread_t *)&uGPIOIntData.nThreadID,
&uGPIOIntData.ThreadAttr,
uGPIOInt_ISTMain,NULL);
if (nResult == QURT_EFATAL)
{
return UGPIOINT_ERROR;
}
return UGPIOINT_SUCCESS;
} /* END uGPIOInt_ConfigureIST */
