lib_at91rm9200.h

ARM板驱动程序源代码

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgOutput*/
/** \brief Enable PIO in output mode*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgOutput(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int pioEnable)      /* \arg PIO to be enabled*/
{
	pPio->PIO_PER = pioEnable; /* Set in PIO mode*/
	pPio->PIO_OER = pioEnable; /* Configure in Output*/
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgInput*/
/** \brief Enable PIO in input mode*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgInput(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int inputEnable)      /* \arg PIO to be enabled*/
{
	/* Disable output*/
	pPio->PIO_ODR  = inputEnable;
	pPio->PIO_PER  = inputEnable;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgOpendrain*/
/** \brief Configure PIO in open drain*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgOpendrain(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int multiDrvEnable) /* \arg pio to be configured in open drain*/
{
	/* Configure the multi-drive option*/
	pPio->PIO_MDDR = ~multiDrvEnable;
	pPio->PIO_MDER = multiDrvEnable;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgPullup*/
/** \brief Enable pullup on PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgPullup(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int pullupEnable)   /* \arg enable pullup on PIO*/
{
		/* Connect or not Pullup*/
	pPio->PIO_PPUDR = ~pullupEnable;
	pPio->PIO_PPUER = pullupEnable;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgDirectDrive*/
/** \brief Enable direct drive on PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgDirectDrive(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int directDrive)    /* \arg PIO to be configured with direct drive*/

{
	/* Configure the Direct Drive*/
	pPio->PIO_OWDR  = ~directDrive;
	pPio->PIO_OWER  = directDrive;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_CfgInputFilter*/
/** \brief Enable input filter on input PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_CfgInputFilter(
	AT91PS_PIO pPio,             /* \arg pointer to a PIO controller*/
	unsigned int inputFilter)    /* \arg PIO to be configured with input filter*/

{
	/* Configure the Direct Drive*/
	pPio->PIO_IFDR  = ~inputFilter;
	pPio->PIO_IFER  = inputFilter;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetInput*/
/** \brief Return PIO input value*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetInput( /* \return PIO input*/
	AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
	return pPio->PIO_PDSR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_IsInputSet*/
/** \brief Test if PIO is input flag is active*/
/**----------------------------------------------------------------------------*/
__inline int AT91F_PIO_IsInputSet(
	AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
	unsigned int flag) /* \arg  flag to be tested*/
{
	return (AT91F_PIO_GetInput(pPio) & flag);
}


/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_SetOutput*/
/** \brief Set to 1 output PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_SetOutput(
	AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
	unsigned int flag) /* \arg  output to be set*/
{
	pPio->PIO_SODR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_ClearOutput*/
/** \brief Set to 0 output PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_ClearOutput(
	AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
	unsigned int flag) /* \arg  output to be cleared*/
{
	pPio->PIO_CODR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_ForceOutput*/
/** \brief Force output when Direct drive option is enabled*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_ForceOutput(
	AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
	unsigned int flag) /* \arg  output to be forced*/
{
	pPio->PIO_ODSR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_Enable*/
/** \brief Enable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_Enable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio to be enabled */
{
        pPio->PIO_PER = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_Disable*/
/** \brief Disable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_Disable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio to be disabled */
{
        pPio->PIO_PDR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetStatus*/
/** \brief Return PIO Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetStatus( /* \return PIO Status*/
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_PSR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_IsSet*/
/** \brief Test if PIO is Set*/
/**----------------------------------------------------------------------------*/
__inline int AT91F_PIO_IsSet(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  flag to be tested*/
{
        return (AT91F_PIO_GetStatus(pPio) & flag);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_OutputEnable*/
/** \brief Output Enable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_OutputEnable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio output to be enabled*/
{
        pPio->PIO_OER = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_OutputDisable*/
/** \brief Output Enable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_OutputDisable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio output to be disabled*/
{
        pPio->PIO_ODR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetOutputStatus*/
/** \brief Return PIO Output Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetOutputStatus( /* \return PIO Output Status*/
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_OSR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_IsOuputSet*/
/** \brief Test if PIO Output is Set*/
/**----------------------------------------------------------------------------*/
__inline int AT91F_PIO_IsOutputSet(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  flag to be tested*/
{
        return (AT91F_PIO_GetOutputStatus(pPio) & flag);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_InputFilterEnable*/
/** \brief Input Filter Enable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_InputFilterEnable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio input filter to be enabled*/
{
        pPio->PIO_IFER = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_InputFilterDisable*/
/** \brief Input Filter Disable PIO*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_InputFilterDisable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio input filter to be disabled*/
{
        pPio->PIO_IFDR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetInputFilterStatus*/
/** \brief Return PIO Input Filter Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetInputFilterStatus( /* \return PIO Input Filter Status*/
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_IFSR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_IsInputFilterSet*/
/** \brief Test if PIO Input filter is Set*/
/**----------------------------------------------------------------------------*/
__inline int AT91F_PIO_IsInputFilterSet(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  flag to be tested*/
{
        return (AT91F_PIO_GetInputFilterStatus(pPio) & flag);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetOutputDataStatus*/
/** \brief Return PIO Output Data Status */
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetOutputDataStatus( /* \return PIO Output Data Status */
	AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_ODSR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_InterruptEnable*/
/** \brief Enable PIO Interrupt*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_InterruptEnable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio interrupt to be enabled*/
{
        pPio->PIO_IER = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_InterruptDisable*/
/** \brief Disable PIO Interrupt*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_InterruptDisable(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio interrupt to be disabled*/
{
        pPio->PIO_IDR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetInterruptMaskStatus*/
/** \brief Return PIO Interrupt Mask Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetInterruptMaskStatus( /* \return PIO Interrupt Mask Status*/
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_IMR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetInterruptStatus*/
/** \brief Return PIO Interrupt Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetInterruptStatus( /* \return PIO Interrupt Status*/
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_ISR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_IsInterruptMasked*/
/** \brief Test if PIO Interrupt is Masked */
/**----------------------------------------------------------------------------*/
__inline int AT91F_PIO_IsInterruptMasked(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  flag to be tested*/
{