/**
* @brief Disable the IRQ of the specified GPIO
* @param[in] port GPIO port
* @param[in] pin GPIO pin number
* @return None
*/
void HAL_GPIO_DisableIRQ(GPIO_Port port, GPIO_Pin pin)
{
GPIO_IRQ_T *gpiox;
GPIO_Private *gpioPriv;
IRQn_Type IRQn;
unsigned long flags;
flags = HAL_EnterCriticalSection();
if (port == GPIO_PORT_A) {
gpioPriv = gGPIOAPrivate;
IRQn = GPIOA_IRQn;
} else if (port == GPIO_PORT_B) {
gpioPriv = gGPIOBPrivate;
IRQn = GPIOB_IRQn;
} else {
HAL_ERR("Invalid port %d for IRQ\n", port);
return;
}
gpiox = GPIO_GetIRQInstance(port);
HAL_NVIC_DisableIRQ(IRQn);
GPIO_DisableIRQ(gpiox, pin);
if (GPIO_IsPendingIRQ(gpiox, pin)) {
GPIO_ClearPendingIRQ(gpiox, pin);
}
gpioPriv[pin].callback = NULL;
gpioPriv[pin].arg = NULL;
HAL_ExitCriticalSection(flags);
}
/**
* @brief Configure the specified ADC channel for conversion in interrupt mode(FIFO mode)
* @param[in] chan The specified ADC channel
* @param[in] select ADC channel selected state
* @retval HAL_Status, HAL_OK on success, HAL_ERROR on fail, HAL_INVALID on invalid argument
* @note When this function is called, the FIFO will be flushed firstly
*/
HAL_Status HAL_ADC_FifoConfigChannel(ADC_Channel chan, ADC_Select select)
{
unsigned long flags;
ADC_ASSERT_CHANNEL(chan);
if (gADCPrivate.mode != ADC_BURST_CONV) {
HAL_ERR("Invalid call.\n");
return HAL_ERROR;
}
#ifdef CONFIG_PM
hal_adc_chan_config[chan].is_config = 1;
hal_adc_chan_config[chan].select = select;
hal_adc_chan_config[chan].workmode = ADC_BURST_CONV;
#endif
flags = HAL_EnterCriticalSection();
if ((gADCPrivate.state == ADC_STATE_READY) || (gADCPrivate.state == ADC_STATE_BUSY)) {
if (gADCPrivate.state == ADC_STATE_BUSY)
ADC_DisableADC();
ADC_FlushFifo();
if (select == ADC_SELECT_DISABLE) {
ADC_DisableChanSel(chan);
if (chan == ADC_CHANNEL_8)
ADC_DisableVbatDetec();
if (!gADCPrivate.chanPinMux)
ADC_DisableAllFifoIRQ();
if (ADC_GetChanPinMux(chan) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_DEINIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_ClrChanPinMux(chan);
}
} else {
if ((!ADC_GetChanPinMux(chan)) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_INIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_SetChanPinMux(chan);
}
if (chan == ADC_CHANNEL_8)
ADC_EnableVbatDetec();
ADC_EnableChanSel(chan);
ADC_EnableFifoDataIRQ();
}
if (gADCPrivate.state == ADC_STATE_BUSY)
ADC_EnableADC();
HAL_ExitCriticalSection(flags);
return HAL_OK;
} else {
HAL_ExitCriticalSection(flags);
HAL_WRN("ADC state: %d\n", gADCPrivate.state);
return HAL_ERROR;
}
}
/**
* @brief Enable the IRQ of the specified GPIO
* @param[in] port GPIO port
* @param[in] pin GPIO pin number
* @param[in] param Pointer to GPIO_IrqParam structure
* @return None
*/
void HAL_GPIO_EnableIRQ(GPIO_Port port, GPIO_Pin pin, const GPIO_IrqParam *param)
{
uint32_t regIdx;
uint32_t bitShift;
GPIO_IRQ_T *gpiox;
GPIO_Private *gpioPriv;
IRQn_Type IRQn;
unsigned long flags;
flags = HAL_EnterCriticalSection();
if (port == GPIO_PORT_A) {
gpioPriv = gGPIOAPrivate;
IRQn = GPIOA_IRQn;
} else if (port == GPIO_PORT_B) {
gpioPriv = gGPIOBPrivate;
IRQn = GPIOB_IRQn;
} else {
HAL_ERR("Invalid port %d for IRQ\n", port);
return;
}
gpiox = GPIO_GetIRQInstance(port);
/* set callback */
gpioPriv[pin].callback = param->callback;
gpioPriv[pin].arg = param->arg;
/* set IRQ trigger mode */
GPIO_GET_REG_IDX_SHIFT(regIdx, bitShift, pin, GPIO_IRQ_EVT_BITS);
HAL_MODIFY_REG(gpiox->IRQ_MODE[regIdx],
GPIO_IRQ_EVT_VMASK << bitShift,
(param->event & GPIO_IRQ_EVT_VMASK) << bitShift);
if (GPIO_IsPendingIRQ(gpiox, pin)) {
GPIO_ClearPendingIRQ(gpiox, pin);
}
GPIO_EnableIRQ(gpiox, pin);
HAL_NVIC_SetPriority(IRQn, NVIC_PERIPHERAL_PRIORITY_DEFAULT);
HAL_NVIC_EnableIRQ(IRQn);
HAL_ExitCriticalSection(flags);
}
nsresult
GonkSensorsProtocol::Send(DaemonSocketPDU* aPDU,
DaemonSocketResultHandler* aRes)
{
MOZ_ASSERT(mConnection);
MOZ_ASSERT(aPDU);
aPDU->SetConsumer(this);
aPDU->SetResultHandler(aRes);
aPDU->UpdateHeader();
if (mConnection->GetConnectionStatus() == SOCKET_DISCONNECTED) {
HAL_ERR("Sensors socket is disconnected");
return NS_ERROR_FAILURE;
}
mConnection->SendSocketData(aPDU); // Forward PDU to data channel
return NS_OK;
}
/**
* @brief Configure the specified ADC channel for conversion in interrupt mode(CHAN mode)
* @param[in] chan The specified ADC channel
* @param[in] select ADC channel selected state
* @param[in] mode ADC interrupt mode
* @param[in] lowValue lower limit value in interrupt mode of ADC_IRQ_LOW,
* ADC_IRQ_LOW_DATA, ADC_IRQ_LOW_HIGH or ADC_IRQ_LOW_HIGH_DATA
* @param[in] highValue Upper limit value in interrupt mode of ADC_IRQ_HIGH,
* ADC_IRQ_HIGH_DATA, ADC_IRQ_LOW_HIGH or ADC_IRQ_LOW_HIGH_DATA
* @retval HAL_Status, HAL_OK on success, HAL_ERROR on fail
*/
HAL_Status HAL_ADC_ConfigChannel(ADC_Channel chan, ADC_Select select, ADC_IRQMode mode, uint32_t lowValue, uint32_t highValue)
{
unsigned long flags;
ADC_ASSERT_CHANNEL(chan);
if (gADCPrivate.mode != ADC_CONTI_CONV) {
HAL_ERR("Invalid call.\n");
return HAL_ERROR;
}
if (((mode == ADC_IRQ_LOW_HIGH_DATA) || (mode == ADC_IRQ_LOW_HIGH)) && (lowValue > highValue)) {
HAL_ERR("lowValue greater than highValue.\n");
return HAL_ERROR;
}
#ifdef CONFIG_PM
hal_adc_chan_config[chan].is_config = 1;
hal_adc_chan_config[chan].select = select;
hal_adc_chan_config[chan].irqmode = mode;
hal_adc_chan_config[chan].workmode = ADC_CONTI_CONV;
hal_adc_chan_config[chan].lowValue = lowValue;
hal_adc_chan_config[chan].highValue = highValue;
#endif
flags = HAL_EnterCriticalSection();
if ((gADCPrivate.state == ADC_STATE_READY) || (gADCPrivate.state == ADC_STATE_BUSY)) {
if (gADCPrivate.state == ADC_STATE_BUSY)
ADC_DisableADC();
if (select == ADC_SELECT_DISABLE) {
ADC_DisableChanSel(chan);
if (chan == ADC_CHANNEL_8)
ADC_DisableVbatDetec();
ADC_DisableChanDataIRQ(chan);
ADC_DisableChanCmp(chan);
ADC_DisableChanLowIRQ(chan);
ADC_DisableChanHighIRQ(chan);
if (ADC_GetChanPinMux(chan) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_DEINIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_ClrChanPinMux(chan);
}
} else {
if ((!ADC_GetChanPinMux(chan)) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_INIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_SetChanPinMux(chan);
}
if (chan == ADC_CHANNEL_8)
ADC_EnableVbatDetec();
ADC_EnableChanSel(chan);
switch (mode) {
case ADC_IRQ_NONE:
ADC_DisableChanDataIRQ(chan);
ADC_DisableChanCmp(chan);
ADC_DisableChanLowIRQ(chan);
ADC_DisableChanHighIRQ(chan);
break;
case ADC_IRQ_DATA:
ADC_EnableChanDataIRQ(chan);
ADC_DisableChanCmp(chan);
ADC_DisableChanLowIRQ(chan);
ADC_DisableChanHighIRQ(chan);
break;
case ADC_IRQ_LOW:
ADC_DisableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_EnableChanLowIRQ(chan);
ADC_SetLowValue(chan, lowValue);
ADC_DisableChanHighIRQ(chan);
break;
case ADC_IRQ_HIGH:
ADC_DisableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_DisableChanLowIRQ(chan);
ADC_EnableChanHighIRQ(chan);
ADC_SetHighValue(chan, highValue);
break;
case ADC_IRQ_LOW_DATA:
ADC_EnableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_EnableChanLowIRQ(chan);
ADC_SetLowValue(chan, lowValue);
ADC_DisableChanHighIRQ(chan);
break;
case ADC_IRQ_HIGH_DATA:
ADC_EnableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_DisableChanLowIRQ(chan);
ADC_EnableChanHighIRQ(chan);
ADC_SetHighValue(chan, highValue);
break;
case ADC_IRQ_LOW_HIGH:
ADC_DisableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_EnableChanLowIRQ(chan);
ADC_SetLowValue(chan, lowValue);
ADC_EnableChanHighIRQ(chan);
ADC_SetHighValue(chan, highValue);
break;
case ADC_IRQ_LOW_HIGH_DATA:
ADC_EnableChanDataIRQ(chan);
ADC_EnableChanCmp(chan);
ADC_EnableChanLowIRQ(chan);
ADC_SetLowValue(chan, lowValue);
ADC_EnableChanHighIRQ(chan);
ADC_SetHighValue(chan, highValue);
break;
}
}
if (gADCPrivate.state == ADC_STATE_BUSY)
ADC_EnableADC();
HAL_ExitCriticalSection(flags);
return HAL_OK;
} else {
HAL_ExitCriticalSection(flags);
HAL_WRN("ADC state: %d\n", gADCPrivate.state);
return HAL_ERROR;
}
}
/**
* @brief The specified ADC channel convert once in polling mode
* @param[in] chan The specified ADC channel
* @param[in] data Pointer to the output data
* @param[in] msec Timeout value in millisecond of conversion
* HAL_WAIT_FOREVER for no timeout
* @retval HAL_Status, HAL_OK on success
*/
HAL_Status HAL_ADC_Conv_Polling(ADC_Channel chan, uint32_t *data, uint32_t msec)
{
unsigned long flags;
ADC_Private *priv;
uint32_t stopTime;
uint8_t isTimeout;
ADC_ASSERT_CHANNEL(chan);
flags = HAL_EnterCriticalSection();
priv = &gADCPrivate;
if (priv->state == ADC_STATE_READY)
priv->state = ADC_STATE_BUSY;
else
priv = NULL;
HAL_ExitCriticalSection(flags);
if (priv == NULL) {
HAL_WRN("ADC state: %d\n", gADCPrivate.state);
return HAL_ERROR;
}
if ((!ADC_GetChanPinMux(chan)) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_INIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_SetChanPinMux(chan);
}
ADC_DisableAllChanSel();
ADC_DisableAllChanCmp();
ADC_DisableAllChanIRQ();
if (chan == ADC_CHANNEL_8)
ADC_EnableVbatDetec();
ADC_EnableChanSel(chan);
if (msec == HAL_WAIT_FOREVER)
stopTime = 0xFFFFFFFF;
else
stopTime = HAL_TicksToMSecs(HAL_Ticks()) + msec;
if (stopTime < msec) {
HAL_ERR("stopTime overflow.\n");
return HAL_ERROR;
}
isTimeout = 1;
ADC_EnableADC();
while (HAL_TicksToMSecs(HAL_Ticks()) <= stopTime) {
if (HAL_GET_BIT(ADC_GetDataPending(), HAL_BIT(chan))) {
*data = ADC_GetValue(chan);
ADC_ClrDataPending(ADC_GetDataPending());
isTimeout = 0;
break;
}
}
ADC_DisableADC();
ADC_DisableChanSel(chan);
if (chan == ADC_CHANNEL_8)
ADC_DisableVbatDetec();
if (ADC_GetChanPinMux(chan) && (chan != ADC_CHANNEL_8)) {
HAL_BoardIoctl(HAL_BIR_PINMUX_DEINIT, HAL_MKDEV(HAL_DEV_MAJOR_ADC, chan), 0);
ADC_ClrChanPinMux(chan);
}
flags = HAL_EnterCriticalSection();
priv->state = ADC_STATE_READY;
HAL_ExitCriticalSection(flags);
if (isTimeout) {
HAL_WRN("ADC timeout.\n");
return HAL_TIMEOUT;
} else {
return HAL_OK;
}
}
/**
* @brief Initialize the ADC according to the specified parameters
* @param[in] initParam Pointer to ADC_InitParam structure
* @retval HAL_Status, HAL_OK on success
*/
HAL_Status HAL_ADC_Init(ADC_InitParam *initParam)
{
unsigned long flags;
ADC_Private *priv;
uint32_t hoscClk;
uint32_t fsDiv;
uint32_t tAcq;
if ((initParam->freq < 1000) || (initParam->freq > 1000000)) {
HAL_ERR("invalid parameter, freq: %d\n", initParam->freq);
return HAL_ERROR;
}
if((initParam->mode != ADC_CONTI_CONV) && (initParam->mode != ADC_BURST_CONV)) {
HAL_ERR("invalid mode: %d\n", initParam->mode);
return HAL_ERROR;
}
flags = HAL_EnterCriticalSection();
priv = &gADCPrivate;
if (priv->state == ADC_STATE_INVALID)
priv->state = ADC_STATE_INIT;
else
priv = NULL;
HAL_ExitCriticalSection(flags);
if (priv == NULL) {
HAL_WRN("ADC state: %d\n", gADCPrivate.state);
return HAL_BUSY;
}
#ifdef CONFIG_PM
if (!hal_adc_suspending) {
pm_register_ops(ADC_DEV);
HAL_Memcpy(&hal_adc_param, initParam, sizeof(ADC_InitParam));
HAL_Memset(hal_adc_chan_config, 0, ADC_CHANNEL_NUM * sizeof(struct adc_chan_config));
}
#endif
priv->chanPinMux = 0;
priv->lowPending = 0;
priv->highPending = 0;
priv->dataPending = 0;
priv->mode = initParam->mode;
#ifdef CONFIG_PM
if (!hal_adc_suspending) {
HAL_Memset(priv->IRQCallback, 0, ADC_CHANNEL_NUM * sizeof(ADC_IRQCallback));
HAL_Memset(priv->arg, 0, ADC_CHANNEL_NUM * sizeof(void *));
}
#else
HAL_Memset(priv->IRQCallback, 0, ADC_CHANNEL_NUM * sizeof(ADC_IRQCallback));
HAL_Memset(priv->arg, 0, ADC_CHANNEL_NUM * sizeof(void *));
#endif
/* enable ADC clock and release reset */
HAL_CCM_BusEnablePeriphClock(CCM_BUS_PERIPH_BIT_GPADC);
HAL_CCM_BusReleasePeriphReset(CCM_BUS_PERIPH_BIT_GPADC);
HAL_CCM_GPADC_SetMClock(CCM_APB_PERIPH_CLK_SRC_LFCLK, CCM_PERIPH_CLK_DIV_N_1, CCM_PERIPH_CLK_DIV_M_1);
HAL_CCM_GPADC_EnableMClock();
hoscClk = HAL_GetHFClock();
fsDiv = hoscClk / initParam->freq - 1;
if (initParam->freq <= 300000)
tAcq = hoscClk / 500000 - 1;
else if (initParam->freq <= 600000)
tAcq = hoscClk / 1000000 - 1;
else
tAcq = hoscClk / 2000000 - 1;
ADC_SetSampleRate(fsDiv, tAcq);
ADC_SetFirstDelay(initParam->delay);
ADC_SetWorkMode(initParam->mode);
ADC_EnableLDO();
ADC_DisableAllChanSel();
ADC_DisableAllChanCmp();
ADC_DisableAllChanIRQ();
ADC_DisableAllFifoIRQ();
if(initParam->mode == ADC_BURST_CONV)
ADC_SetFifoLevel(ADC_FIFO_LEVEL);
ADC_EnableCalib();
while (ADC_GetCalibState())
;
/* enable NVIC IRQ */
HAL_NVIC_SetPriority(GPADC_IRQn, NVIC_PERIPHERAL_PRIORITY_DEFAULT);
HAL_NVIC_EnableIRQ(GPADC_IRQn);
flags = HAL_EnterCriticalSection();
priv->state = ADC_STATE_READY;
HAL_ExitCriticalSection(flags);
return HAL_OK;
}
