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;
}
