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