/** * @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; }