uint32_t OS_Task_create(task_start_t pstart, void* param, uint32_t pri, uint32_t stack_size, char* task_name, void* opt) { osa_status_t status; /* * For uC/OS, we should allocate memory for task stack. */ #if ((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII))) usb_adapter_task_struct* task_struct = OSA_MemAllocZero(sizeof(usb_adapter_task_struct)); if (!task_struct) { return (uint32_t)OS_TASK_ERROR; } task_struct->stack_mem = OSA_MemAlloc(stack_size); if(!task_struct->stack_mem) { OSA_MemFree(task_struct); return (uint32_t)OS_TASK_ERROR; } #if defined (FSL_RTOS_UCOSIII) task_struct->handler = OSA_MemAllocZero(sizeof(OS_TCB)); if(!task_struct->handler) { OSA_MemFree(task_struct->stack_mem); OSA_MemFree(task_struct); return (uint32_t)OS_TASK_ERROR; } #endif status = OSA_TaskCreate((task_t)pstart, (uint8_t*)task_name, stack_size, task_struct->stack_mem, pri, (task_param_t)param, false, &task_struct->handler); if (kStatus_OSA_Success == status) { return (uint32_t)task_struct; } else { return (uint32_t)OS_TASK_ERROR; } #else //((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII))) task_handler_t task_handler; status = OSA_TaskCreate((task_t) pstart, (uint8_t*) task_name, stack_size, NULL, pri, (task_param_t) param, false, &task_handler); if (kStatus_OSA_Success == status) { return (uint32_t) task_handler; } else { return (uint32_t) OS_TASK_ERROR; } #endif //((defined (FSL_RTOS_UCOSII)) || (defined (FSL_RTOS_UCOSIII))) }
/* * NOTE: The msg_size here is counted by words, not bytes! */ os_msgq_handle OS_MsgQ_create(uint32_t max_msg_number, uint32_t msg_size) { os_msgq_handle ret; #if defined (FSL_RTOS_UCOSII) uint8_t *p_tmp; uint32_t size = sizeof(msg_queue_t) + (msg_size*sizeof(int32_t)+sizeof(void*))*max_msg_number; #elif defined (FSL_RTOS_UCOSIII) uint8_t *p_tmp; uint32_t size = sizeof(msg_queue_t) + (msg_size*sizeof(int32_t))*max_msg_number; #elif defined (FSL_RTOS_MQX) uint32_t size = (SIZE_IN_MMT_UNITS(sizeof(LWMSGQ_STRUCT)) + SIZE_IN_MMT_UNITS((msg_size*sizeof(int32_t))*(max_msg_number))) * sizeof(_mqx_max_type); #elif defined (FSL_RTOS_FREE_RTOS) #else /* Bare metal by default. */ uint8_t *p_tmp; uint32_t size = sizeof(msg_queue_t) + sizeof(uint32_t) * max_msg_number * msg_size; #endif #if defined (FSL_RTOS_FREE_RTOS) msg_queue_t* msgq = NULL; #else msg_queue_t* msgq = (msg_queue_t*) OSA_MemAllocZero(size); if (!msgq) { return (msg_queue_handler_t) 0; } #endif /* initialize the msg_queue_t */ #if defined (FSL_RTOS_UCOSII) p_tmp = (uint8_t*)msgq; p_tmp += sizeof(msg_queue_t); msgq->msgTbl = (void**)p_tmp; p_tmp += max_msg_number*sizeof(void*); msgq->msgs = (uint32_t*)p_tmp; #elif defined (FSL_RTOS_UCOSIII) p_tmp = (uint8_t*)msgq; p_tmp += sizeof(msg_queue_t); msgq->msgs = (void*)p_tmp; #elif defined (FSL_RTOS_MQX) #elif defined (FSL_RTOS_FREE_RTOS) #else /* Bare metal by default. */ p_tmp = (uint8_t*) msgq; p_tmp += sizeof(msg_queue_t); msgq->queueMem = (uint32_t*) p_tmp; #endif ret = OSA_MsgQCreate(msgq, max_msg_number, msg_size); #if !defined (FSL_RTOS_FREE_RTOS) if (!ret) { OSA_MemFree(msgq); } #endif return ret; }
/* Mutex create and destroy */ os_mutex_handle OS_Mutex_create(void) { mutex_t *p_mutex = (mutex_t *) OSA_MemAllocZero(sizeof(mutex_t)); if (!p_mutex) { return (os_mutex_handle) 0; } if (kStatus_OSA_Success != OSA_MutexCreate(p_mutex)) { OSA_MemFree(p_mutex); return (os_mutex_handle) 0; } return (os_mutex_handle) p_mutex; }
/* Event create and destroy */ os_event_handle OS_Event_create(uint32_t flag) { event_t *p_event = (event_t *) OSA_MemAllocZero(sizeof(event_t)); if (!p_event) { return (os_event_handle) 0; } if (kStatus_OSA_Success != OSA_EventCreate(p_event, flag ? kEventAutoClear : kEventManualClear)) { OSA_MemFree(p_event); return (os_event_handle) 0; } return (os_event_handle) p_event; }
/* Semaphore create and destroy */ os_sem_handle OS_Sem_create(uint32_t initial_number) { semaphore_t *p_sem = (semaphore_t *) OSA_MemAllocZero(sizeof(semaphore_t)); if (!p_sem) { return (os_sem_handle) 0; } if (kStatus_OSA_Success != OSA_SemaCreate(p_sem, initial_number)) { OSA_MemFree(p_sem); return (os_sem_handle) 0; } return (os_sem_handle) p_sem; }
/*FUNCTION********************************************************************** * * Function Name : SND_RxInit * Description : Initialize the Rx soundcard. * The soundcard includes a controller and a codec. *END**************************************************************************/ snd_status_t SND_RxInit( sound_card_t * card, void * ctrl_config, void * codec_config, ctrl_state_t *state) { audio_controller_t *ctrl = &card->controller; audio_codec_t *codec = &card->codec; /* Allocate space for buffer */ audio_buffer_t *buffer = &card->buffer; /* Buffer size and block settings */ if ((buffer->blocks == 0) || (buffer->size == 0)) { buffer->blocks = AUDIO_BUFFER_BLOCK; buffer->size = AUDIO_BUFFER_BLOCK_SIZE; } #if SOUNDCARD_USE_STATIC_MEM buffer->buff = &s_rx_buffer[ctrl->instance][0]; #else buffer->buff = (uint8_t *)OSA_MemAllocZero(buffer->size * buffer->blocks); if(!buffer->buff) { return kStatus_SND_BufferAllocateFail; } #endif buffer->input_curbuff = buffer->buff; buffer->output_curbuff = buffer->buff; /* Initialize the status structure */ buffer->empty_block = buffer->blocks; buffer->full_block = 0; OSA_SemaCreate(&buffer->sem, 0); /* Initialize audio controller and codec */ ctrl->ops->Ctrl_RxInit(ctrl->instance, ctrl_config,state); codec->ops->Codec_Init((void *)codec->handler, codec_config); #if USEDMA EDMA_DRV_RequestChannel(kEDMAAnyChannel, ctrl->dma_source, &ctrl->dma_channel); EDMA_DRV_InstallCallback(&ctrl->dma_channel, SND_RxDmaCallback, (void *)card); #else ctrl->ops->Ctrl_RxRegisterCallback(ctrl->instance, SND_RxCallback, card); #endif return kStatus_SND_Success; }