lib_at91rm9200.h

ARM板驱动程序源代码

        return (AT91F_PIO_GetInterruptMaskStatus(pPio) & flag);
}

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

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

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

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

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

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_A_RegisterSelection*/
/** \brief PIO A Register Selection */
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_A_RegisterSelection(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio A register selection*/
{
        pPio->PIO_ASR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_B_RegisterSelection*/
/** \brief PIO B Register Selection */
/**----------------------------------------------------------------------------*/
__inline void AT91F_PIO_B_RegisterSelection(
        AT91PS_PIO pPio,   /* \arg  pointer to a PIO controller*/
        unsigned int flag) /* \arg  pio B register selection */
{
        pPio->PIO_BSR = flag;
}

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

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

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

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

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

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

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_PIO_GetCfgPullup*/
/** \brief Return PIO Configuration Pullup*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_PIO_GetCfgPullup( /* \return PIO Configuration Pullup */
        AT91PS_PIO pPio) /* \arg  pointer to a PIO controller*/
{
        return pPio->PIO_PPUSR;
}

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

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

/* *****************************************************************************
                SOFTWARE API FOR TWI
   ***************************************************************************** */
/**----------------------------------------------------------------------------*/
/** \fn    AT91F_TWI_EnableIt*/
/** \brief Enable TWI IT*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_TWI_EnableIt (
	AT91PS_TWI pTWI, /* \arg pointer to a TWI controller*/
	unsigned int flag)   /* \arg IT to be enabled*/
{
	/** Write to the IER register*/
	pTWI->TWI_IER = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_TWI_DisableIt*/
/** \brief Disable TWI IT*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_TWI_DisableIt (
	AT91PS_TWI pTWI, /* \arg pointer to a TWI controller*/
	unsigned int flag)   /* \arg IT to be disabled*/
{
	/** Write to the IDR register*/
	pTWI->TWI_IDR = flag;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_TWI_Configure*/
/** \brief Configure TWI in master mode*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_TWI_Configure ( AT91PS_TWI pTWI )          /* \arg pointer to a TWI controller*/
{
    /** Disable interrupts*/
	pTWI->TWI_IDR = (unsigned int) -1;

    /** Reset peripheral*/
	pTWI->TWI_CR = AT91C_TWI_SWRST;

	/** Set Master mode*/
	pTWI->TWI_CR = AT91C_TWI_MSEN | AT91C_TWI_SVDIS;

}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_TWI_GetInterruptMaskStatus*/
/** \brief Return TWI Interrupt Mask Status*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_TWI_GetInterruptMaskStatus( /* \return TWI Interrupt Mask Status*/
        AT91PS_TWI pTwi) /* \arg  pointer to a TWI controller*/
{
        return pTwi->TWI_IMR;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_TWI_IsInterruptMasked*/
/** \brief Test if TWI Interrupt is Masked */
/**----------------------------------------------------------------------------*/
__inline int AT91F_TWI_IsInterruptMasked(
        AT91PS_TWI pTwi,   /* \arg  pointer to a TWI controller*/
        unsigned int flag) /* \arg  flag to be tested*/
{
        return (AT91F_TWI_GetInterruptMaskStatus(pTwi) & flag);
}

/* *****************************************************************************
                SOFTWARE API FOR USART
   ***************************************************************************** */
/**----------------------------------------------------------------------------*/
/** \fn    AT91F_US_Baudrate*/
/** \brief Calculate the baudrate*/
/** Standard Asynchronous Mode : 8 bits , 1 stop , no parity*/
#define AT91C_US_ASYNC_MODE ( AT91C_US_USMODE_NORMAL + \
                        AT91C_US_NBSTOP_1_BIT + \
                        AT91C_US_PAR_NONE + \
                        AT91C_US_CHRL_8_BITS + \
                        AT91C_US_CLKS_CLOCK )

/** Standard External Asynchronous Mode : 8 bits , 1 stop , no parity*/
#define AT91C_US_ASYNC_SCK_MODE ( AT91C_US_USMODE_NORMAL + \
                            AT91C_US_NBSTOP_1_BIT + \
                            AT91C_US_PAR_NONE + \
                            AT91C_US_CHRL_8_BITS + \
                            AT91C_US_CLKS_EXT )

/** Standard Synchronous Mode : 8 bits , 1 stop , no parity*/
#define AT91C_US_SYNC_MODE ( AT91C_US_SYNC + \
                       AT91C_US_USMODE_NORMAL + \
                       AT91C_US_NBSTOP_1_BIT + \
                       AT91C_US_PAR_NONE + \
                       AT91C_US_CHRL_8_BITS + \
                       AT91C_US_CLKS_CLOCK )

/** SCK used Label*/
#define AT91C_US_SCK_USED (AT91C_US_CKLO | AT91C_US_CLKS_EXT)

/** Standard ISO T=0 Mode : 8 bits , 1 stop , parity*/
#define AT91C_US_ISO_READER_MODE ( AT91C_US_USMODE_ISO7816_0 + \
					   		 AT91C_US_CLKS_CLOCK +\
                       		 AT91C_US_NBSTOP_1_BIT + \
                       		 AT91C_US_PAR_EVEN + \
                       		 AT91C_US_CHRL_8_BITS + \
                       		 AT91C_US_CKLO +\
                       		 AT91C_US_OVER)

/** Standard IRDA mode*/
#define AT91C_US_ASYNC_IRDA_MODE (  AT91C_US_USMODE_IRDA + \
                            AT91C_US_NBSTOP_1_BIT + \
                            AT91C_US_PAR_NONE + \
                            AT91C_US_CHRL_8_BITS + \
                            AT91C_US_CLKS_CLOCK )

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_US_Baudrate*/
/** \brief Caluculate baud_value according to the main clock and the baud rate*/
/**----------------------------------------------------------------------------*/
__inline unsigned int AT91F_US_Baudrate (
	const unsigned int main_clock, /* \arg peripheral clock*/
	const unsigned int baud_rate)  /* \arg UART baudrate*/
{
	unsigned int baud_value = ((main_clock*10)/(baud_rate * 16));
	if ((baud_value % 10) >= 5)
		baud_value = (baud_value / 10) + 1;
	else
		baud_value /= 10;
	return baud_value;
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_US_SetBaudrate*/
/** \brief Set the baudrate according to the CPU clock*/
/**----------------------------------------------------------------------------*/
__inline void AT91F_US_SetBaudrate (
	AT91PS_USART pUSART,    /* \arg pointer to a USART controller*/
	unsigned int mainClock, /* \arg peripheral clock*/
	unsigned int speed)     /* \arg UART baudrate*/
{
	/** Define the baud rate divisor register*/
	pUSART->US_BRGR = AT91F_US_Baudrate(mainClock, speed);
}

/**----------------------------------------------------------------------------*/
/** \fn    AT91F_US_SetTimeguard*/
/** \brief Set USART timeguard*/
/**-----------------------------------------------------------------------