hpm_usb_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_USB_DRV_H
#define HPM_USB_DRV_H
/*---------------------------------------------------------------------
 * Includes
 *---------------------------------------------------------------------
 */
#include "hpm_common.h"
#include "hpm_usb_regs.h"
#include "hpm_soc_feature.h"
 
/*---------------------------------------------------------------------
 *  Macro Constant Declarations
 *---------------------------------------------------------------------
 */
#define USB_PHY_INIT_DELAY_COUNT  (100U) 
#define USB_HOST_FRAMELIST_SIZE   (8U)  
/*---------------------------------------------------------------------
 *  Macro Enum Declarations
 *---------------------------------------------------------------------
 */
typedef enum {
    usb_dir_out     = 0,
    usb_dir_in      = 1,
    usb_dir_in_mask = 0x80
} usb_dir_t;    
typedef enum {
    usb_xfer_control = 0,
    usb_xfer_isochronous,
    usb_xfer_bulk,
    usb_xfer_interrupt
} usb_xfer_type_t;    
typedef enum {
    usb_ctrl_mode_otg    = 0,
    usb_ctrl_mode_device = 2,
    usb_ctrl_mode_host   = 3
} usb_controller_mode_t;    
typedef enum {
    usb_line_state0 = 0,
    usb_line_state1 = 1,
    usb_line_state2 = 2
} usb_line_state_t;    
typedef enum {
    usb_tran_parallel = 0,
    usb_tran_serial = 1
} usb_transceiver_t;    
typedef enum {
    usb_test_mode_disable = 0,
    usb_test_j_state,
    usb_test_k_state,
    usb_test_se0_nak,
    usb_test_packet,
    usb_test_force_hs,
    usb_test_force_fs,
    usb_test_force_ls,
} usb_test_mode_t;    
typedef enum {
    usb_vbus_wakeup_vbus_valid = 0,
    usb_vbus_wakeup_session_valid,
} usb_vbus_wakeup_source_t;    
/*---------------------------------------------------------------------
 * Structure Declarations
 *---------------------------------------------------------------------
 */
typedef struct  __attribute__ ((packed)) {
    union {
        struct  __attribute__ ((packed)) {
            uint8_t recipient :  5;
            uint8_t type      :  2;
            uint8_t direction :  1;
        } bmRequestType_bit;
 
        uint8_t bmRequestType;
    };
 
    uint8_t  bRequest;
    uint16_t wValue;
    uint16_t wIndex;
    uint16_t wLength;
} usb_control_request_t;
 
typedef struct {
    uint8_t  xfer;
    uint8_t  ep_addr;
    uint16_t max_packet_size;
} usb_endpoint_config_t;
 
#if defined __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/*---------------------------------------------------------------------
 * Common API
 *---------------------------------------------------------------------
 */
 
static inline uint32_t usb_get_interrupts(USB_Type *ptr)
{
    return ptr->USBINTR;
}
 
static inline void usb_enable_interrupts(USB_Type *ptr, uint32_t mask)
{
    ptr->USBINTR |= mask;
}
 
static inline void usb_disable_interrupts(USB_Type *ptr, uint32_t mask)
{
    ptr->USBINTR &= ~mask;
}
 
static inline uint32_t usb_get_status_flags(USB_Type *ptr)
{
    return ptr->USBSTS;
}
 
static inline void usb_clear_status_flags(USB_Type *ptr, uint32_t mask)
{
    ptr->USBSTS = mask;
}
 
static inline void usb_otg_enable_dpdm_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 |= USB_OTG_CTRL0_OTG_WKDPDMCHG_EN_MASK;
}
 
static inline void usb_otg_disable_dpdm_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 &= ~USB_OTG_CTRL0_OTG_WKDPDMCHG_EN_MASK;
}
 
static inline void usb_otg_enable_id_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 |= USB_OTG_CTRL0_OTG_ID_WAKEUP_EN_MASK;
}
 
static inline void usb_otg_disable_id_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 &= ~USB_OTG_CTRL0_OTG_ID_WAKEUP_EN_MASK;
}
 
static inline void usb_otg_enable_vbus_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 |= USB_OTG_CTRL0_OTG_VBUS_WAKEUP_EN_MASK;
}
 
static inline void usb_otg_disable_vbus_wakeup(USB_Type *ptr)
{
    ptr->OTG_CTRL0 &= ~USB_OTG_CTRL0_OTG_VBUS_WAKEUP_EN_MASK;
}
 
static inline void usb_otg_set_vbus_wakeup_source(USB_Type *ptr, usb_vbus_wakeup_source_t src)
{
    ptr->OTG_CTRL0 = (ptr->OTG_CTRL0 & ~USB_OTG_CTRL0_OTG_VBUS_SOURCE_SEL_MASK) | USB_OTG_CTRL0_OTG_VBUS_SOURCE_SEL_SET(src);
}
 
static inline void usb_otg_enable_wakeup_int(USB_Type *ptr)
{
    ptr->OTG_CTRL0 |=  USB_OTG_CTRL0_OTG_WAKEUP_INT_ENABLE_MASK;
}
 
static inline void usb_otg_disable_wakeup_int(USB_Type *ptr)
{
    ptr->OTG_CTRL0 &= ~USB_OTG_CTRL0_OTG_WAKEUP_INT_ENABLE_MASK;
}
 
static inline bool usb_get_otg_wakeup_int_flag(USB_Type *ptr)
{
    return (USB_TOP_STATUS_WAKEUP_INT_STATUS_GET(ptr->TOP_STATUS) != 0) ? true : false;
}
 
static inline uint8_t usb_get_suspend_status(USB_Type *ptr)
{
    return USB_PORTSC1_SUSP_GET(ptr->PORTSC1);
}
 
static inline bool usb_get_port_reset_status(USB_Type *ptr)
{
    return USB_PORTSC1_PR_GET(ptr->PORTSC1);
}
 
static inline bool usb_get_port_ccs(USB_Type *ptr)
{
    return USB_PORTSC1_CCS_GET(ptr->PORTSC1);
}
 
static inline uint8_t usb_get_port_speed(USB_Type *ptr)
{
    return USB_PORTSC1_PSPD_GET(ptr->PORTSC1);
}
 
static inline void usb_set_port_test_mode(USB_Type *ptr, usb_test_mode_t test_mode)
{
    ptr->PORTSC1 = (ptr->PORTSC1 & ~USB_PORTSC1_PTC_MASK) | USB_PORTSC1_PTC_SET(test_mode);
}
 
static inline void usb_set_port_suspend(USB_Type *ptr)
{
    ptr->PORTSC1 |= USB_PORTSC1_SUSP_MASK;
}
 
static inline void usb_force_port_resume(USB_Type *ptr)
{
    ptr->PORTSC1 |= USB_PORTSC1_FPR_MASK;
    while ((ptr->PORTSC1 & USB_PORTSC1_FPR_MASK) != 0) {
    }
}
 
static inline void usb_phy_enter_low_power_suspend(USB_Type *ptr)
{
    ptr->PORTSC1 |= USB_PORTSC1_PHCD_MASK;
}
 
static inline void usb_phy_exit_low_power_suspend(USB_Type *ptr)
{
    ptr->PORTSC1 &= ~USB_PORTSC1_PHCD_MASK;
    /* otg utmi clock detection */
    ptr->PHY_STATUS |= USB_PHY_STATUS_UTMI_CLK_VALID_MASK;                 /* write 1 to clear valid status */
    while (USB_PHY_STATUS_UTMI_CLK_VALID_GET(ptr->PHY_STATUS) == 0) {      /* get utmi clock status */
        ;
    }
}
 
static inline bool usb_phy_get_session_valid_flag(USB_Type *ptr)
{
    return (USB_PHY_STATUS_UTMI_SESS_VALID_GET(ptr->PHY_STATUS) != 0) ? true : false;
}
 
static inline void usb_otgsc_enable_session_valid_chg_int(USB_Type *ptr)
{
    ptr->OTGSC |= USB_OTGSC_ASVIE_MASK;
}
 
static inline void usb_otgsc_disable_session_valid_chg_int(USB_Type *ptr)
{
    ptr->OTGSC &= ~USB_OTGSC_ASVIE_MASK;
}
 
static inline bool usb_otgsc_session_valid_chg_int_is_enable(USB_Type *ptr)
{
    return ((ptr->OTGSC & USB_OTGSC_ASVIE_MASK) != 0);
}
 
static inline bool usb_otgsc_get_session_valid_chg_flag(USB_Type *ptr)
{
    return (USB_OTGSC_ASVIS_SET(ptr->OTGSC) != 0) ? true : false;
}
 
static inline void usb_otgsc_clear_session_valid_chg_flag(USB_Type *ptr)
{
    ptr->OTGSC |= USB_OTGSC_ASVIS_MASK;
}
 
static inline bool usb_otgsc_get_session_valid_flag(USB_Type *ptr)
{
    return (USB_OTGSC_ASV_GET(ptr->OTGSC) != 0) ? true : false;
}
 
void usb_phy_init(USB_Type *ptr, bool host);
 
static inline uint8_t usb_phy_get_line_state(USB_Type *ptr)
{
    return USB_PHY_STATUS_LINE_STATE_GET(ptr->PHY_STATUS);
}
 
static inline void usb_phy_using_internal_vbus(USB_Type *ptr)
{
    ptr->PHY_CTRL0 |= (USB_PHY_CTRL0_VBUS_VALID_OVERRIDE_MASK | USB_PHY_CTRL0_SESS_VALID_OVERRIDE_MASK)
                    | (USB_PHY_CTRL0_VBUS_VALID_OVERRIDE_EN_MASK | USB_PHY_CTRL0_SESS_VALID_OVERRIDE_EN_MASK);
}
 
static inline void usb_phy_using_external_vbus(USB_Type *ptr)
{
    ptr->PHY_CTRL0 &= ~((USB_PHY_CTRL0_VBUS_VALID_OVERRIDE_MASK | USB_PHY_CTRL0_SESS_VALID_OVERRIDE_MASK)
                      | (USB_PHY_CTRL0_VBUS_VALID_OVERRIDE_EN_MASK | USB_PHY_CTRL0_SESS_VALID_OVERRIDE_EN_MASK));
}
 
static inline void usb_phy_disable_dp_dm_pulldown(USB_Type *ptr)
{
    ptr->PHY_CTRL0 |= 0x001000E0u;
}
 
static inline void usb_phy_enable_dp_dm_pulldown(USB_Type *ptr)
{
    ptr->PHY_CTRL0 &= ~0x001000E0u;
}
 
static inline void usb_phyctrl1_set_not_utmi_suspend(USB_Type *ptr)
{
    ptr->PHY_CTRL1 |= USB_PHY_CTRL1_UTMI_OTG_SUSPENDM_MASK;
}
 
/*---------------------------------------------------------------------
 * Device API
 *---------------------------------------------------------------------
 */
 
void usb_dcd_bus_reset(USB_Type *ptr, uint16_t ep0_max_packet_size);
 
void usb_dcd_init(USB_Type *ptr);
 
void usb_dcd_deinit(USB_Type *ptr);
 
void usb_dcd_remote_wakeup(USB_Type *ptr);
 
void usb_dcd_edpt_open(USB_Type *ptr, usb_endpoint_config_t *config);
 
uint8_t usb_dcd_edpt_get_type(USB_Type *ptr, uint8_t ep_addr);
 
void usb_dcd_edpt_xfer(USB_Type *ptr, uint8_t ep_idx);
 
void usb_dcd_edpt_stall(USB_Type *ptr, uint8_t ep_addr);
 
void usb_dcd_edpt_clear_stall(USB_Type *ptr, uint8_t ep_addr);
 
bool usb_dcd_edpt_check_stall(USB_Type *ptr, uint8_t ep_addr);
 
void usb_dcd_edpt_close(USB_Type *ptr, uint8_t ep_addr);
 
void usb_dcd_connect(USB_Type *ptr);
 
void usb_dcd_disconnect(USB_Type *ptr);
 
static inline uint32_t usb_dcd_get_edpt_setup_status(USB_Type *ptr)
{
    return ptr->ENDPTSETUPSTAT;
}
 
static inline void usb_dcd_clear_edpt_setup_status(USB_Type *ptr, uint32_t mask)
{
    ptr->ENDPTSETUPSTAT = mask;
}
 
static inline void usb_dcd_set_address(USB_Type *ptr, uint8_t dev_addr)
{
    ptr->DEVICEADDR = USB_DEVICEADDR_USBADR_SET(dev_addr) | USB_DEVICEADDR_USBADRA_MASK;
}
 
static inline void usb_dcd_set_edpt_list_addr(USB_Type *ptr, uint32_t addr)
{
    ptr->ENDPTLISTADDR = addr & USB_ENDPTLISTADDR_EPBASE_MASK;
}
 
static inline uint8_t usb_dcd_get_device_addr(USB_Type *ptr)
{
    return USB_DEVICEADDR_USBADR_GET(ptr->DEVICEADDR);
}
 
static inline uint32_t usb_dcd_get_edpt_complete_status(USB_Type *ptr)
{
    return ptr->ENDPTCOMPLETE;
}
 
static inline void usb_dcd_clear_edpt_complete_status(USB_Type *ptr, uint32_t mask)
{
    ptr->ENDPTCOMPLETE = mask;
}
 
/*---------------------------------------------------------------------
 * Host API
 *---------------------------------------------------------------------
 */
bool usb_hcd_init(USB_Type *ptr, uint32_t int_mask, uint16_t framelist_size);
 
void usb_hcd_port_reset(USB_Type *ptr);
 
static inline void usb_hcd_set_command(USB_Type *ptr, uint32_t mask)
{
    ptr->USBCMD |= mask;
}
 
static inline uint32_t usb_hcd_get_frame_index(USB_Type *ptr)
{
    return ptr->FRINDEX;
}
 
static inline bool usb_hcd_get_port_csc(USB_Type *ptr)
{
    return USB_PORTSC1_CSC_GET(ptr->PORTSC1);
}
 
static inline void usb_hcd_set_power_ctrl_polarity(USB_Type *ptr, bool high)
{
    if (high) {
        ptr->OTG_CTRL0 |= USB_OTG_CTRL0_OTG_POWER_MASK_MASK;
    } else {
        ptr->OTG_CTRL0 &= ~USB_OTG_CTRL0_OTG_POWER_MASK_MASK;
    }
}
 
static inline void usb_hcd_enable_port_power(USB_Type *ptr)
{
    ptr->PORTSC1 |= USB_PORTSC1_PP_MASK;
}
 
static inline void usb_hcd_set_async_list_addr(USB_Type *ptr, uint32_t addr)
{
    ptr->ASYNCLISTADDR = addr & USB_ASYNCLISTADDR_ASYBASE_MASK;
}
 
static inline void usb_hcd_set_periodic_list_addr(USB_Type *ptr, uint32_t addr)
{
    ptr->PERIODICLISTBASE = addr & USB_PERIODICLISTBASE_BASEADR_MASK;
}
 
static inline void usb_hcd_run(USB_Type *ptr)
{
    ptr->USBCMD |= USB_USBCMD_RS_MASK;
}
 
static inline void usb_hcd_stop(USB_Type *ptr)
{
    ptr->USBCMD &= ~USB_USBCMD_RS_MASK;
}
 
static inline void usb_hcd_disable_ase_pse(USB_Type *ptr)
{
    ptr->USBCMD &= ~(USB_USBCMD_PSE_MASK | USB_USBCMD_ASE_MASK);
    while (ptr->USBCMD & (USB_USBCMD_PSE_MASK | USB_USBCMD_ASE_MASK)) {
        ;
    }
}
 
static inline void usb_hcd_enable_ase_pse(USB_Type *ptr)
{
    ptr->USBCMD |= (USB_USBCMD_PSE_MASK | USB_USBCMD_ASE_MASK);
}
 
#if defined __cplusplus
}
#endif /* __cplusplus */
 
#endif /* HPM_USB_DRV_H */