/*FUNCTION**********************************************************************
*
* Function Name : I2C_DRV_SlaveInit
* Description : initializes the I2C module.
* This function will save the application callback info, turn on the clock of
* I2C instance, setup according to user configuration.
*
*END**************************************************************************/
void I2C_DRV_SlaveInit(uint32_t instance,
const i2c_slave_user_config_t * userConfigPtr,
i2c_slave_state_t * slave)
{
assert(slave);
assert(instance < HW_I2C_INSTANCE_COUNT);
uint32_t baseAddr = g_i2cBaseAddr[instance];
/* Exit if current instance is already initialized. */
if (g_i2cStatePtr[instance])
{
return;
}
/* Init driver instance structure */
memset(slave, 0, sizeof(i2c_slave_state_t));
slave->slaveListening = userConfigPtr->slaveListening;
slave->slaveCallback = userConfigPtr->slaveCallback;
slave->callbackParam = userConfigPtr->callbackParam;
/* Enable clock for I2C.*/
CLOCK_SYS_EnableI2cClock(instance);
/* Init instance to known state. */
I2C_HAL_Init(baseAddr);
/* Set slave address.*/
I2C_HAL_SetAddress7bit(baseAddr, userConfigPtr->address);
/* Save runtime structure pointer.*/
g_i2cStatePtr[instance] = slave;
/* Create Event for irqSync */
OSA_EventCreate(&slave->irqEvent, kEventAutoClear);
#if FSL_FEATURE_I2C_HAS_START_STOP_DETECT
/* Enable I2C START&STOP signal detect interrupt in the peripheral.*/
if(userConfigPtr->startStopDetect)
{
I2C_HAL_SetStartStopIntCmd(baseAddr,true);
}
#endif
#if FSL_FEATURE_I2C_HAS_STOP_DETECT
/* Enable STOP signal detect interrupt in the peripheral.*/
if(userConfigPtr->stopDetect)
{
I2C_HAL_SetStopIntCmd(baseAddr,true);
}
#endif
/* Enable I2C interrupt as default if setup slave listening mode */
I2C_HAL_SetIntCmd(baseAddr, slave->slaveListening);
/* Enable I2C interrupt from NVIC */
INT_SYS_EnableIRQ(g_i2cIrqId[instance]);
/* Enable the peripheral operation.*/
I2C_HAL_Enable(baseAddr);
}
/* 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;
}
/**
* create the event for the watch screen
*/
void watch_CreateLinkStateUpdateEvent()
{
OSA_EventCreate( &watch_event, kEventAutoClear );
}
/*FUNCTION**********************************************************************
*
* Function Name : SPI_DRV_DmaSlaveInit
* Description : Initializes the SPI module for slave mode.
* Saves the application callback info, turns on the clock to the module,
* enables the device, and enables interrupts. Sets the SPI to a slave mode.
*
*END**************************************************************************/
spi_status_t SPI_DRV_DmaSlaveInit(uint32_t instance, spi_dma_slave_state_t * spiState,
const spi_dma_slave_user_config_t * slaveConfig)
{
SPI_Type *base = g_spiBase[instance];
assert(slaveConfig);
assert(instance < SPI_INSTANCE_COUNT);
assert(spiState);
#if FSL_FEATURE_SPI_16BIT_TRANSFERS
if (slaveConfig->bitCount > kSpi16BitMode)
{
/* bits/frame larger than hardware support */
return kStatus_SPI_InvalidParameter;
}
#endif /* FSL_FEATURE_SPI_16BIT_TRANSFERS */
/* Check if the slave already initialized */
if (g_spiStatePtr[instance])
{
return kStatus_SPI_AlreadyInitialized;
}
/* Clear the state for this instance. */
memset(spiState, 0, sizeof(* spiState));
spiState->hasExtraByte = false;
/* Update dummy pattern value */
spiState->dummyPattern = slaveConfig->dummyPattern;
/* Enable clock for SPI */
CLOCK_SYS_EnableSpiClock(instance);
/* Reset the SPI module to its default settings including disabling SPI */
SPI_HAL_Init(base);
/* Initialize the event structure */
if (OSA_EventCreate(&spiState->event, kEventAutoClear) != kStatus_OSA_Success)
{
return kStatus_SPI_Error;
}
/* Set SPI to slave mode */
SPI_HAL_SetMasterSlave(base, kSpiSlave);
/* Configure the slave clock polarity, phase and data direction */
SPI_HAL_SetDataFormat(base, slaveConfig->polarity, slaveConfig->phase,
slaveConfig->direction);
/* Set the SPI pin mode to normal mode */
SPI_HAL_SetPinMode(base, kSpiPinMode_Normal);
#if FSL_FEATURE_SPI_16BIT_TRANSFERS
SPI_HAL_Set8or16BitMode(base, slaveConfig->bitCount);
#endif /* FSL_FEATURE_SPI_16BIT_TRANSFERS */
#if FSL_FEATURE_SPI_FIFO_SIZE
if (g_spiFifoSize[instance] != 0)
{
/* If SPI module contains a FIFO, enable it and set watermarks to half full/empty */
SPI_HAL_SetFifoMode(base, true, kSpiTxFifoOneHalfEmpty, kSpiRxFifoOneHalfFull);
/* Set the interrupt clearing mechansim select for later use in driver to clear
* status flags
*/
SPI_HAL_SetIntClearCmd(base, true);
}
#endif /* FSL_FEATURE_SPI_FIFO_SIZE */
/*****************************************
* Request DMA channel for RX and TX FIFO
*****************************************/
/* This channel transfers data from RX FIFO to receiveBuffer */
if (instance == 0)
{
/* Request DMA channel for RX FIFO */
if (kDmaInvalidChannel == DMA_DRV_RequestChannel(kDmaAnyChannel,
kDmaRequestMux0SPI0Rx,
&spiState->dmaReceive))
{
return kStatus_SPI_DMAChannelInvalid;
}
/* Request DMA channel for TX FIFO */
if (kDmaInvalidChannel == DMA_DRV_RequestChannel(kDmaAnyChannel,
kDmaRequestMux0SPI0Tx,
&spiState->dmaTransmit))
{
return kStatus_SPI_DMAChannelInvalid;
}
}
#if (SPI_INSTANCE_COUNT > 1)
else if (instance == 1)
{
/* Request DMA channel for RX FIFO */
if (kDmaInvalidChannel == DMA_DRV_RequestChannel(kDmaAnyChannel,
kDmaRequestMux0SPI1Rx,
&spiState->dmaReceive))
{
return kStatus_SPI_DMAChannelInvalid;
}
/* Request DMA channel for TX FIFO */
if (kDmaInvalidChannel == DMA_DRV_RequestChannel(kDmaAnyChannel,
kDmaRequestMux0SPI1Tx,
&spiState->dmaTransmit))
{
return kStatus_SPI_DMAChannelInvalid;
}
}
else
{
return kStatus_SPI_OutOfRange;
}
#endif
/* Save runtime structure pointers to irq handler can point to the correct state structure */
g_spiStatePtr[instance] = spiState;
/* Enable SPI interrupt. The transmit interrupt should immediately cause an interrupt
* which will fill in the transmit buffer and will be ready to send once the slave initiates
* transmission.
*/
INT_SYS_EnableIRQ(g_spiIrqId[instance]);
/* SPI module enable */
SPI_HAL_Enable(base);
return kStatus_SPI_Success;
}
void bluetooth_CreateAdvModeUpdateEvent()
{
OSA_EventCreate( &advModeUpdate_event, kEventAutoClear );
}
