97 baseAddr = g_flexioBase[instance];
102 FLEXIO_Init(baseAddr);
106 FLEXIO_SetEnable(baseAddr,
true);
108 deviceState->resourceAllocation = 0U;
112 deviceState->flexioStatePtr[count] = NULL;
132 baseAddr = g_flexioBase[instance];
134 FLEXIO_Init(baseAddr);
157 baseAddr = g_flexioBase[instance];
159 FLEXIO_Init(baseAddr);
176 uint8_t resourceAllocation;
181 baseAddr = g_flexioBase[instance];
183 step = driver->resourceCount;
184 size = FLEXIO_GetShifterNum(baseAddr);
186 mask = (uint8_t)((1U << step) - 1U);
191 if ((resourceAllocation & mask) == 0U)
194 driver->resourceIndex = count;
219 mask = (uint8_t)((1U << driver->resourceCount) - 1U);
220 mask <<= driver->resourceIndex;
236 uint8_t resourceCount;
237 uint8_t resourceIndex;
240 baseAddr = g_flexioBase[instance];
241 resourceCount = driver->resourceCount;
242 resourceIndex = driver->resourceIndex;
243 for (resource = resourceIndex; resource < (resourceIndex + resourceCount); resource++)
246 FLEXIO_SetShifterMode(baseAddr, resource, FLEXIO_SHIFTER_MODE_DISABLED);
247 FLEXIO_SetTimerMode(baseAddr, resource, FLEXIO_TIMER_MODE_DISABLED);
249 FLEXIO_SetShifterInterrupt(baseAddr, (uint8_t)(1U << resource),
false);
250 FLEXIO_SetShifterErrorInterrupt(baseAddr, (uint8_t)(1U << resource),
false);
251 FLEXIO_SetTimerInterrupt(baseAddr, (uint8_t)(1U << resource),
false);
252 FLEXIO_SetShifterDMARequest(baseAddr, (uint8_t)(1U << resource),
false);
254 FLEXIO_ClearShifterStatus(baseAddr, resource);
255 FLEXIO_ClearShifterErrorStatus(baseAddr, resource);
256 FLEXIO_ClearTimerStatus(baseAddr, resource);
271 flexio_common_state_t **flexioStatePtr;
285 if (flexioStatePtr[count] == NULL)
288 flexioStatePtr[count] = driver;
293 DEV_ASSERT(count < FEATURE_FLEXIO_MAX_SHIFTER_COUNT);
300 driver->instance = instance;
316 flexio_common_state_t **flexioStatePtr;
318 instance = driver->instance;
324 if (flexioStatePtr[count] == driver)
327 flexioStatePtr[count] = NULL;
331 DEV_ASSERT(count < FEATURE_FLEXIO_MAX_SHIFTER_COUNT);
340 #if (FLEXIO_INSTANCE_COUNT > 0U)
351 uint32_t resourceMask;
352 uint32_t shifterEvents;
353 uint32_t shifterErrorEvents;
354 uint32_t timerEvents;
355 uint32_t enabledInterrupts;
357 flexio_common_state_t *
const *driverList;
358 flexio_common_state_t *driverState;
361 baseAddr = g_flexioBase[instance];
364 enabledInterrupts = FLEXIO_GetAllShifterInterrupt(baseAddr);
365 shifterEvents = FLEXIO_GetAllShifterStatus(baseAddr) & enabledInterrupts;
366 enabledInterrupts = FLEXIO_GetAllShifterErrorInterrupt(baseAddr);
367 shifterErrorEvents = FLEXIO_GetAllShifterErrorStatus(baseAddr) & enabledInterrupts;
368 enabledInterrupts = FLEXIO_GetAllTimerInterrupt(baseAddr);
369 timerEvents = FLEXIO_GetAllTimerStatus(baseAddr) & enabledInterrupts;
375 driverState = driverList[count];
377 if ((driverState != NULL) && (driverState->isr != NULL))
380 resourceMask = ((1UL << driverState->resourceCount) - 1U) << driverState->resourceIndex;
382 if (((shifterEvents & resourceMask) != 0U) ||
383 ((shifterErrorEvents & resourceMask) != 0U) ||
384 ((timerEvents & resourceMask) != 0U))
387 (driverState->isr)(driverState);
status_t OSIF_MutexDestroy(const mutex_t *const pMutex)
Destroys a previously created mutex.
static status_t FLEXIO_DRV_Allocate(uint32_t instance, flexio_common_state_t *driver)
status_t OSIF_MutexUnlock(const mutex_t *const pMutex)
Unlocks a previously locked mutex.
status_t OSIF_MutexLock(const mutex_t *const pMutex, const uint32_t timeout)
Waits for a mutex and locks it.
FLEXIO_Type *const g_flexioBase[FLEXIO_INSTANCE_COUNT]
#define FLEXIO_INSTANCE_COUNT
#define FEATURE_FLEXIO_DMA_REQ_1
status_t FLEXIO_DRV_DeinitDriver(const flexio_common_state_t *driver)
void INT_SYS_DisableIRQ(IRQn_Type irqNumber)
Disables an interrupt for a given IRQ number.
status_t FLEXIO_DRV_Reset(uint32_t instance)
Resets the FlexIO device.
static void FLEXIO_DRV_ResourcesInit(uint32_t instance, const flexio_common_state_t *driver)
status_t OSIF_MutexCreate(mutex_t *const pMutex)
Create an unlocked mutex.
clock_names_t
Clock names.
const IRQn_Type g_flexioIrqId[FLEXIO_INSTANCE_COUNT]
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
#define FEATURE_FLEXIO_DMA_REQ_2
const uint8_t g_flexioDMASrc[FLEXIO_INSTANCE_COUNT][FEATURE_FLEXIO_MAX_SHIFTER_COUNT]
status_t FLEXIO_DRV_InitDriver(uint32_t instance, flexio_common_state_t *driver)
#define OSIF_WAIT_FOREVER
static void FLEXIO_DRV_Deallocate(uint32_t instance, const flexio_common_state_t *driver)
void FLEXIO_IRQHandler(void)
flexio_device_state_t * g_flexioDeviceStatePtr[FLEXIO_INSTANCE_COUNT]
status_t FLEXIO_DRV_DeinitDevice(uint32_t instance)
De-initializes the FlexIO device.
#define FEATURE_FLEXIO_DMA_REQ_0
void INT_SYS_EnableIRQ(IRQn_Type irqNumber)
Enables an interrupt for a given IRQ number.
#define FEATURE_FLEXIO_MAX_SHIFTER_COUNT
const clock_names_t g_flexioClock[FLEXIO_INSTANCE_COUNT]
#define FEATURE_FLEXIO_DMA_REQ_3
status_t FLEXIO_DRV_InitDevice(uint32_t instance, flexio_device_state_t *deviceState)
Initializes the FlexIO device.
IRQn_Type
Defines the Interrupt Numbers definitions.