hw-libs/libchip/include/usbhs.h

Go to the documentation of this file.

/* ---------------------------------------------------------------------------- */
/*                  Atmel Microcontroller Software Support                      */
/*                       SAM Software Package License                           */
/* ---------------------------------------------------------------------------- */
/* Copyright (c) 2015, Atmel Corporation                                        */
/*                                                                              */
/* All rights reserved.                                                         */
/*                                                                              */
/* Redistribution and use in source and binary forms, with or without           */
/* modification, are permitted provided that the following condition is met:    */
/*                                                                              */
/* - Redistributions of source code must retain the above copyright notice,     */
/* this list of conditions and the disclaimer below.                            */
/*                                                                              */
/* Atmel's name may not be used to endorse or promote products derived from     */
/* this software without specific prior written permission.                     */
/*                                                                              */
/* DISCLAIMER:  THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR   */
/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE   */
/* DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,      */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,  */
/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    */
/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING         */
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, */
/* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                           */
/* ---------------------------------------------------------------------------- */

#ifndef USBHS_H
#define USBHS_H

#include <assert.h>

#define  USB_DEVICE_HS_SUPPORT

#define  USB_DEVICE_EP_CTRL_SIZE       64

#define CHIP_USB_UDP

#define CHIP_USB_PULLUP_INTERNAL

#define CHIP_USB_NUMENDPOINTS   10

#define CHIP_USB_ENDPOINTS_MAXPACKETSIZE(ep) \
        ((ep == 0) ? 64 : 1024)

#define CHIP_USB_ENDPOINTS_BANKS(ep)            ((ep==0)?1:((ep<=2)?3:2))


#define CHIP_USB_ENDPOINTS_HBW(ep)               ((((ep)>=1) &&((ep)<=2))?true:false)

#define CHIP_USB_ENDPOINTS_DMA(ep)              ((((ep)>=1)&&((ep)<=7))?true:false)

#define DMA_MAX_FIFO_SIZE     (65536/1)

#define EPT_VIRTUAL_SIZE      8192


#define uhd_get_pipe_max_nbr()                (9)
#define USBHS_EPT_NUM                        (uhd_get_pipe_max_nbr()+1)
#define uhd_get_pipe_bank_max_nbr(ep)         ((ep == 0) ? 1 : ((ep <= 2) ? 3 : 2))
#define uhd_get_pipe_size_max(ep)             (((ep) == 0) ? 64 : 1024)
#define Is_uhd_pipe_dma_supported(ep)         ((((ep) >= 1) && ((ep) <= 7)) ? true : false)
#define Is_uhd_pipe_high_bw_supported(ep)     (((ep) >= 2) ? true : false)

typedef enum {
        HOST_MODE = 0,
        DEVICE_MODE = 1
} USB_Mode_t;

#define UHD_PIPE_MAX_TRANS 0x8000

__STATIC_INLINE void USBHS_FreezeClock(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_CTRL |= USBHS_CTRL_FRZCLK;
}

__STATIC_INLINE void USBHS_UnFreezeClock(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_CTRL &= ~((uint32_t)USBHS_CTRL_FRZCLK);
}
__STATIC_INLINE void USBHS_VBusHWC(Usbhs *pUsbhs, uint8_t Enable)
{

        if (!Enable)
                pUsbhs->USBHS_CTRL |= (1 << 8);
        else
                pUsbhs->USBHS_CTRL &= ~((uint32_t)(1 << 8));
}

__STATIC_INLINE void USBHS_UsbEnable(Usbhs *pUsbhs, uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_CTRL |= USBHS_CTRL_USBE;
        else
                pUsbhs->USBHS_CTRL &= ~((uint32_t)USBHS_CTRL_USBE);
}


__STATIC_INLINE void USBHS_UsbMode(Usbhs *pUsbhs, USB_Mode_t Mode)
{
        if (Mode)
                pUsbhs->USBHS_CTRL |= USBHS_CTRL_UIMOD_DEVICE;
        else
                pUsbhs->USBHS_CTRL &= ~((uint32_t)USBHS_CTRL_UIMOD_DEVICE);
}

/********************* USBHS_SR  *****************/

__STATIC_INLINE uint8_t USBHS_ISUsableClock(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_SR & USBHS_SR_CLKUSABLE) >> 14);
}


__STATIC_INLINE uint32_t USBHS_ReadStatus(Usbhs *pUsbhs)
{
        return (pUsbhs->USBHS_SR);
}

__STATIC_INLINE uint32_t USBHS_GetUsbSpeed(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_SR & USBHS_SR_SPEED_Msk));
}


__STATIC_INLINE bool USBHS_IsUsbFullSpeed(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_SR & USBHS_SR_SPEED_Msk) == USBHS_SR_SPEED_FULL_SPEED) ?
                   true : false;
}


__STATIC_INLINE bool USBHS_IsUsbHighSpeed(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_SR & USBHS_SR_SPEED_Msk) == USBHS_SR_SPEED_HIGH_SPEED) ?
                   true : false;
}

__STATIC_INLINE bool USBHS_IsUsbLowSpeed(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_SR & USBHS_SR_SPEED_Msk) == USBHS_SR_SPEED_LOW_SPEED) ?
                   true : false;
}
/********************* USBHS_SCR  *****************/

__STATIC_INLINE void USBHS_Ack(Usbhs *pUsbhs, uint32_t AckType)
{
        pUsbhs->USBHS_SCR |= AckType;
}

/********************* USBHS_SFR  *****************/

__STATIC_INLINE void USBHS_Set(Usbhs *pUsbhs, uint32_t SetStatus)
{
        pUsbhs->USBHS_SFR |= SetStatus;
}


/*--------------------------------------------------------
* =========== USB Device functions ======================
*---------------------------------------------------------*/

__STATIC_INLINE void USBHS_EnableAddress(Usbhs *pUsbhs, uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_ADDEN;
        else
                pUsbhs->USBHS_DEVCTRL &= ~((uint32_t)USBHS_DEVCTRL_ADDEN);
}

__STATIC_INLINE void USBHS_SetAddress(Usbhs *pUsbhs, uint8_t Addr)
{
        pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_UADD(Addr);
        pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_ADDEN;
}

__STATIC_INLINE uint8_t USBHS_GetAddress(Usbhs *pUsbhs)
{
        return (pUsbhs->USBHS_DEVCTRL & USBHS_DEVCTRL_UADD_Msk);
}

__STATIC_INLINE void USBHS_DetachUsb(Usbhs *pUsbhs, uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_DETACH;
        else
                pUsbhs->USBHS_DEVCTRL &= ~((uint32_t)USBHS_DEVCTRL_DETACH);

}

__STATIC_INLINE void USBHS_ForceLowSpeed(Usbhs *pUsbhs, uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_LS;
        else
                pUsbhs->USBHS_DEVCTRL &= ~((uint32_t)USBHS_DEVCTRL_LS);
}

__STATIC_INLINE void USBHS_EnableHighSpeed(Usbhs *pUsbhs, uint8_t Enable)
{
        uint32_t cfg = pUsbhs->USBHS_DEVCTRL;
        cfg &= ~((uint32_t)USBHS_DEVCTRL_SPDCONF_Msk);

        if (Enable)
                pUsbhs->USBHS_DEVCTRL |= cfg;
        else
                pUsbhs->USBHS_DEVCTRL |= (cfg | USBHS_DEVCTRL_SPDCONF_FORCED_FS);

}

__STATIC_INLINE void USBHS_SetRemoteWakeUp(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_RMWKUP;
}

__STATIC_INLINE void USBHS_EnableTestMode(Usbhs *pUsbhs, uint32_t mode)
{
        pUsbhs->USBHS_DEVCTRL |= mode;
}


__STATIC_INLINE void USBHS_EnableHSTestMode(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_DEVCTRL |= USBHS_DEVCTRL_SPDCONF_HIGH_SPEED;
}

__STATIC_INLINE uint32_t USBHS_ReadIntStatus(Usbhs *pUsbhs, uint32_t IntType)
{
        return (pUsbhs->USBHS_DEVISR & IntType);
}

__STATIC_INLINE uint32_t USBHS_ReadEpIntStatus(Usbhs *pUsbhs, uint8_t EpNum)
{
        return (pUsbhs->USBHS_DEVISR & (USBHS_DEVISR_PEP_0 << EpNum));
}

__STATIC_INLINE uint32_t USBHS_ReadDmaIntStatus(Usbhs *pUsbhs, uint8_t DmaNum)
{
        return (pUsbhs->USBHS_DEVISR & (USBHS_DEVISR_DMA_1 << DmaNum));
}

__STATIC_INLINE void USBHS_AckInt(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_DEVICR |=  IntType;
}

__STATIC_INLINE void USBHS_RaiseInt(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_DEVIFR |=  IntType;
}

__STATIC_INLINE void USBHS_RaiseDmaInt(Usbhs *pUsbhs, uint8_t Dma)
{
        assert(Dma < USBHSDEVDMA_NUMBER);
        pUsbhs->USBHS_DEVIFR |=  (USBHS_DEVIFR_DMA_1 << Dma);
}

__STATIC_INLINE uint32_t USBHS_IsIntEnable(Usbhs *pUsbhs, uint32_t IntType)
{
        return (pUsbhs->USBHS_DEVIMR &  IntType);
}

__STATIC_INLINE uint32_t USBHS_IsIntEnableEP(Usbhs *pUsbhs, uint8_t EpNum)
{
        return (pUsbhs->USBHS_DEVIMR &  (USBHS_DEVIMR_PEP_0 << EpNum));
}


__STATIC_INLINE uint32_t USBHS_IsDmaIntEnable(Usbhs *pUsbhs, uint8_t DmaNum)
{
        return (pUsbhs->USBHS_DEVIMR &  (USBHS_DEVIMR_DMA_1 << DmaNum));
}


__STATIC_INLINE void USBHS_EnableInt(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_DEVIER |=  IntType;
}

__STATIC_INLINE void USBHS_EnableIntEP(Usbhs *pUsbhs, uint8_t EpNum)
{
        pUsbhs->USBHS_DEVIER |=  (USBHS_DEVIER_PEP_0 << EpNum);
}

__STATIC_INLINE void USBHS_EnableDMAIntEP(Usbhs *pUsbhs, uint32_t DmaEp)
{
        assert(DmaEp < USBHSDEVDMA_NUMBER);
        pUsbhs->USBHS_DEVIER |=  (USBHS_DEVIER_DMA_1 << DmaEp);
}

__STATIC_INLINE void USBHS_DisableInt(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_DEVIDR |=  IntType;
}

__STATIC_INLINE void USBHS_DisableIntEP(Usbhs *pUsbhs, uint8_t Ep)
{
        pUsbhs->USBHS_DEVIDR |=  (USBHS_DEVIDR_PEP_0 << Ep);
}

__STATIC_INLINE void USBHS_DisableDMAIntEP(Usbhs *pUsbhs, uint8_t DmaEp)
{
        assert(DmaEp < USBHSDEVDMA_NUMBER);
        pUsbhs->USBHS_DEVIDR |=  (USBHS_DEVIDR_DMA_1 << DmaEp);
}


__STATIC_INLINE void USBHS_EnableEP(Usbhs *pUsbhs, uint8_t Ep, uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_DEVEPT |= (USBHS_DEVEPT_EPEN0 << Ep);
        else
                pUsbhs->USBHS_DEVEPT &= ~(uint32_t)(USBHS_DEVEPT_EPEN0 << Ep);

}


__STATIC_INLINE void USBHS_ResetEP(Usbhs *pUsbhs, uint8_t Ep)
{
        pUsbhs->USBHS_DEVEPT |=  (USBHS_DEVEPT_EPRST0 << Ep);
        pUsbhs->USBHS_DEVEPT &=  ~(uint32_t)(USBHS_DEVEPT_EPRST0 << Ep);
}

__STATIC_INLINE uint32_t USBHS_IsEPEnabled(Usbhs *pUsbhs, uint8_t Ep)
{
        return (pUsbhs->USBHS_DEVEPT & (USBHS_DEVEPT_EPEN0 << Ep));
}

__STATIC_INLINE uint8_t USBHS_GetMicroFrameNum(Usbhs *pUsbhs)
{
        return (pUsbhs->USBHS_DEVFNUM & USBHS_DEVFNUM_MFNUM_Msk);
}


__STATIC_INLINE uint8_t USBHS_GetFrameNum(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_DEVFNUM & USBHS_DEVFNUM_FNUM_Msk)
                         >> USBHS_DEVFNUM_FNUM_Pos);
}

__STATIC_INLINE uint8_t USBHS_GetFrameNumCrcErr(Usbhs *pUsbhs)
{
        return ((pUsbhs->USBHS_DEVFNUM & USBHS_DEVFNUM_FNCERR) >> 15);
}

/*-----------------------------------------
* =========== USB Device's Endpoint functions ========
*------------------------------------------*/

__STATIC_INLINE void USBHS_ConfigureEPs(Usbhs *pUsbhs, const uint8_t Ep,
                                                                                const uint8_t Type, const uint8_t Dir,
                                                                                const uint8_t Size, const uint8_t Bank)
{

        pUsbhs->USBHS_DEVEPTCFG[Ep] |=
                ((Size << USBHS_DEVEPTCFG_EPSIZE_Pos) & USBHS_DEVEPTCFG_EPSIZE_Msk);
        pUsbhs->USBHS_DEVEPTCFG[Ep] |=
                ((Dir << 8) & USBHS_DEVEPTCFG_EPDIR);
        pUsbhs->USBHS_DEVEPTCFG[Ep] |=
                (((Type) << USBHS_DEVEPTCFG_EPTYPE_Pos) & USBHS_DEVEPTCFG_EPTYPE_Msk);
        pUsbhs->USBHS_DEVEPTCFG[Ep] |=
                (((Bank) << USBHS_DEVEPTCFG_EPBK_Pos) & USBHS_DEVEPTCFG_EPBK_Msk);
}


__STATIC_INLINE void USBHS_AutoSwitchBankEnable(Usbhs *pUsbhs, uint8_t Ep,
                uint8_t Enable)
{
        if (Enable)
                pUsbhs->USBHS_DEVEPTCFG[Ep] |= USBHS_DEVEPTCFG_AUTOSW;
        else
                pUsbhs->USBHS_DEVEPTCFG[Ep] &= ~((uint32_t)USBHS_DEVEPTCFG_AUTOSW);
}


__STATIC_INLINE void USBHS_AllocateMemory(Usbhs *pUsbhs, uint8_t Ep)
{
        pUsbhs->USBHS_DEVEPTCFG[Ep] |= USBHS_DEVEPTCFG_ALLOC;
}


__STATIC_INLINE void USBHS_FreeMemory(Usbhs *pUsbhs, uint8_t Ep)
{
        pUsbhs->USBHS_DEVEPTCFG[Ep] &= ~((uint32_t)USBHS_DEVEPTCFG_ALLOC);
}


__STATIC_INLINE uint32_t USBHS_GetConfigureEPs(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t IntType)
{
        return ((pUsbhs->USBHS_DEVEPTCFG[Ep]) & IntType);
}

__STATIC_INLINE uint8_t USBHS_GetEpType(Usbhs *pUsbhs, uint8_t Ep)
{
        return ((pUsbhs->USBHS_DEVEPTCFG[Ep] & USBHS_DEVEPTCFG_EPTYPE_Msk)
                        >> USBHS_DEVEPTCFG_EPTYPE_Pos);
}

__STATIC_INLINE uint32_t USBHS_GetEpSize(Usbhs *pUsbhs, uint8_t Ep)
{
        return (8 << ((pUsbhs->USBHS_DEVEPTCFG[Ep] & USBHS_DEVEPTCFG_EPSIZE_Msk)
                                        >> USBHS_DEVEPTCFG_EPSIZE_Pos));
}


__STATIC_INLINE void USBHS_SetIsoTrans(Usbhs *pUsbhs, uint8_t Ep,
                                                                           uint8_t nbTrans)
{
        pUsbhs->USBHS_DEVEPTCFG[Ep] |= USBHS_DEVEPTCFG_NBTRANS(nbTrans);
}

__STATIC_INLINE uint32_t USBHS_IsEpIntEnable(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t EpIntType)
{
        return (pUsbhs->USBHS_DEVEPTIMR[Ep] & EpIntType);
}


__STATIC_INLINE void USBHS_EnableEPIntType(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t EpInt)
{
        pUsbhs->USBHS_DEVEPTIER[Ep] |=  EpInt;
}

__STATIC_INLINE uint32_t USBHS_IsBankKilled(Usbhs *pUsbhs, uint8_t Ep)
{
        return (pUsbhs->USBHS_DEVEPTIMR[Ep] & USBHS_DEVEPTIMR_KILLBK);
}

__STATIC_INLINE void USBHS_KillBank(Usbhs *pUsbhs, uint8_t Ep)
{
        pUsbhs->USBHS_DEVEPTIER[Ep] =  USBHS_DEVEPTIER_KILLBKS;
}
__STATIC_INLINE void USBHS_DisableEPIntType(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t EpInt)
{
        pUsbhs->USBHS_DEVEPTIDR[Ep] |=  EpInt;
}

__STATIC_INLINE void USBHS_AckEpInterrupt(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t EpInt)
{
        pUsbhs->USBHS_DEVEPTICR[Ep] |=  EpInt;
}

__STATIC_INLINE void USBHS_RaiseEPInt(Usbhs *pUsbhs, uint8_t Ep, uint32_t EpInt)
{
        pUsbhs->USBHS_DEVEPTIFR[Ep] |=  EpInt;
}

__STATIC_INLINE uint32_t USBHS_ReadEPStatus(Usbhs *pUsbhs, uint8_t Ep,
                uint32_t EpInt)
{
        return (pUsbhs->USBHS_DEVEPTISR[Ep] & EpInt);
}

__STATIC_INLINE uint8_t USBHS_IsBankFree(Usbhs *pUsbhs, uint8_t Ep)
{
        if ((pUsbhs->USBHS_DEVEPTISR[Ep] & USBHS_DEVEPTISR_NBUSYBK_Msk))
                return false;
        else
                return true;
}

__STATIC_INLINE uint8_t USBHS_NumOfBanksInUse(Usbhs *pUsbhs, uint8_t Ep)
{
        return ((pUsbhs->USBHS_DEVEPTISR[Ep] & USBHS_DEVEPTISR_NBUSYBK_Msk)
                         >> USBHS_DEVEPTISR_NBUSYBK_Pos);
}


__STATIC_INLINE uint16_t USBHS_ByteCount(Usbhs *pUsbhs, uint8_t Ep)
{
        return (uint16_t)((pUsbhs->USBHS_DEVEPTISR[Ep] & USBHS_DEVEPTISR_BYCT_Msk)
                                           >> USBHS_DEVEPTISR_BYCT_Pos);
}

/*--------------------------------------------------------
* =========== USB Device's Ep's DMA functions =========
*---------------------------------------------------------*/

__STATIC_INLINE void USBHS_SetDmaNDA(UsbhsDevdma *pUsbDma, uint32_t Desc)
{
        pUsbDma->USBHS_DEVDMANXTDSC = Desc;
}

__STATIC_INLINE uint32_t USBHS_GetDmaNDA(UsbhsDevdma *pUsbDma)
{
        return (pUsbDma->USBHS_DEVDMANXTDSC);
}

__STATIC_INLINE void USBHS_SetDmaBuffAdd(UsbhsDevdma *pUsbDma, uint32_t Addr)
{
        pUsbDma->USBHS_DEVDMAADDRESS = Addr;
}


__STATIC_INLINE uint32_t USBHS_GetDmaBuffAdd(UsbhsDevdma *pUsbDma)
{
        return (pUsbDma->USBHS_DEVDMAADDRESS);
}

__STATIC_INLINE void USBHS_ConfigureDma(UsbhsDevdma *pUsbDma, uint32_t Cfg)
{
        pUsbDma->USBHS_DEVDMACONTROL |= Cfg;
}

__STATIC_INLINE uint32_t USBHS_GetDmaConfiguration(UsbhsDevdma *pUsbDma)
{
        return (pUsbDma->USBHS_DEVDMACONTROL);
}


__STATIC_INLINE void USBHS_SetDmaStatus(UsbhsDevdma *pUsbDma, uint32_t Status)
{
        pUsbDma->USBHS_DEVDMASTATUS = Status;
}


__STATIC_INLINE uint32_t USBHS_GetDmaStatus(UsbhsDevdma *pUsbDma)
{
        return (pUsbDma->USBHS_DEVDMASTATUS);
}


__STATIC_INLINE uint16_t USBHS_GetDmaBuffCount(UsbhsDevdma *pUsbDma)
{
        return ((pUsbDma->USBHS_DEVDMASTATUS & USBHS_DEVDMASTATUS_BUFF_COUNT_Msk)
                         >> USBHS_DEVDMASTATUS_BUFF_COUNT_Pos);
}


/*--------------------------------------------------------
* =========== USB Host Functions  ========================
*---------------------------------------------------------*/

#define CHIP_USB_NUMPIPE            10

#define CHIP_USB_DMA_NUMPIPE        7

#define CHIP_USB_PIPE_MAXPACKETSIZE(ep) \
        ((ep == 0) ? 64 : 1024)

#define CHIP_USB_PIPE_BANKS(ep)                 ((ep==0)?1:((ep<=2)?3:2))


#define CHIP_USB_PIPE_HBW(ep)                   ((((ep)>=1) &&((ep)<=2))?true:false)

#define CHIP_USB_PIPE_DMA(ep)                   ((((ep)>=1)&&((ep)<=7))?true:false)

__STATIC_INLINE void USBHS_SetHostHighSpeed(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_HSTCTRL &= ~USBHS_HSTCTRL_SPDCONF_Msk;
        pUsbhs->USBHS_HSTCTRL |= USBHS_HSTCTRL_SPDCONF_NORMAL;
}

__STATIC_INLINE void USBHS_SetHostLowSpeed(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_HSTCTRL &= ~USBHS_HSTCTRL_SPDCONF_Msk;
        pUsbhs->USBHS_HSTCTRL |= USBHS_HSTCTRL_SPDCONF_LOW_POWER;
}

__STATIC_INLINE void USBHS_SetHostForcedFullSpeed(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_HSTCTRL &= ~USBHS_HSTCTRL_SPDCONF_Msk;
        pUsbhs->USBHS_HSTCTRL |= USBHS_HSTCTRL_SPDCONF_FORCED_FS;
}

__STATIC_INLINE void USBHS_Reset(void)
{
        USBHS->USBHS_HSTCTRL |= USBHS_HSTCTRL_RESET;
}

__STATIC_INLINE void USBHS_StopReset(void)
{
        USBHS->USBHS_HSTCTRL &= ~USBHS_HSTCTRL_RESET;
}

__STATIC_INLINE void USBHS_Resume(void)
{
        USBHS->USBHS_HSTCTRL |= USBHS_HSTCTRL_RESUME;
}

__STATIC_INLINE void USBHS_EnableSOF(Usbhs *pUsbhs)
{
        pUsbhs->USBHS_HSTCTRL |= USBHS_HSTCTRL_SOFE;
}

__STATIC_INLINE uint8_t USBHS_IsEnableSOF(Usbhs *pUsbhs)
{
        return (pUsbhs->USBHS_HSTCTRL & USBHS_HSTCTRL_SOFE) >> 8;
}
__STATIC_INLINE void USBHS_DisableSOF(void)
{
        USBHS->USBHS_HSTCTRL &= ~USBHS_HSTCTRL_SOFE;
}

__STATIC_INLINE uint32_t USBHS_GetHostStatus(Usbhs *pUsbhs, uint8_t IntType)
{
        return (pUsbhs->USBHS_HSTISR & IntType);
}


__STATIC_INLINE uint32_t USBHS_GetHostPipeStatus(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt < CHIP_USB_NUMPIPE);
        return (pUsbhs->USBHS_HSTISR & (USBHS_HSTISR_PEP_0 << PipeInt));
}


__STATIC_INLINE uint32_t USBHS_GetHostDmaPipeStatus(Usbhs *pUsbhs,
                uint8_t PipeInt)
{
        assert(PipeInt);
        assert(PipeInt < CHIP_USB_DMA_NUMPIPE);
        return (pUsbhs->USBHS_HSTISR & (USBHS_HSTISR_DMA_1 << PipeInt));
}

__STATIC_INLINE void USBHS_ClearHostStatus(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_HSTICR = IntType;
}

__STATIC_INLINE void USBHS_SetHostStatus(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_HSTIFR = IntType;
}

__STATIC_INLINE void USBHS_SetHostDmaStatus(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt);
        assert(PipeInt < CHIP_USB_DMA_NUMPIPE);
        pUsbhs->USBHS_HSTIFR =  (USBHS_HSTIFR_DMA_1 << PipeInt);
}

/*** Interrupt Mask ****/
__STATIC_INLINE uint8_t USBHS_IsHostIntEnable(Usbhs *pUsbhs, uint8_t IntType)
{
        return (pUsbhs->USBHS_HSTIMR & IntType);
}

__STATIC_INLINE uint32_t USBHS_IsHostPipeIntEnable(Usbhs *pUsbhs,
                uint8_t PipeInt)
{
        assert(PipeInt < CHIP_USB_NUMPIPE);
        return (pUsbhs->USBHS_HSTIMR & (USBHS_HSTIMR_PEP_0 << PipeInt));
}

__STATIC_INLINE uint32_t USBHS_IsHostDmaIntEnable(Usbhs *pUsbhs,
                uint8_t PipeInt)
{
        assert(PipeInt);
        assert(PipeInt < CHIP_USB_DMA_NUMPIPE);
        return (pUsbhs->USBHS_HSTIMR & (USBHS_HSTIMR_DMA_1 << PipeInt));
}

/*** Interrupt Disable ****/
__STATIC_INLINE void USBHS_HostIntDisable(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_HSTIDR = IntType;
}

__STATIC_INLINE void USBHS_HostPipeIntDisable(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTIDR  = (USBHS_HSTIDR_PEP_0 << PipeInt);
}

__STATIC_INLINE void USBHS_HostDmaIntDisable(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt);
        assert(PipeInt < CHIP_USB_DMA_NUMPIPE);
        pUsbhs->USBHS_HSTIDR = (USBHS_HSTIDR_DMA_1 << PipeInt);
}

/*** Interrupt Enable ****/

__STATIC_INLINE void USBHS_HostIntEnable(Usbhs *pUsbhs, uint32_t IntType)
{
        pUsbhs->USBHS_HSTIER = IntType;
}

__STATIC_INLINE void USBHS_HostPipeIntEnable(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTIER = (USBHS_HSTIER_PEP_0 << PipeInt);
}

__STATIC_INLINE void USBHS_HostDmaIntEnable(Usbhs *pUsbhs, uint8_t PipeInt)
{
        assert(PipeInt < CHIP_USB_DMA_NUMPIPE);
        pUsbhs->USBHS_HSTIER |= (USBHS_HSTIER_DMA_1 << PipeInt);
}

__STATIC_INLINE uint16_t USBHS_HostGetSOF(void)
{
        return ((USBHS->USBHS_HSTFNUM & USBHS_HSTFNUM_FNUM_Msk) >>
                         USBHS_HSTFNUM_FNUM_Pos);
}

__STATIC_INLINE uint16_t USBHS_HostGetFramePos(void)
{
        return ((USBHS->USBHS_HSTFNUM & USBHS_HSTFNUM_FLENHIGH_Msk) >>
                         USBHS_HSTFNUM_FLENHIGH_Pos);
}


__STATIC_INLINE uint16_t USBHS_HostGetMSOF(void)
{
        return ((USBHS->USBHS_HSTFNUM & USBHS_HSTFNUM_MFNUM_Msk) >>
                         USBHS_HSTFNUM_MFNUM_Pos);
}

__STATIC_INLINE void USBHS_HostSetAddr(Usbhs *pUsbhs, uint8_t Pipe,
                                                                           uint8_t Addr)
{
        assert(Pipe < CHIP_USB_NUMPIPE);

        if (Pipe < 4)
                pUsbhs->USBHS_HSTADDR1 |= (Addr << (8 * Pipe));
        else if ((Pipe < 8) && (Pipe >= 4))
                pUsbhs->USBHS_HSTADDR2 |= (Addr << (8 * (Pipe - 4)));
        else
                pUsbhs->USBHS_HSTADDR3 |= (Addr << (8 * (Pipe - 8)));

}

__STATIC_INLINE uint8_t USBHS_HostGetAddr(Usbhs *pUsbhs, uint8_t Pipe)
{
        assert(Pipe < CHIP_USB_NUMPIPE);

        if (Pipe < 4)
                return (pUsbhs->USBHS_HSTADDR1 >>  (8 * Pipe));
        else if ((Pipe < 8) && (Pipe >= 4))
                return (pUsbhs->USBHS_HSTADDR2  >>  (8 * (Pipe - 4)));
        else
                return (pUsbhs->USBHS_HSTADDR3  >> (8 * (Pipe - 8)));

}

__STATIC_INLINE void USBHS_HostPipeEnable(Usbhs *pUsbhs, uint8_t Pipe)
{
        assert(Pipe < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTPIP |= (USBHS_HSTPIP_PEN0 << Pipe);
}

__STATIC_INLINE void USBHS_HostPipeDisable(Usbhs *pUsbhs, uint8_t Pipe)
{
        assert(Pipe < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTPIP &= ~(USBHS_HSTPIP_PEN0 << Pipe);
}

__STATIC_INLINE uint32_t USBHS_IsHostPipeEnable(Usbhs *pUsbhs, uint8_t Pipe)
{
        assert(Pipe < CHIP_USB_NUMPIPE);
        return (pUsbhs->USBHS_HSTPIP & (USBHS_HSTPIP_PEN0 << Pipe));
}
__STATIC_INLINE void USBHS_HostPipeReset(Usbhs *pUsbhs, uint8_t Pipe)
{
        assert(Pipe < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTPIP |= (USBHS_HSTPIP_PRST0 << Pipe);
        pUsbhs->USBHS_HSTPIP &= ~(USBHS_HSTPIP_PRST0 << Pipe);
}

__STATIC_INLINE void USBHS_HostConfigure(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t pipeBank, uint8_t pipeSize, uint32_t pipeType, uint32_t pipeToken,
                uint8_t pipeEpNum, uint8_t PipeIntFreq)
{
        assert(Pipe < CHIP_USB_NUMPIPE);
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= (pipeBank | pipeToken | USBHS_HSTPIPCFG_PSIZE(
                                                                                   pipeSize) | pipeType | USBHS_HSTPIPCFG_PEPNUM(pipeEpNum) |
                                                                           USBHS_HSTPIPCFG_INTFRQ(PipeIntFreq));
}

__STATIC_INLINE void USBHS_HostAllocMem(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= USBHS_HSTPIPCFG_ALLOC;

}

__STATIC_INLINE void USBHS_HostFreeMem(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] &= ~USBHS_HSTPIPCFG_ALLOC;

}


__STATIC_INLINE uint16_t USBHS_HostGetSize(Usbhs *pUsbhs, uint8_t Pipe)
{
        return (8 << ((pUsbhs->USBHS_HSTPIPCFG[Pipe] & USBHS_HSTPIPCFG_PSIZE_Msk) >>
                                  USBHS_HSTPIPCFG_PSIZE_Pos));

}

__STATIC_INLINE void USBHS_HostSetToken(Usbhs *pUsbhs, uint8_t Pipe,
                                                                                uint32_t Token)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] &= ~USBHS_HSTPIPCFG_PTOKEN_Msk;
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= Token;

}


__STATIC_INLINE uint32_t USBHS_HostGetToken(Usbhs *pUsbhs, uint8_t Pipe)
{
        return (pUsbhs->USBHS_HSTPIPCFG[Pipe] & USBHS_HSTPIPCFG_PTOKEN_Msk);

}


__STATIC_INLINE void USBHS_HostSetPipeType(Usbhs *pUsbhs, uint8_t Pipe,
                uint8_t PipeType)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] &= ~USBHS_HSTPIPCFG_PTYPE_Msk;
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= PipeType;

}

__STATIC_INLINE uint32_t USBHS_HostGetPipeType(Usbhs *pUsbhs, uint8_t Pipe)
{
        return (pUsbhs->USBHS_HSTPIPCFG[Pipe] & USBHS_HSTPIPCFG_PTYPE_Msk);

}

__STATIC_INLINE uint8_t USBHS_GetPipeEpAddr(Usbhs *pUsbhs, uint8_t Pipe)
{

        if (USBHS_HostGetToken(USBHS, Pipe) == USBHS_HSTPIPCFG_PTOKEN_IN)
                return (((pUsbhs->USBHS_HSTPIPCFG[Pipe] & USBHS_HSTPIPCFG_PEPNUM_Msk) >>
                                  USBHS_HSTPIPCFG_PEPNUM_Pos) | 0x80);
        else
                return (((pUsbhs->USBHS_HSTPIPCFG[Pipe] & USBHS_HSTPIPCFG_PEPNUM_Msk) >>
                                  USBHS_HSTPIPCFG_PEPNUM_Pos) | 0x00);
}



__STATIC_INLINE void USBHS_HostEnableAutoSw(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= USBHS_HSTPIPCFG_AUTOSW;
}

__STATIC_INLINE void USBHS_HostDisableAutoSw(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] &= ~USBHS_HSTPIPCFG_AUTOSW;
}

__STATIC_INLINE void USBHS_HostSetIntFreq(Usbhs *pUsbhs, uint8_t Pipe,
                uint8_t Freq)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= USBHS_HSTPIPCFG_BINTERVAL(Freq);
}


__STATIC_INLINE void USBHS_HostEnablePing(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPCFG[Pipe] |= USBHS_HSTPIPCFG_PINGEN;
}


__STATIC_INLINE uint8_t USBHS_HostGetDataTogSeq(Usbhs *pUsbhs, uint8_t Pipe)
{
        return ((pUsbhs->USBHS_HSTPIPISR[Pipe] & USBHS_HSTPIPISR_DTSEQ_Msk) >>
                         USBHS_HSTPIPISR_DTSEQ_Pos);
}


__STATIC_INLINE uint8_t USBHS_HostGetNumOfBusyBank(Usbhs *pUsbhs, uint8_t Pipe)
{
        return ((pUsbhs->USBHS_HSTPIPISR[Pipe] & USBHS_HSTPIPISR_NBUSYBK_Msk) >>
                         USBHS_HSTPIPISR_NBUSYBK_Pos);
}


__STATIC_INLINE uint8_t USBHS_HostGetCurrentBank(Usbhs *pUsbhs, uint8_t Pipe)
{
        return ((pUsbhs->USBHS_HSTPIPISR[Pipe] & USBHS_HSTPIPISR_CURRBK_Msk) >>
                         USBHS_HSTPIPISR_CURRBK_Pos);
}


__STATIC_INLINE uint8_t USBHS_HostGetPipeByteCount(Usbhs *pUsbhs, uint8_t Pipe)
{
        return ((pUsbhs->USBHS_HSTPIPISR[Pipe] & USBHS_HSTPIPISR_PBYCT_Msk) >>
                         USBHS_HSTPIPISR_PBYCT_Pos);
}

__STATIC_INLINE uint32_t USBHS_IsHostConfigOk(Usbhs *pUsbhs, uint8_t Pipe)
{
        return (pUsbhs->USBHS_HSTPIPISR[Pipe] & USBHS_DEVEPTISR_CFGOK);
}

__STATIC_INLINE uint32_t USBHS_HostGetIntTypeStatus(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t intType)
{
        return (pUsbhs->USBHS_HSTPIPISR[Pipe] & intType);
}

__STATIC_INLINE void USBHS_HostAckPipeIntType(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t intType)
{
        pUsbhs->USBHS_HSTPIPICR[Pipe] = intType;
}

__STATIC_INLINE void USBHS_HostSetPipeIntType(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t intType)
{
        pUsbhs->USBHS_HSTPIPIFR[Pipe] = intType;
}

__STATIC_INLINE uint32_t USBHS_IsHostPipeIntTypeEnable(Usbhs *pUsbhs,
                uint8_t Pipe, uint32_t intType)
{
        return (pUsbhs->USBHS_HSTPIPIMR[Pipe] & intType);
}

__STATIC_INLINE void USBHS_HostDisablePipeIntType(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t intType)
{
        pUsbhs->USBHS_HSTPIPIDR[Pipe] = intType;
}

__STATIC_INLINE void USBHS_HostEnablePipeIntType(Usbhs *pUsbhs, uint8_t Pipe,
                uint32_t intType)
{
        pUsbhs->USBHS_HSTPIPIER[Pipe] = intType;
}

__STATIC_INLINE void USBHS_HostEnableInReq(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPINRQ[Pipe] |= USBHS_HSTPIPINRQ_INMODE;
}

__STATIC_INLINE void USBHS_HostDisableInReq(Usbhs *pUsbhs, uint8_t Pipe)
{
        pUsbhs->USBHS_HSTPIPINRQ[Pipe] &= ~USBHS_HSTPIPINRQ_INMODE;
}

__STATIC_INLINE uint8_t USBHS_IsHostInReqEnable(Usbhs *pUsbhs, uint8_t Pipe)
{
        return ((pUsbhs->USBHS_HSTPIPINRQ[Pipe] & USBHS_HSTPIPINRQ_INMODE) >> 8);
}

__STATIC_INLINE void USBHS_HostInReq(Usbhs *pUsbhs, uint8_t Pipe, uint8_t InReq)
{
        pUsbhs->USBHS_HSTPIPINRQ[Pipe] = USBHS_HSTPIPINRQ_INRQ(InReq - 1);
}


__STATIC_INLINE void USBHS_HostSetErr(Usbhs *pUsbhs, uint8_t Pipe, uint8_t Err)
{
        pUsbhs->USBHS_HSTPIPERR[Pipe] |= Err;
}

__STATIC_INLINE uint8_t USBHS_HostGetErr(Usbhs *pUsbhs, uint8_t Pipe,
                uint8_t Err)
{
        return (pUsbhs->USBHS_HSTPIPERR[Pipe] & Err);
}


__STATIC_INLINE void USBHS_HostClearErr(Usbhs *pUsbhs, uint8_t Pipe,
                                                                                uint8_t Err)
{
        pUsbhs->USBHS_HSTPIPERR[Pipe] = Err;
}


__STATIC_INLINE  uint8_t USBHS_GetInterruptPipeNum(void)
{
        uint32_t status = USBHS->USBHS_HSTISR;
        uint32_t mask = USBHS->USBHS_HSTIMR;
        return ctz(((status & mask) >> 8) | (1 << USBHS_EPT_NUM));
}

static inline uint8_t USBHS_GetInterruptPipeDmaNum(void)
{
        uint32_t status = USBHS->USBHS_HSTISR;
        uint32_t mask = USBHS->USBHS_HSTIMR;
        return (ctz(((status & mask) >> 25) | (1 << (USBHS_EPT_NUM - 1))) + 1);
}
/*--------------------------------------------------------
* =========== USB Host's pipe DMA functions =========
*---------------------------------------------------------*/

__STATIC_INLINE void USBHS_SetHostDmaNDA(UsbhsHstdma *pUsbDma, uint32_t Desc)
{
        pUsbDma->USBHS_HSTDMANXTDSC = Desc;
}

__STATIC_INLINE uint32_t USBHS_GetHostDmaNDA(UsbhsHstdma *pUsbDma)
{
        return (pUsbDma->USBHS_HSTDMANXTDSC);
}

__STATIC_INLINE void USBHS_SetHostDmaBuffAdd(UsbhsHstdma *pUsbDma,
                uint32_t Addr)
{
        pUsbDma->USBHS_HSTDMAADDRESS = Addr;
}


__STATIC_INLINE uint32_t USBHS_GetHostDmaBuffAdd(UsbhsHstdma *pUsbDma)
{
        return (pUsbDma->USBHS_HSTDMAADDRESS);
}

__STATIC_INLINE void USBHS_HostConfigureDma(UsbhsHstdma *pUsbDma, uint32_t Cfg)
{
        pUsbDma->USBHS_HSTDMACONTROL |= Cfg;
}

__STATIC_INLINE uint32_t USBHS_GetHostDmaConfiguration(UsbhsHstdma *pUsbDma)
{
        return (pUsbDma->USBHS_HSTDMACONTROL);
}


__STATIC_INLINE void USBHS_SetHostPipeDmaStatus(UsbhsHstdma *pUsbDma,
                uint32_t Status)
{
        pUsbDma->USBHS_HSTDMASTATUS = Status;
}


__STATIC_INLINE uint32_t USBHS_GetHostPipeDmaStatus(UsbhsHstdma *pUsbDma)
{
        return (pUsbDma->USBHS_HSTDMASTATUS);
}

#endif /* #ifndef USBHS_H */