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  (16U) 
#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;
/*---------------------------------------------------------------------
 * 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 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 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);
}
 
void usb_phy_init(USB_Type *ptr);
 
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;
}
 
/*---------------------------------------------------------------------
 * 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;
}
 
#if defined __cplusplus
}
#endif /* __cplusplus */
 
#endif /* HPM_USB_DRV_H */