diff --git a/port/hpm/usb_dc_hpm.c b/port/hpm/usb_dc_hpm.c new file mode 100644 index 00000000..a19fb42a --- /dev/null +++ b/port/hpm/usb_dc_hpm.c @@ -0,0 +1,250 @@ +#include "board.h" +#include "hpm_usb_device.h" +#include "usbd_core.h" + +#ifndef USBD_IRQHandler +#define USBD_IRQHandler USBD_IRQHandler // use actual usb irq name instead +#endif + +#ifndef USB_NUM_BIDIR_ENDPOINTS +#define USB_NUM_BIDIR_ENDPOINTS USB_SOC_DCD_MAX_ENDPOINT_COUNT +#endif + +/* USBSTS, USBINTR */ +enum { + intr_usb = HPM_BITSMASK(1, 0), + intr_error = HPM_BITSMASK(1, 1), + intr_port_change = HPM_BITSMASK(1, 2), + intr_reset = HPM_BITSMASK(1, 6), + intr_sof = HPM_BITSMASK(1, 7), + intr_suspend = HPM_BITSMASK(1, 8), + intr_nak = HPM_BITSMASK(1, 16) +}; + +/* Endpoint state */ +struct hpm_ep_state { + /** Endpoint max packet size */ + uint16_t ep_mps; + /** Endpoint Transfer Type. + * May be Bulk, Interrupt, Control or Isochronous + */ + uint8_t ep_type; + uint8_t ep_stalled; /** Endpoint stall flag */ +}; + +/* Driver state */ +struct hpm_udc { + usb_device_handle_t *handle; + struct hpm_ep_state in_ep[USB_NUM_BIDIR_ENDPOINTS]; /*!< IN endpoint parameters*/ + struct hpm_ep_state out_ep[USB_NUM_BIDIR_ENDPOINTS]; /*!< OUT endpoint parameters */ +} g_hpm_udc; + +static ATTR_PLACE_AT_NONCACHEABLE_WITH_ALIGNMENT(USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT) dcd_data_t _dcd_data; +static ATTR_PLACE_AT_NONCACHEABLE usb_device_handle_t usb_device_handle[USB_SOC_MAX_COUNT]; + +/* Index to bit position in register */ +static inline uint8_t ep_idx2bit(uint8_t ep_idx) +{ + return ep_idx / 2 + ((ep_idx % 2) ? 16 : 0); +} + +__WEAK void usb_dc_low_level_init(void) +{ +} + +__WEAK void usb_dc_low_level_deinit(void) +{ +} + +int usb_dc_init(void) +{ + memset(&g_hpm_udc, 0, sizeof(struct hpm_udc)); + + usb_dc_low_level_init(); + + g_hpm_udc.handle = &usb_device_handle[0]; + g_hpm_udc.handle->regs = (USB_Type *)HPM_USB0_BASE; + g_hpm_udc.handle->dcd_data = &_dcd_data; + + uint32_t int_mask; + int_mask = (USB_USBINTR_UE_MASK | USB_USBINTR_UEE_MASK | + USB_USBINTR_PCE_MASK | USB_USBINTR_URE_MASK); + + usb_device_init(g_hpm_udc.handle, int_mask); + + intc_m_enable_irq(IRQn_USB0); + return 0; +} + +int usb_dc_deinit(void) +{ + return 0; +} + +int usbd_set_address(const uint8_t addr) +{ + usb_device_handle_t *handle = g_hpm_udc.handle; + usb_dcd_set_address(handle->regs, addr); + return 0; +} + +int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg) +{ + usb_endpoint_config_t tmp_ep_cfg; + usb_device_handle_t *handle = g_hpm_udc.handle; + + uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr); + + if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) { + g_hpm_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps; + g_hpm_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type; + } else { + g_hpm_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps; + g_hpm_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type; + } + + tmp_ep_cfg.xfer = ep_cfg->ep_type; + tmp_ep_cfg.ep_addr = ep_cfg->ep_addr; + tmp_ep_cfg.max_packet_size = ep_cfg->ep_mps; + + usb_device_edpt_open(handle, &tmp_ep_cfg); + return 0; +} + +int usbd_ep_close(const uint8_t ep) +{ + return 0; +} + +int usbd_ep_set_stall(const uint8_t ep) +{ + usb_device_handle_t *handle = g_hpm_udc.handle; + + usb_device_edpt_stall(handle, ep); + return 0; +} + +int usbd_ep_clear_stall(const uint8_t ep) +{ + usb_device_handle_t *handle = g_hpm_udc.handle; + + usb_device_edpt_clear_stall(handle, ep); + return 0; +} + +int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +{ + return 0; +} + +int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +{ + uint8_t ep_idx = USB_EP_GET_IDX(ep); + usb_device_handle_t *handle = g_hpm_udc.handle; + + if (!data && data_len) { + return -1; + } + + usb_device_edpt_xfer(handle, ep, data, data_len); + + return 0; +} + +int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +{ + uint8_t ep_idx = USB_EP_GET_IDX(ep); + usb_device_handle_t *handle = g_hpm_udc.handle; + + if (!data && data_len) { + return -1; + } + + usb_device_edpt_xfer(handle, ep, data, data_len); + + return 0; +} + +void USBD_IRQHandler(void) +{ + uint32_t int_status; + uint32_t speed; + usb_device_handle_t *handle = g_hpm_udc.handle; + uint32_t transfer_len; + + /* Acknowledge handled interrupt */ + int_status = usb_device_status_flags(handle); + int_status &= usb_device_interrupts(handle); + usb_device_clear_status_flags(handle, int_status); + + /* disabled interrupt sources */ + if (int_status == 0) { + return; + } + + if (int_status & intr_reset) { + speed = usb_device_get_port_speed(handle); + usbd_event_reset_handler(); + usb_device_bus_reset(handle, 64); + } + + if (int_status & intr_suspend) { + if (usb_device_get_suspend_status(handle)) { + /* Note: Host may delay more than 3 ms before and/or after bus reset + * before doing enumeration. */ + if (usb_device_get_address(handle)) { + } + } + } + + if (int_status & intr_port_change) { + if (!usb_device_get_port_ccs(handle)) { + } else { + if (usb_device_get_port_reset_status(handle) == 0) { + uint32_t speed = usb_device_get_port_speed(handle); + } + } + } + + if (int_status & intr_usb) { + uint32_t const edpt_complete = usb_device_get_edpt_complete_status(handle); + usb_device_clear_edpt_complete_status(handle, edpt_complete); + uint32_t edpt_setup_status = usb_device_get_setup_status(handle); + + if (edpt_setup_status) { + /*------------- Set up Received -------------*/ + usb_device_clear_setup_status(handle, edpt_setup_status); + dcd_qhd_t *qhd0 = usb_device_qhd_get(handle, 0); + usbd_event_ep0_setup_complete_handler((uint8_t *)&qhd0->setup_request); + } + + if (edpt_complete) { + for (uint8_t ep_idx = 0; ep_idx < USB_SOS_DCD_MAX_QHD_COUNT; ep_idx++) { + if (edpt_complete & (1 << ep_idx2bit(ep_idx))) { + /* Failed QTD also get ENDPTCOMPLETE set */ + dcd_qtd_t *p_qtd = usb_device_qtd_get(handle, ep_idx); + + if (p_qtd->halted || p_qtd->xact_err || p_qtd->buffer_err) { + } else { + /* only number of bytes in the IOC qtd */ + uint8_t const ep_addr = (ep_idx / 2) | ((ep_idx & 0x01) ? 0x80 : 0); + + transfer_len = p_qtd->expected_bytes - p_qtd->total_bytes; + + if (ep_addr & 0x80) { + usbd_event_ep_in_complete_handler(ep_addr, transfer_len); + } else { + usbd_event_ep_out_complete_handler(ep_addr, transfer_len); + } + } + } + } + } + } +} + +void isr_usb0(void) +{ + USBD_IRQHandler(); +} +SDK_DECLARE_EXT_ISR_M(IRQn_USB0, isr_usb0)