Ejemplo n.º 1
0
uint32_t HAL_PRCM_GetLFClock(void)
{
	uint32_t val = HAL_GET_BIT(PRCM->SYS_LFCLK_CTRL, PRCM_LFCLK_SRC_MASK);

	if (val == PRCM_LFCLK_SRC_INTER32K &&
	    HAL_GET_BIT(PRCM->SYS_RCOSC_CALIB_CTRL, PRCM_RCOSC_CALIB_EN_BIT)) {
		return HAL_PRCM_GetInter32KFreq();
	} else {
		return SYS_LFCLOCK;
	}
}
Ejemplo n.º 2
0
uint32_t HAL_PRCM_GetLDOEnableFlags(void)
{
	return HAL_GET_BIT(PRCM->SYS_LDO_SW_CTRL,
					   PRCM_LDO1_EN_BIT |
					   PRCM_PLL_LDO_EN_BIT |
					   PRCM_SRAM_LDO_EN_BIT);
}
Ejemplo n.º 3
0
/**
  * @brief Gets the CSI moudle status.
  * @param None.
  * @retval CSI_Status: The status of CSI.
  */
CSI_Status HAL_CSI_Status()
{
	CSI_Status sta;
	sta.luminance = HAL_GET_BIT(CSI->CSI_BUF_STA_REG, LUM_STATIS) >> 8;
	sta.still_Mode = HAL_GET_BIT(CSI->CSI_BUF_STA_REG, HAL_BIT(1)) >> 1;
	sta.video_Mode = HAL_GET_BIT(CSI->CSI_BUF_STA_REG, HAL_BIT(0));
	return sta;
}
Ejemplo n.º 4
0
/**
  * @brief  Cached data length of FIFO.
  * @param None
  * @retval CSI_FIFO_Data_Len: The data length of CSI_FIFO_A and CSI_FIFO_B.
  *        @arg FIFO_0_A_Data_Len: The data length of CSI_FIFO_A.
  *        @arg FIFO_0_B_Data_Len: The data length of CSI_FIFO_B.
  */
__nonxip_text
CSI_FIFO_Data_Len HAL_CSI_FIFO_Data_Len()
{
	CSI_FIFO_Data_Len len;
	len.FIFO_0_B_Data_Len = HAL_GET_BIT(CSI->CSI_TRUE_DATA_NUM, (CSI_VALID_DATA_LEN << 16)) >> 16;
	len.FIFO_0_A_Data_Len = HAL_GET_BIT(CSI->CSI_TRUE_DATA_NUM, CSI_VALID_DATA_LEN);
	return len;
}
Ejemplo n.º 5
0
/**
 * @brief Get interrupt mode of the specified ADC channel
 * @param[in] chan The specified ADC channel
 * @retval HAL_Status, HAL_OK on success
 */
ADC_IRQState HAL_ADC_GetIRQState(ADC_Channel chan)
{
	ADC_ASSERT_CHANNEL(chan);

	if (HAL_GET_BIT(gADCPrivate.dataPending, HAL_BIT(chan)) && ADC_GetChanDataIRQ(chan)) {
		if (HAL_GET_BIT(gADCPrivate.lowPending, HAL_BIT(chan)) && ADC_GetChanLowIRQ(chan))
			return ADC_LOW_DATA_IRQ;
		if (HAL_GET_BIT(gADCPrivate.highPending, HAL_BIT(chan)) && ADC_GetChanHighIRQ(chan))
			return ADC_HIGH_DATA_IRQ;
		else
			return ADC_DATA_IRQ;
	} else {
		if (HAL_GET_BIT(gADCPrivate.lowPending, HAL_BIT(chan)) && ADC_GetChanLowIRQ(chan))
			return ADC_LOW_IRQ;
		if (HAL_GET_BIT(gADCPrivate.highPending, HAL_BIT(chan)) && ADC_GetChanHighIRQ(chan))
			return ADC_HIGH_IRQ;
		else
			return ADC_NO_IRQ;
	}
}
Ejemplo n.º 6
0
uint32_t HAL_PRCM_GetSysPowerEnableFlags(void)
{
	return HAL_GET_BIT(PRCM->SYS_LDO_SW_CTRL,
					   PRCM_SYS1_PWR1_EN_BIT |
					   PRCM_SYS1_PWR2_EN_BIT |
					   PRCM_SYS2_PWR3_EN_BIT |
					   PRCM_SYS3_PWR4_EN_BIT |
					   PRCM_SYS3_PWR5_EN_BIT |
	  				   PRCM_SYS1_SRAM_PWR1_EN_BIT |
	  				   PRCM_SYS2_SRAM_PWR2_EN_BIT |
	  				   PRCM_SYS3_SRAM_PWR3_EN_BIT);
}
Ejemplo n.º 7
0
__nonxip_text
void GPADC_IRQHandler(void)
{
	if(gADCPrivate.mode == ADC_BURST_CONV) {
		uint32_t i;
		uint32_t fifoverunPending, fifodataPending;
		fifoverunPending = ADC_GetFifoOverunPending();
		fifodataPending  = ADC_GetFifodataPending();
		ADC_ClrFifoPending(fifoverunPending);
		ADC_ClrFifoPending(fifodataPending);

		if(fifodataPending) {
			for (i = ADC_CHANNEL_0; i < ADC_CHANNEL_NUM; i++) {
				if (ADC_GetChanPinMux(i) && (gADCPrivate.IRQCallback[i]))
					gADCPrivate.IRQCallback[i](gADCPrivate.arg[i]);
			}
		}
	} else {
		uint32_t i;
		gADCPrivate.lowPending	= ADC_GetLowPending();
		gADCPrivate.highPending = ADC_GetHighPending();
		gADCPrivate.dataPending = ADC_GetDataPending();

		ADC_ClrLowPending(gADCPrivate.lowPending);
		ADC_ClrHighPending(gADCPrivate.highPending);
		ADC_ClrDataPending(gADCPrivate.dataPending);

		for (i = ADC_CHANNEL_0; i < ADC_CHANNEL_NUM; i++) {
			if (((HAL_GET_BIT(gADCPrivate.dataPending, HAL_BIT(i)) && ADC_GetChanDataIRQ(i))
				|| (HAL_GET_BIT(gADCPrivate.lowPending, HAL_BIT(i)) && ADC_GetChanLowIRQ(i))
				|| (HAL_GET_BIT(gADCPrivate.highPending, HAL_BIT(i)) && ADC_GetChanHighIRQ(i)))
				&& (gADCPrivate.IRQCallback[i])) {
				gADCPrivate.IRQCallback[i](gADCPrivate.arg[i]);
			}
		}
	}
}
Ejemplo n.º 8
0
__STATIC_INLINE uint32_t ADC_GetValue(ADC_Channel chan)
{
	return HAL_GET_BIT(ADC->DATA[chan], ADC_DATA_MASK);
}
Ejemplo n.º 9
0
__STATIC_INLINE void ADC_SetLowValue(ADC_Channel chan, uint32_t value)
{
	HAL_MODIFY_REG(ADC->CMP_DATA[chan], ADC_LOW_DATA_MASK,
				   HAL_GET_BIT(value << ADC_LOW_DATA_SHIFT, ADC_LOW_DATA_MASK));
}
Ejemplo n.º 10
0
__nonxip_text
static __always_inline uint32_t ADC_GetDataPending(void)
{
	return HAL_GET_BIT(ADC->DATA_STATUS, ADC_DATA_PENDING_MASK);
}
Ejemplo n.º 11
0
__nonxip_text
static __always_inline uint8_t I2C_IsMemMode(I2C_Private *priv)
{
	return !!HAL_GET_BIT(priv->ctrl, I2C_MEM_MODE_BIT);
}
Ejemplo n.º 12
0
__nonxip_text
static __always_inline uint8_t ADC_GetChanPinMux(ADC_Channel chan)
{
	return !!HAL_GET_BIT(gADCPrivate.chanPinMux, HAL_BIT(chan));
}
Ejemplo n.º 13
0
static __always_inline uint8_t I2C_IsInitState(I2C_Private *priv)
{
	return !!HAL_GET_BIT(priv->ctrl, I2C_INIT_STATE_BIT);
}
Ejemplo n.º 14
0
__nonxip_text
static __always_inline uint8_t ADC_GetChanDataIRQ(ADC_Channel chan)
{
	return !!HAL_GET_BIT(ADC->DATA_CONFIG, HAL_BIT(chan));
}
Ejemplo n.º 15
0
/**
 * @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;
	}
}
Ejemplo n.º 16
0
__STATIC_INLINE uint32_t ADC_GetCalibState(void)
{
	return !!HAL_GET_BIT(ADC->CTRL, ADC_CALIB_EN_BIT);
}
Ejemplo n.º 17
0
__STATIC_INLINE void ADC_SetWorkMode(ADC_WorkMode workMode)
{
	HAL_MODIFY_REG(ADC->CTRL, ADC_WORK_MODE_MASK,
				   HAL_GET_BIT(workMode << ADC_WORK_MODE_SHIFT, ADC_WORK_MODE_MASK));
}
Ejemplo n.º 18
0
__STATIC_INLINE void ADC_SetOPBias(uint32_t opBias)
{
	HAL_MODIFY_REG(ADC->CTRL, ADC_OP_BIAS_MASK,
				   HAL_GET_BIT(opBias << ADC_OP_BIAS_SHIFT, ADC_OP_BIAS_MASK));
}
Ejemplo n.º 19
0
__STATIC_INLINE void ADC_SetFirstDelay(uint32_t firstDelay)
{
	HAL_MODIFY_REG(ADC->CTRL, ADC_FIRST_DELAY_MASK,
				   HAL_GET_BIT(firstDelay << ADC_FIRST_DELAY_SHIFT, ADC_FIRST_DELAY_MASK));
}
Ejemplo n.º 20
0
__STATIC_INLINE void ADC_SetSampleRate(uint32_t fsDiv, uint32_t tAcq)
{
	ADC->SAMPLE_RATE = (HAL_GET_BIT(fsDiv << ADC_FS_DIV_SHIFT, ADC_FS_DIV_MASK)
						| HAL_GET_BIT(tAcq << ADC_TACQ_SHIFT, ADC_TACQ_MASK));
}
Ejemplo n.º 21
0
__STATIC_INLINE void ADC_SetFifoLevel(uint8_t level)
{
	HAL_MODIFY_REG(ADC->FIFO_CTRL, ADC_FIFO_LEVEL_MASK,
			   HAL_GET_BIT((level - 1) << ADC_FIFO_LEVEL_SHIFT, ADC_FIFO_LEVEL_MASK));
}
Ejemplo n.º 22
0
/*
 * @brief
 */
__SPI_STATIC_INLINE__
bool SPI_ClearInt(SPI_T *spi, SPI_Int_Type type)
{
    HAL_SET_BIT(spi->STA, type);
    return HAL_GET_BIT(spi->STA, type);
}
Ejemplo n.º 23
0
/*
 * @brief
 */
__SPI_STATIC_INLINE__
bool SPI_IntState(SPI_T *spi, SPI_Int_Type type)
{
    return !!HAL_GET_BIT(spi->STA, type);
}
Ejemplo n.º 24
0
__nonxip_text
static __always_inline uint32_t ADC_GetFifoOverunPending(void)
{
	return HAL_GET_BIT(ADC->FIFO_STATUS, ADC_FIFO_OVERUN_PENDING_MASK);
}
Ejemplo n.º 25
0
/*
 * @brief
 */
__SPI_STATIC_INLINE__
void SPI_ResetRxFifo(SPI_T *spi)
{
    HAL_SET_BIT(spi->FCTL, SPI_FCTL_RF_RST_MASK);
    while (HAL_GET_BIT(spi->FCTL, SPI_FCTL_RF_RST_MASK) != 0);
}
Ejemplo n.º 26
0
__STATIC_INLINE uint32_t ADC_GetFifoData(void)
{
	return HAL_GET_BIT(ADC->FIFO_DATA, ADC_FIFO_DATA_MASK);
}
Ejemplo n.º 27
0
__nonxip_text
static __always_inline uint8_t I2C_Is7BitAddrMode(I2C_Private *priv)
{
	return !!HAL_GET_BIT(priv->ctrl, I2C_7BIT_ADDR_BIT);
}
Ejemplo n.º 28
0
__nonxip_text
static __always_inline uint32_t ADC_GetLowPending(void)
{
	return HAL_GET_BIT(ADC->LOW_STATUS, ADC_LOW_PENDING_MASK);
}
Ejemplo n.º 29
0
__nonxip_text
static __always_inline uint8_t I2C_IsRestart(I2C_Private *priv)
{
	return !!HAL_GET_BIT(priv->ctrl, I2C_RESTART_BIT);
}
Ejemplo n.º 30
0
__nonxip_text
static __always_inline uint32_t ADC_GetHighPending(void)
{
	return HAL_GET_BIT(ADC->HIGH_STATUS, ADC_HIGH_PENDING_MASK);
}