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 */