hsusbd.h

Go to the documentation of this file.

/**************************************************************************/
#ifndef __HSUSBD_H__
#define __HSUSBD_H__
 
#ifdef __cplusplus
extern "C"
{
#endif
 
 
#define HSUSBD_MAX_EP     12ul
 
#define Maximum(a,b)    (a)>(b) ? (a) : (b)
#define Minimum(a,b)    (((a)<(b)) ? (a) : (b))
 
 
#define CEP     0xfful    
#define EPA     0ul       
#define EPB     1ul       
#define EPC     2ul       
#define EPD     3ul       
#define EPE     4ul       
#define EPF     5ul       
#define EPG     6ul       
#define EPH     7ul       
#define EPI     8ul       
#define EPJ     9ul       
#define EPK     10ul      
#define EPL     11ul      
/********************* Bit definition of CEPCTL register **********************/
#define HSUSBD_CEPCTL_NAKCLR               ((uint32_t)0x00000000ul)      
#define HSUSBD_CEPCTL_STALL                ((uint32_t)0x00000002ul)      
#define HSUSBD_CEPCTL_ZEROLEN              ((uint32_t)0x00000004ul)      
#define HSUSBD_CEPCTL_FLUSH                ((uint32_t)0x00000008ul)      
/********************* Bit definition of EPxRSPCTL register **********************/
#define HSUSBD_EP_RSPCTL_FLUSH             ((uint32_t)0x00000001ul)      
#define HSUSBD_EP_RSPCTL_MODE_AUTO         ((uint32_t)0x00000000ul)      
#define HSUSBD_EP_RSPCTL_MODE_MANUAL       ((uint32_t)0x00000002ul)      
#define HSUSBD_EP_RSPCTL_MODE_FLY          ((uint32_t)0x00000004ul)      
#define HSUSBD_EP_RSPCTL_MODE_MASK         ((uint32_t)0x00000006ul)      
#define HSUSBD_EP_RSPCTL_TOGGLE            ((uint32_t)0x00000008ul)      
#define HSUSBD_EP_RSPCTL_HALT              ((uint32_t)0x00000010ul)      
#define HSUSBD_EP_RSPCTL_ZEROLEN           ((uint32_t)0x00000020ul)      
#define HSUSBD_EP_RSPCTL_SHORTTXEN         ((uint32_t)0x00000040ul)      
#define HSUSBD_EP_RSPCTL_DISBUF            ((uint32_t)0x00000080ul)      
/********************* Bit definition of EPxCFG register **********************/
#define HSUSBD_EP_CFG_VALID                ((uint32_t)0x00000001ul)      
#define HSUSBD_EP_CFG_TYPE_BULK            ((uint32_t)0x00000002ul)      
#define HSUSBD_EP_CFG_TYPE_INT             ((uint32_t)0x00000004ul)      
#define HSUSBD_EP_CFG_TYPE_ISO             ((uint32_t)0x00000006ul)      
#define HSUSBD_EP_CFG_TYPE_MASK            ((uint32_t)0x00000006ul)      
#define HSUSBD_EP_CFG_DIR_OUT              ((uint32_t)0x00000000ul)      
#define HSUSBD_EP_CFG_DIR_IN               ((uint32_t)0x00000008ul)      
/*---------------------------------------------------------------------------------------------------------*/
/* HSUSBD Define Error Code                                                                                */
/*---------------------------------------------------------------------------------------------------------*/
#define HSUSBD_TIMEOUT                     SystemCoreClock               
#define HSUSBD_OK                          ( 0L)                         
#define HSUSBD_ERR_FAIL                    (-1L)                         
#define HSUSBD_ERR_TIMEOUT                 (-2L)                          /* end of group HSUSBD_EXPORTED_CONSTANTS */
 
typedef struct HSUSBD_CMD_STRUCT
{
    uint8_t  bmRequestType;
    uint8_t  bRequest;
    uint16_t wValue;
    uint16_t wIndex;
    uint16_t wLength;
 
} S_HSUSBD_CMD_T; 
typedef struct s_hsusbd_info
{
    uint8_t *gu8DevDesc;            
    uint8_t *gu8ConfigDesc;         
    uint8_t **gu8StringDesc;        
    uint8_t *gu8QualDesc;           
    uint8_t *gu8FullConfigDesc;     
    uint8_t *gu8HSOtherConfigDesc;  
    uint8_t *gu8FSOtherConfigDesc;  
    uint8_t **gu8HidReportDesc;     
    uint32_t *gu32HidReportSize;    
    uint32_t *gu32ConfigHidDescIdx; 
} S_HSUSBD_INFO_T;  /* end of group HSUSBD_EXPORTED_STRUCT */
 
extern uint32_t g_u32HsEpStallLock;
extern uint8_t volatile g_hsusbd_Configured;
extern uint8_t g_hsusbd_ShortPacket;
extern uint8_t g_hsusbd_CtrlZero;
extern uint8_t g_hsusbd_UsbAddr;
extern uint32_t volatile g_hsusbd_DmaDone;
extern uint32_t g_hsusbd_CtrlInSize;
extern S_HSUSBD_INFO_T gsHSInfo;
extern S_HSUSBD_CMD_T gUsbCmd;
#define HSUSBD_ENABLE_USB()               ((uint32_t)(HSUSBD->PHYCTL |= (HSUSBD_PHYCTL_PHYEN_Msk|HSUSBD_PHYCTL_DPPUEN_Msk))) 
#define HSUSBD_DISABLE_USB()              ((uint32_t)(HSUSBD->PHYCTL &= ~HSUSBD_PHYCTL_DPPUEN_Msk)) 
#define HSUSBD_ENABLE_PHY()               ((uint32_t)(HSUSBD->PHYCTL |= HSUSBD_PHYCTL_PHYEN_Msk)) 
#define HSUSBD_DISABLE_PHY()              ((uint32_t)(HSUSBD->PHYCTL &= ~HSUSBD_PHYCTL_PHYEN_Msk)) 
#define HSUSBD_SET_SE0()                  ((uint32_t)(HSUSBD->PHYCTL &= ~HSUSBD_PHYCTL_DPPUEN_Msk)) 
#define HSUSBD_CLR_SE0()                  ((uint32_t)(HSUSBD->PHYCTL |= HSUSBD_PHYCTL_DPPUEN_Msk)) 
#define HSUSBD_SET_ADDR(addr)             (HSUSBD->FADDR = (addr)) 
#define HSUSBD_GET_ADDR()                 ((uint32_t)(HSUSBD->FADDR)) 
#define HSUSBD_ENABLE_USB_INT(intr)       (HSUSBD->GINTEN = (intr)) 
#define HSUSBD_ENABLE_BUS_INT(intr)       (HSUSBD->BUSINTEN = (intr)) 
#define HSUSBD_GET_BUS_INT_FLAG()         (HSUSBD->BUSINTSTS)        
#define HSUSBD_CLR_BUS_INT_FLAG(flag)     (HSUSBD->BUSINTSTS = (flag)) 
#define HSUSBD_ENABLE_CEP_INT(intr)       (HSUSBD->CEPINTEN = (intr)) 
#define HSUSBD_CLR_CEP_INT_FLAG(flag)     (HSUSBD->CEPINTSTS = (flag)) 
#define HSUSBD_SET_CEP_STATE(flag)        (HSUSBD->CEPCTL = (flag)) 
#define HSUSBD_START_CEP_IN(size)         (HSUSBD->CEPTXCNT = (size)) 
#define HSUSBD_SET_MAX_PAYLOAD(ep, size)  (HSUSBD->EP[(ep)].EPMPS = (size)) 
#define HSUSBD_ENABLE_EP_INT(ep, intr)    (HSUSBD->EP[(ep)].EPINTEN = (intr)) 
#define HSUSBD_GET_EP_INT_FLAG(ep)        (HSUSBD->EP[(ep)].EPINTSTS) 
#define HSUSBD_CLR_EP_INT_FLAG(ep, flag)  (HSUSBD->EP[(ep)].EPINTSTS = (flag)) 
#define HSUSBD_SET_DMA_LEN(len)           (HSUSBD->DMACNT = (len)) 
#define HSUSBD_SET_DMA_ADDR(addr)         (HSUSBD->DMAADDR = (addr)) 
#define HSUSBD_SET_DMA_READ(epnum)        (HSUSBD->DMACTL = (HSUSBD->DMACTL & ~HSUSBD_DMACTL_EPNUM_Msk) | HSUSBD_DMACTL_DMARD_Msk | (epnum) | 0x100) 
#define HSUSBD_SET_DMA_WRITE(epnum)       (HSUSBD->DMACTL = (HSUSBD->DMACTL & ~(HSUSBD_DMACTL_EPNUM_Msk | HSUSBD_DMACTL_DMARD_Msk | 0x100)) | (epnum)) 
#define HSUSBD_ENABLE_DMA()               (HSUSBD->DMACTL |= HSUSBD_DMACTL_DMAEN_Msk) 
#define HSUSBD_IS_ATTACHED()              ((uint32_t)(HSUSBD->PHYCTL & HSUSBD_PHYCTL_VBUSDET_Msk)) 
__STATIC_INLINE void HSUSBD_MemCopy(uint8_t u8Dst[], uint8_t u8Src[], uint32_t u32Size)
{
    uint32_t i = 0ul;
 
    while (u32Size--)
    {
        u8Dst[i] = u8Src[i];
        i++;
    }
}
 
__STATIC_INLINE void HSUSBD_ResetDMA(void)
{
    HSUSBD->DMACNT = 0ul;
    HSUSBD->DMACTL = 0x80ul;
    HSUSBD->DMACTL = 0x00ul;
}
__STATIC_INLINE void HSUSBD_SetEpBufAddr(uint32_t u32Ep, uint32_t u32Base, uint32_t u32Len)
{
    if (u32Ep == CEP)
    {
        HSUSBD->CEPBUFST = u32Base;
        HSUSBD->CEPBUFEND   = u32Base + u32Len - 1ul;
    }
    else
    {
        HSUSBD->EP[u32Ep].EPBUFST = u32Base;
        HSUSBD->EP[u32Ep].EPBUFEND = u32Base + u32Len - 1ul;
    }
}
 
__STATIC_INLINE void HSUSBD_ConfigEp(uint32_t u32Ep, uint32_t u32EpNum, uint32_t u32EpType, uint32_t u32EpDir)
{
    if (u32EpType == HSUSBD_EP_CFG_TYPE_BULK)
    {
        HSUSBD->EP[u32Ep].EPRSPCTL = (HSUSBD_EP_RSPCTL_FLUSH|HSUSBD_EP_RSPCTL_MODE_AUTO);
    }
    else if (u32EpType == HSUSBD_EP_CFG_TYPE_INT)
    {
        HSUSBD->EP[u32Ep].EPRSPCTL = (HSUSBD_EP_RSPCTL_FLUSH|HSUSBD_EP_RSPCTL_MODE_MANUAL);
    }
    else if (u32EpType == HSUSBD_EP_CFG_TYPE_ISO)
    {
        HSUSBD->EP[u32Ep].EPRSPCTL = (HSUSBD_EP_RSPCTL_FLUSH|HSUSBD_EP_RSPCTL_MODE_FLY);
    }
 
    HSUSBD->EP[u32Ep].EPCFG = (u32EpType|u32EpDir|HSUSBD_EP_CFG_VALID|(u32EpNum << 4));
}
 
__STATIC_INLINE void HSUSBD_SetEpStall(uint32_t u32Ep)
{
    if (u32Ep == CEP)
    {
        HSUSBD_SET_CEP_STATE(HSUSBD_CEPCTL_STALL);
    }
    else
    {
        HSUSBD->EP[u32Ep].EPRSPCTL = (HSUSBD->EP[u32Ep].EPRSPCTL & 0xf7ul) | HSUSBD_EP_RSPCTL_HALT;
    }
}
 
__STATIC_INLINE void HSUSBD_SetStall(uint32_t u32EpNum)
{
    uint32_t i;
 
    if (u32EpNum == 0ul)
    {
        HSUSBD_SET_CEP_STATE(HSUSBD_CEPCTL_STALL);
    }
    else
    {
        for (i=0ul; i<HSUSBD_MAX_EP; i++)
        {
            if (((HSUSBD->EP[i].EPCFG & 0xf0ul) >> 4) == u32EpNum)
            {
                HSUSBD->EP[i].EPRSPCTL = (HSUSBD->EP[i].EPRSPCTL & 0xf7ul) | HSUSBD_EP_RSPCTL_HALT;
            }
        }
    }
}
 
__STATIC_INLINE void  HSUSBD_ClearEpStall(uint32_t u32Ep)
{
    HSUSBD->EP[u32Ep].EPRSPCTL = HSUSBD_EP_RSPCTL_TOGGLE;
}
 
__STATIC_INLINE void HSUSBD_ClearStall(uint32_t u32EpNum)
{
    uint32_t i;
 
    for (i=0ul; i<HSUSBD_MAX_EP; i++)
    {
        if (((HSUSBD->EP[i].EPCFG & 0xf0ul) >> 4) == u32EpNum)
        {
            HSUSBD->EP[i].EPRSPCTL = HSUSBD_EP_RSPCTL_TOGGLE;
        }
    }
}
 
__STATIC_INLINE uint32_t HSUSBD_GetEpStall(uint32_t u32Ep)
{
    return (HSUSBD->EP[u32Ep].EPRSPCTL & HSUSBD_EP_RSPCTL_HALT);
}
 
__STATIC_INLINE uint32_t HSUSBD_GetStall(uint32_t u32EpNum)
{
    uint32_t i;
    uint32_t val = 0ul;
 
    for (i=0ul; i<HSUSBD_MAX_EP; i++)
    {
        if (((HSUSBD->EP[i].EPCFG & 0xf0ul) >> 4) == u32EpNum)
        {
            val = (HSUSBD->EP[i].EPRSPCTL & HSUSBD_EP_RSPCTL_HALT);
            break;
        }
    }
    return val;
}
 
 
/*-------------------------------------------------------------------------------------------*/
typedef void (*HSUSBD_VENDOR_REQ)(void); 
typedef void (*HSUSBD_CLASS_REQ)(void); 
typedef void (*HSUSBD_SET_INTERFACE_REQ)(uint32_t u32AltInterface); 
void HSUSBD_Open(S_HSUSBD_INFO_T *param, HSUSBD_CLASS_REQ pfnClassReq, HSUSBD_SET_INTERFACE_REQ pfnSetInterface);
void HSUSBD_Start(void);
void HSUSBD_ProcessSetupPacket(void);
void HSUSBD_StandardRequest(void);
void HSUSBD_UpdateDeviceState(void);
void HSUSBD_PrepareCtrlIn(uint8_t pu8Buf[], uint32_t u32Size);
void HSUSBD_CtrlIn(void);
int32_t HSUSBD_CtrlOut(uint8_t pu8Buf[], uint32_t u32Size);
void HSUSBD_SwReset(void);
void HSUSBD_SetVendorRequest(HSUSBD_VENDOR_REQ pfnVendorReq);
 
 
 /* end of group HSUSBD_EXPORTED_FUNCTIONS */
 /* end of group HSUSBD_Driver */
 /* end of group Standard_Driver */
 
#ifdef __cplusplus
}
#endif
 
#endif /*__HSUSBD_H__ */
 
/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/