/* 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;
}
/*FUNCTION**********************************************************************
*
* Function Name : DMA_DRV_Init
* Description : Initialize DMA.
*
*END**************************************************************************/
dma_status_t DMA_DRV_Init(dma_state_t *state)
{
uint8_t i;
g_dma = state;
memset(g_dma, 0, sizeof(dma_state_t));
#if (USE_RTOS)
OSA_MutexCreate(&state->lock);
#endif
/* Enable DMA clock. */
for (i = 0; i < DMA_INSTANCE_COUNT; i ++)
{
CLOCK_SYS_EnableDmaClock(i);
}
/* Enable DMAMUX clock and init. */
for (i = 0; i < DMAMUX_INSTANCE_COUNT; i++)
{
CLOCK_SYS_EnableDmamuxClock(i);
DMAMUX_HAL_Init(g_dmamuxBase[i]);
}
return kStatus_DMA_Success;
}
/*!
* @cond DOXYGEN_PRIVATE
*
* @brief This function initializes caller allocated structure according to given
* numerical identifier of the timer.
*
* Called by hwtimer_init().
* Initializes the HWTIMER structure.
* Sets interrupt priority and registers ISR.
*
* @param hwtimer[in] Returns initialized hwtimer structure handle.
* @param pitId[in] Determines PIT module and pit channel.
* @param isrPrior[in] Interrupt priority for PIT
* @param data[in] Specific data. Not used in this timer.
*
* @return kHwtimerSuccess Success.
* @return kHwtimerInvalidInput When channel number does not exist in pit module.
* @return kHwtimerLockError When Locking failed.
* @return kHwtimerRegisterHandlerError When registration of the interrupt service routine failed.
*
* @see HWTIMER_SYS_PitDeinit
* @see HWTIMER_SYS_PitSetDiv
* @see HWTIMER_SYS_PitStart
* @see HWTIMER_SYS_PitStop
* @see HWTIMER_SYS_PitGetTime
* @see HWTIMER_SYS_PitIsr
* @see HWTIMER_SYS_PitIsrShared
*/
static _hwtimer_error_code_t HWTIMER_SYS_PitInit(hwtimer_t * hwtimer, uint32_t pitId, uint32_t isrPrior, void *data)
{
uint32_t pitChannel;
uint32_t baseAddr = g_pitBaseAddr[0];
if (FSL_FEATURE_PIT_TIMER_COUNT < pitId)
{
return kHwtimerInvalidInput;
}
assert(NULL != hwtimer);
/* We need to store pitId of timer in context struct */
hwtimer->llContext[0U] = pitId;
pitChannel = hwtimer->llContext[0U];
/* Un-gate pit clock */
CLOCK_SYS_EnablePitClock(0U);
/* Enable PIT module clock */
PIT_HAL_Enable(baseAddr);
/* Allows the timers to be stopped when the device enters the Debug mode. */
PIT_HAL_SetTimerRunInDebugCmd(baseAddr, false);
/* Disable timer and interrupt */
PIT_HAL_StopTimer(baseAddr, pitChannel);
PIT_HAL_SetIntCmd(baseAddr, pitChannel, false);
/* Clear any pending interrupt */
PIT_HAL_ClearIntFlag(baseAddr, pitChannel);
/* Create lock if does not exists*/
/* Enter critical section to avoid interrupt create locking */
OSA_EnterCritical(kCriticalDisableInt);
if (g_lock == NULL)
{
/* Initialize synchronization object */
if (kStatus_OSA_Success != OSA_MutexCreate(&g_lock_data))
{
return kHwtimerLockError;
}
g_lock = &g_lock_data;
}
OSA_ExitCritical(kCriticalDisableInt);
assert(g_lock == &g_lock_data);
/* Critical section. Access to global variable */
if (kStatus_OSA_Success != OSA_MutexLock(g_lock, OSA_WAIT_FOREVER))
{
return kHwtimerLockError;
}
/* Store hwtimer in global array */
g_hwtimersPit[pitChannel] = hwtimer;
if (kStatus_OSA_Success != OSA_MutexUnlock(g_lock))
{
return kHwtimerLockError;
}
/* Enable PIT interrupt.*/
if (kStatus_OSA_Success != OSA_InstallIntHandler(kpitIrqIds[pitChannel], HWTIMER_SYS_PitIsr))
{
return kHwtimerRegisterHandlerError;
}
PIT_HAL_SetIntCmd(baseAddr, pitChannel, true);
INT_SYS_EnableIRQ(kpitIrqIds[pitChannel]);
return kHwtimerSuccess;
}
/*FUNCTION**********************************************************************
*
* Function Name : TSI_DRV_Init
* Description : Initialize whole the TSI peripheral to be ready to read capacitance changes
* To initialize the TSI driver, the configuration structure should be handled.
*
*END**************************************************************************/
tsi_status_t TSI_DRV_Init(uint32_t instance, tsi_state_t * tsiState, const tsi_user_config_t * tsiUserConfig)
{
assert(instance < TSI_INSTANCE_COUNT);
TSI_Type * base = g_tsiBase[instance];
tsi_state_t * tsiSt = g_tsiStatePtr[instance];
/* Critical section. */
OSA_EnterCritical(kCriticalDisableInt);
/* Exit if current instance is already initialized. */
if(tsiSt)
{
/* End of critical section. */
OSA_ExitCritical(kCriticalDisableInt);
return kStatus_TSI_Initialized;
}
/* Save runtime structure pointer.*/
tsiSt = g_tsiStatePtr[instance] = tsiState;
/* Clear the state structure for this instance. */
memset(tsiSt, 0, sizeof(tsi_state_t));
/* Create the mutex used by whole driver. */
OSA_MutexCreate(&tsiSt->lock);
/* Create the mutex used by change mode function. */
OSA_MutexCreate(&tsiSt->lockChangeMode);
/* Critical section. Access to global variable */
if (kStatus_OSA_Success != OSA_MutexLock(&tsiSt->lock, OSA_WAIT_FOREVER))
{
/* End of critical section. */
OSA_ExitCritical(kCriticalDisableInt);
return kStatus_TSI_Error;
}
/* End of critical section. */
OSA_ExitCritical(kCriticalDisableInt);
tsiSt->opMode = tsi_OpModeNormal;
tsiSt->opModesData[tsiSt->opMode].config = *tsiUserConfig->config; /* Store the hardware configuration. */
tsiSt->pCallBackFunc = tsiUserConfig->pCallBackFunc;
tsiSt->usrData = tsiUserConfig->usrData;
tsiSt->isBlockingMeasure = false;
/* Un-gate TSI module clock */
CLOCK_SYS_EnableTsiClock(instance);
/* Initialize the interrupt sync object. */
OSA_SemaCreate(&tsiSt->irqSync, 0);
TSI_HAL_Init(base);
TSI_HAL_SetConfiguration(base, &tsiSt->opModesData[tsiSt->opMode].config);
TSI_HAL_EnableInterrupt(base);
TSI_HAL_EnableEndOfScanInterrupt(base);
TSI_HAL_EnableSoftwareTriggerScan(base);
/* Disable all electrodes */
tsiState->opModesData[tsiState->opMode].enabledElectrodes = 0;
/* Enable TSI interrupt on NVIC level. */
INT_SYS_EnableIRQ(g_tsiIrqId[instance]);
tsiSt->status = kStatus_TSI_Initialized;
/* End of critical section. */
OSA_MutexUnlock(&tsiSt->lock);
return kStatus_TSI_Success;
}
/**
* create RTOS structures for sending data via communication interface
*/
osa_status_t HostInterface_TxInit()
{
osa_status_t
status = OSA_MutexCreate(&uartTxAccessMutex);
if( kStatus_OSA_Success != status )
{
catch(3);
}
// Create Tx Message Queue
hostInterface_txQueueHnd = OSA_MsgQCreate (
hostInterface_txQueue,
gHostInterface_msgNum,
sizeof(hostInterface_packet_t) / sizeof(uint32_t)
);
if ( NULL == hostInterface_txQueueHnd )
{
return kStatus_OSA_Error;
}
#if defined( HEXIWEAR_DEBUG )
vQueueAddToRegistry( hostInterface_txQueueHnd, (signed char*)"TxQueue" );
#endif
// Create Tx-Data Task
status = OSA_TaskCreate (
HostInterface_TxTask,
(uint8_t*)"HostInterface_TxTask",
gHostInterfaceTxTaskStackSize_c,
HostInterface_TxTask_stack,
gHostInterfaceTxPriority_c,
(task_param_t)NULL,
false,
&HostInterface_TxTask_task_handler
);
if ( kStatus_OSA_Success != status )
{
catch(3);
}
// create Tx-OK Task
status = OSA_TaskCreate (
HostInterface_OkTask,
(uint8_t*)"HostInterface_OkTask",
gHostInterfaceOkTaskStackSize_c,
HostInterface_OkTask_stack,
gHostInterfaceOkPriority_c,
(task_param_t)NULL,
false,
&HostInterface_OkTask_task_handler
);
if ( kStatus_OSA_Success != status )
{
catch(3);
}
return (osa_status_t)status;
}
memcpy( (void*)&self, (void*)oledHandle, sizeof(self) );
memcpy( (void*)&settings, (void*)oledSettings, sizeof(settings) );
status = OLED_STATUS_SUCCESS;
/**
* set IRQ priority
*/
NVIC_SetPriority( HEXIWEAR_OLED_SPI_IRQn, HEXIWEAR_OLED_SPI_IRQ_PRIO );
NVIC_SetPriority( HEXIWEAR_OLED_DMA_RX_IRQn, HEXIWEAR_OLED_DMA_RX_IRQ_PRIO );
NVIC_SetPriority( HEXIWEAR_OLED_DMA_TX_IRQn, HEXIWEAR_OLED_DMA_TX_IRQ_PRIO );
// create mutex for using the spi comm
osa_status_t
spiStatus = OSA_MutexCreate( &spiAccessMutex );
/**
* power sequence
*/
power_TurnOFF( POWER_OLED );
OSA_TimeDelay(1);
GPIO_DRV_ClearPinOutput( settings.RSTpin );
OSA_TimeDelay(1);
GPIO_DRV_SetPinOutput( settings.RSTpin );
OSA_TimeDelay(1);
power_TurnON( POWER_OLED );
if ( OLED_STATUS_SUCCESS != OLED_SendCmd( OLED_CMD_SET_CMD_LOCK, FIRST_BYTE ) )
{
