/******************************************************
* Function definitions
******************************************************/
void *mem_align(size_t ptrSize, uint32_t alignment)
{
char gap; /* Variable to store difference between memory locations. */
/* Allocate more than enough memory. */
char *temp = (char *)OSA_MemAlloc(ptrSize + (alignment - 1));
if(temp == NULL)
{
return NULL; /* Return NULL if not enough space for allocation request. */
}
/* Create a pointer that is aligned correctly. */
char *ptr = (char *)(((uint32_t)temp + (alignment - 1)) & ~(uint32_t)(alignment - 1));
/* Calculate the gap between start of allocation and aligned pointer. */
gap = (char)((unsigned int)ptr - (unsigned int)temp);
if(gap)
{
ptr--; /* Decrement the pointer. */
*ptr = gap; /* Store gap size. */
ptr++; /* Return the pointer to aligned address. */
return (void *)ptr;
} /* If there exists a gap between allocated memory and aligned pointer. */
else
{
return (void *)ptr;
}/* If no gap. */
}
static int nio_dummy_init(void *init_data, void **dev_context, int *error) {
NIO_DUMMY_DEV_CONTEXT_STRUCT *context;
context = (NIO_DUMMY_DEV_CONTEXT_STRUCT*)OSA_MemAlloc(sizeof(NIO_DUMMY_DEV_CONTEXT_STRUCT));
OSA_SemaCreate(&context->lock, 1);
*dev_context = (void*)context;
return 0;
}
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)))
}
static int nio_serial_init(void *init_data, void **dev_context)
{
osa_status_t status;
NIO_SERIAL_DEV_CONTEXT_STRUCT *serial_dev_context = (NIO_SERIAL_DEV_CONTEXT_STRUCT *)dev_context;
NIO_SERIAL_INIT_DATA_STRUCT *init = (NIO_SERIAL_INIT_DATA_STRUCT*)init_data;
#if PLATFORM_LPUART_ENABLED
assert(init->UART_INSTANCE < HW_LPUART_INSTANCE_COUNT);
lpuart_user_config_t uartConfig =
#else
assert(init->UART_INSTANCE < HW_UART_INSTANCE_COUNT);
uart_user_config_t uartConfig =
#endif
{
.baudRate = init->BAUDRATE,
.parityMode = init->PARITY_MODE,
.stopBitCount = init->STOPBIT_COUNT,
.bitCountPerChar = init->BITCOUNT_PERCHAR,
};
serial_dev_context = (NIO_SERIAL_DEV_CONTEXT_STRUCT*) OSA_MemAlloc(sizeof(NIO_SERIAL_DEV_CONTEXT_STRUCT));
/* SDK HAL init */
#if PLATFORM_LPUART_ENABLED
if ( kStatus_UART_Success != LPUART_DRV_Init(init->UART_INSTANCE, &serial_dev_context->uart_state, &uartConfig))
{
errno = ENXIO;
}
/* LPUART handler interrupt installation */
status = OSA_InstallIntHandler(g_lpuartRxTxIrqId[init->UART_INSTANCE], init->handler);
if (kStatus_OSA_Success != status)
{
errno = ENXIO;
}
NVIC_SetPriority(g_lpuartRxTxIrqId[init->UART_INSTANCE], init->RXTX_PRIOR);
NVIC_EnableIRQ(g_lpuartRxTxIrqId[init->UART_INSTANCE]);
#else
if ( kStatus_UART_Success != UART_DRV_Init(init->UART_INSTANCE, &serial_dev_context->uart_state, &uartConfig))
{
errno = ENXIO;
}
/* UART handler interrupt installation */
status = OSA_InstallIntHandler(g_uartRxTxIrqId[init->UART_INSTANCE], init->handler);
if (kStatus_OSA_Success != status)
{
errno = ENXIO;
}
NVIC_SetPriority(g_uartRxTxIrqId[init->UART_INSTANCE], init->RXTX_PRIOR);
NVIC_EnableIRQ(g_uartRxTxIrqId[init->UART_INSTANCE]);
#endif
serial_dev_context->instance = init->UART_INSTANCE;
*dev_context = (void*)serial_dev_context;
return 0;
}
static int nio_serial_deinit(void *dev_context)
{
NIO_SERIAL_DEV_CONTEXT_STRUCT *serial_dev_context = (NIO_SERIAL_DEV_CONTEXT_STRUCT *)dev_context;
#if PLATFORM_LPUART_ENABLED
LPUART_DRV_Deinit(serial_dev_context->instance);
#else
UART_DRV_Deinit(serial_dev_context->instance);
#endif
OSA_MemFree(dev_context);
return 0;
}
static int nio_dummy_open(void *dev_context, const char *dev_name, int flags, void **fp_context, int *error) {
*fp_context = OSA_MemAlloc(sizeof(NIO_DUMMY_FP_CONTEXT_STRUCT));
return 0;
}
