lib_at91sam7x256.h

一个开源的Modbus协议栈

//*----------------------------------------------------------------------------
//* \fn    AT91F_PIO_Get_AB_RegisterStatus
//* \brief Return PIO Interrupt Status
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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 
//*----------------------------------------------------------------------------
static __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
//*----------------------------------------------------------------------------
static __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 PMC
   ***************************************************************************** */
//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_CfgSysClkEnableReg
//* \brief Configure the System Clock Enable Register of the PMC controller
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_CfgSysClkEnableReg( AT91PS_PMC pPMC,  // \arg pointer to PMC controller
                              unsigned int mode )
{
    //* Write to the SCER register
    pPMC->PMC_SCER = mode;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_CfgSysClkDisableReg
//* \brief Configure the System Clock Disable Register of the PMC controller
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_CfgSysClkDisableReg( AT91PS_PMC pPMC, // \arg pointer to PMC controller
                               unsigned int mode )
{
    //* Write to the SCDR register
    pPMC->PMC_SCDR = mode;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_GetSysClkStatusReg
//* \brief Return the System Clock Status Register of the PMC controller
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_PMC_GetSysClkStatusReg( AT91PS_PMC pPMC   // pointer to a CAN controller
     )
{
    return pPMC->PMC_SCSR;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_EnablePeriphClock
//* \brief Enable peripheral clock
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_EnablePeriphClock( AT91PS_PMC pPMC,   // \arg pointer to PMC controller
                             unsigned int periphIds )   // \arg IDs of peripherals
{
    pPMC->PMC_PCER = periphIds;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_DisablePeriphClock
//* \brief Disable peripheral clock
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_DisablePeriphClock( AT91PS_PMC pPMC,  // \arg pointer to PMC controller
                              unsigned int periphIds )  // \arg IDs of peripherals
{
    pPMC->PMC_PCDR = periphIds;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_GetPeriphClock
//* \brief Get peripheral clock status
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_PMC_GetPeriphClock( AT91PS_PMC pPMC )     // \arg pointer to PMC controller
{
    return pPMC->PMC_PCSR;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_CfgMainOscillatorReg
//* \brief Cfg the main oscillator
//*----------------------------------------------------------------------------
static __inline void
AT91F_CKGR_CfgMainOscillatorReg( AT91PS_CKGR pCKGR,     // \arg pointer to CKGR controller
                                 unsigned int mode )
{
    pCKGR->CKGR_MOR = mode;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_GetMainOscillatorReg
//* \brief Cfg the main oscillator
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_CKGR_GetMainOscillatorReg( AT91PS_CKGR pCKGR )    // \arg pointer to CKGR controller
{
    return pCKGR->CKGR_MOR;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_EnableMainOscillator
//* \brief Enable the main oscillator
//*----------------------------------------------------------------------------
static __inline void
AT91F_CKGR_EnableMainOscillator( AT91PS_CKGR pCKGR )    // \arg pointer to CKGR controller
{
    pCKGR->CKGR_MOR |= AT91C_CKGR_MOSCEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_DisableMainOscillator
//* \brief Disable the main oscillator
//*----------------------------------------------------------------------------
static __inline void
AT91F_CKGR_DisableMainOscillator( AT91PS_CKGR pCKGR )   // \arg pointer to CKGR controller
{
    pCKGR->CKGR_MOR &= ~AT91C_CKGR_MOSCEN;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_CfgMainOscStartUpTime
//* \brief Cfg MOR Register according to the main osc startup time
//*----------------------------------------------------------------------------
static __inline void
AT91F_CKGR_CfgMainOscStartUpTime( AT91PS_CKGR pCKGR,    // \arg pointer to CKGR controller
                                  unsigned int startup_time,    // \arg main osc startup time in microsecond (us)
                                  unsigned int slowClock )      // \arg slowClock in Hz
{
    pCKGR->CKGR_MOR &= ~AT91C_CKGR_OSCOUNT;
    pCKGR->CKGR_MOR |= ( ( slowClock * startup_time ) / ( 8 * 1000000 ) ) << 8;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_GetMainClockFreqReg
//* \brief Cfg the main oscillator
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_CKGR_GetMainClockFreqReg( AT91PS_CKGR pCKGR )     // \arg pointer to CKGR controller
{
    return pCKGR->CKGR_MCFR;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_CKGR_GetMainClock
//* \brief Return Main clock in Hz
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_CKGR_GetMainClock( AT91PS_CKGR pCKGR,     // \arg pointer to CKGR controller
                         unsigned int slowClock )       // \arg slowClock in Hz
{
    return ( ( pCKGR->CKGR_MCFR & AT91C_CKGR_MAINF ) * slowClock ) >> 4;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_CfgMCKReg
//* \brief Cfg Master Clock Register
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_CfgMCKReg( AT91PS_PMC pPMC,   // \arg pointer to PMC controller
                     unsigned int mode )
{
    pPMC->PMC_MCKR = mode;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_GetMCKReg
//* \brief Return Master Clock Register
//*----------------------------------------------------------------------------
static __inline unsigned int
AT91F_PMC_GetMCKReg( AT91PS_PMC pPMC )  // \arg pointer to PMC controller
{
    return pPMC->PMC_MCKR;
}

//*------------------------------------------------------------------------------
//* \fn    AT91F_PMC_GetMasterClock
//* \brief Return master clock in Hz which correponds to processor clock for ARM7
//*------------------------------------------------------------------------------
static __inline unsigned int
AT91F_PMC_GetMasterClock( AT91PS_PMC pPMC,      // \arg pointer to PMC controller
                          AT91PS_CKGR pCKGR,    // \arg pointer to CKGR controller
                          unsigned int slowClock )      // \arg slowClock in Hz
{
    unsigned int    reg = pPMC->PMC_MCKR;
    unsigned int    prescaler = ( 1 << ( ( reg & AT91C_PMC_PRES ) >> 2 ) );
    unsigned int    pllDivider, pllMultiplier;

    switch ( reg & AT91C_PMC_CSS )
    {
    case AT91C_PMC_CSS_SLOW_CLK:       // Slow clock selected
        return slowClock / prescaler;
    case AT91C_PMC_CSS_MAIN_CLK:       // Main clock is selected
        return AT91F_CKGR_GetMainClock( pCKGR, slowClock ) / prescaler;
    case AT91C_PMC_CSS_PLL_CLK:        // PLLB clock is selected
        reg = pCKGR->CKGR_PLLR;
        pllDivider = ( reg & AT91C_CKGR_DIV );
        pllMultiplier = ( ( reg & AT91C_CKGR_MUL ) >> 16 ) + 1;
        return AT91F_CKGR_GetMainClock( pCKGR, slowClock ) / pllDivider * pllMultiplier / prescaler;
    }
    return 0;
}

//*----------------------------------------------------------------------------
//* \fn    AT91F_PMC_EnablePCK
//* \brief Enable Programmable Clock x Output
//*----------------------------------------------------------------------------
static __inline void
AT91F_PMC_EnablePCK( AT91PS_PMC pPMC,   // \arg pointer to PMC controller
                     unsigned int pck,  // \arg Programmable Clock x Output
                     unsigned int mode )
{
    pPMC->PMC_PCKR[pck] = mode;
    pPMC->PMC_SCER = ( 1 << pck ) << 8;
}