replace struct usbd_endpoint_cfg with struct usb_endpoint_descriptor in usbh_ep_open api

14 files changed, 144 insertions, 162 deletions

diff --git a/common/usb_dc.h b/common/usb_dc.h
index a541330a..fe4b597b 100644
--- a/common/usb_dc.h
+++ b/common/usb_dc.h
@@ -13,18 +13,6 @@ extern "C" {
 #endif
 
 /**
- * @brief USB Endpoint Configuration.
- *
- * Structure containing the USB endpoint configuration.
- */
-struct usbd_endpoint_cfg {
-    uint8_t ep_addr; /* Endpoint addr with direction */
-    uint8_t ep_type; /* Endpoint type */
-    uint16_t ep_mps; /* Endpoint max packet size */
-    uint8_t ep_mult; /* Endpoint additional transcations in micro frame */
-};
-
-/**
  * @brief init device controller registers.
  * @return On success will return 0, and others indicate fail.
  */
@@ -61,7 +49,7 @@ uint8_t usbd_get_port_speed(const uint8_t port);
  *
  * @return On success will return 0, and others indicate fail.
  */
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg);
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep);
 
 /**
  * @brief Disable the selected endpoint
diff --git a/core/usbd_core.c b/core/usbd_core.c
index b30c8070..8795d4c9 100644
--- a/core/usbd_core.c
+++ b/core/usbd_core.c
@@ -89,22 +89,18 @@ static bool is_device_configured(void)
  * This function sets endpoint configuration according to one specified in USB
  * endpoint descriptor and then enables it for data transfers.
  *
- * @param [in]  ep_desc Endpoint descriptor byte array
+ * @param [in]  ep Endpoint descriptor byte array
  *
  * @return true if successfully configured and enabled
  */
-static bool usbd_set_endpoint(const struct usb_endpoint_descriptor *ep_desc)
+static bool usbd_set_endpoint(const struct usb_endpoint_descriptor *ep)
 {
-    struct usbd_endpoint_cfg ep_cfg;
-
-    ep_cfg.ep_addr = ep_desc->bEndpointAddress;
-    ep_cfg.ep_mps = ep_desc->wMaxPacketSize & USB_MAXPACKETSIZE_MASK;
-    ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
-
     USB_LOG_INFO("Open ep:0x%02x type:%u mps:%u\r\n",
-                 ep_cfg.ep_addr, ep_cfg.ep_type, ep_cfg.ep_mps);
+                 ep->bEndpointAddress,
+                 USB_GET_ENDPOINT_TYPE(ep->bmAttributes),
+                 USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize));
 
-    return usbd_ep_open(&ep_cfg) == 0 ? true : false;
+    return usbd_ep_open(ep) == 0 ? true : false;
 }
 /**
  * @brief Disable endpoint for transferring data
@@ -112,22 +108,17 @@ static bool usbd_set_endpoint(const struct usb_endpoint_descriptor *ep_desc)
  * This function cancels transfers that are associated with endpoint and
  * disabled endpoint itself.
  *
- * @param [in]  ep_desc Endpoint descriptor byte array
+ * @param [in]  ep Endpoint descriptor byte array
  *
  * @return true if successfully deconfigured and disabled
  */
-static bool usbd_reset_endpoint(const struct usb_endpoint_descriptor *ep_desc)
+static bool usbd_reset_endpoint(const struct usb_endpoint_descriptor *ep)
 {
-    struct usbd_endpoint_cfg ep_cfg;
-
-    ep_cfg.ep_addr = ep_desc->bEndpointAddress;
-    ep_cfg.ep_mps = ep_desc->wMaxPacketSize & USB_MAXPACKETSIZE_MASK;
-    ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
-
     USB_LOG_INFO("Close ep:0x%02x type:%u\r\n",
-                 ep_cfg.ep_addr, ep_cfg.ep_type);
+                 ep->bEndpointAddress,
+                 USB_GET_ENDPOINT_TYPE(ep->bmAttributes));
 
-    return usbd_ep_close(ep_cfg.ep_addr) == 0 ? true : false;
+    return usbd_ep_close(ep->bEndpointAddress) == 0 ? true : false;
 }
 
 /**
@@ -990,15 +981,18 @@ void usbd_event_reset_handler(void)
 #ifdef CONFIG_USBDEV_TEST_MODE
     g_usbd_core.test_mode = false;
 #endif
-    struct usbd_endpoint_cfg ep0_cfg;
+    struct usb_endpoint_descriptor ep0;
 
-    ep0_cfg.ep_mps = USB_CTRL_EP_MPS;
-    ep0_cfg.ep_type = USB_ENDPOINT_TYPE_CONTROL;
-    ep0_cfg.ep_addr = USB_CONTROL_IN_EP0;
-    usbd_ep_open(&ep0_cfg);
+    ep0.bLength = 7;
+    ep0.bDescriptorType = USB_DESCRIPTOR_TYPE_ENDPOINT;
+    ep0.wMaxPacketSize = USB_CTRL_EP_MPS;
+    ep0.bmAttributes = USB_ENDPOINT_TYPE_CONTROL;
+    ep0.bEndpointAddress = USB_CONTROL_IN_EP0;
+    ep0.bInterval = 0;
+    usbd_ep_open(&ep0);
 
-    ep0_cfg.ep_addr = USB_CONTROL_OUT_EP0;
-    usbd_ep_open(&ep0_cfg);
+    ep0.bEndpointAddress = USB_CONTROL_OUT_EP0;
+    usbd_ep_open(&ep0);
 
     usbd_class_event_notify_handler(USBD_EVENT_RESET, NULL);
     usbd_event_handler(USBD_EVENT_RESET);
diff --git a/port/ch32/usb_ch58x_dc_usbfs.c b/port/ch32/usb_ch58x_dc_usbfs.c
index 51888a2d..d896a328 100644
--- a/port/ch32/usb_ch58x_dc_usbfs.c
+++ b/port/ch32/usb_ch58x_dc_usbfs.c
@@ -147,31 +147,31 @@ uint8_t usbd_get_port_speed(const uint8_t port)
  * @param[in]        ep_cfg : Endpoint configuration structure pointer
  * @retval           >=0 success otherwise failure
  */
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
     /*!< ep id */
-    uint8_t epid = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t epid = USB_EP_GET_IDX(ep->bEndpointAddress);
     if (epid > (USB_NUM_BIDIR_ENDPOINTS - 1)) {
         /**
          * If you use ch58x, you can change the EP_NUMS set to 8
          */
-        USB_LOG_ERR("Ep addr %d overflow\r\n", ep_cfg->ep_addr);
+        USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress);
         return -1;
     }
 
     /*!< ep max packet length */
-    uint8_t mps = ep_cfg->ep_mps;
+    uint8_t mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
     /*!< update ep max packet length */
-    if (USB_EP_DIR_IS_IN(ep_cfg->ep_addr)) {
+    if (USB_EP_DIR_IS_IN(ep->bEndpointAddress)) {
         /*!< in */
         usb_dc_cfg.ep_in[epid].ep_enable = true;
         usb_dc_cfg.ep_in[epid].mps = mps;
-        usb_dc_cfg.ep_in[epid].eptype = ep_cfg->ep_type;
-    } else if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
+        usb_dc_cfg.ep_in[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+    } else if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
         /*!< out */
         usb_dc_cfg.ep_out[epid].ep_enable = true;
         usb_dc_cfg.ep_out[epid].mps = mps;
-        usb_dc_cfg.ep_out[epid].eptype = ep_cfg->ep_type;
+        usb_dc_cfg.ep_out[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
     }
     return 0;
 }
diff --git a/port/ch32/usb_dc_usbfs.c b/port/ch32/usb_dc_usbfs.c
index 69492b33..c26f0ba7 100644
--- a/port/ch32/usb_dc_usbfs.c
+++ b/port/ch32/usb_dc_usbfs.c
@@ -101,18 +101,18 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return USB_SPEED_FULL;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_ch32_usbfs_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_ch32_usbfs_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_ch32_usbfs_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_ch32_usbfs_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_ch32_usbfs_udc.out_ep[ep_idx].ep_enable = true;
         USB_SET_RX_CTRL(ep_idx, USBFS_UEP_R_RES_NAK | USBFS_UEP_AUTO_TOG);
     } else {
-        g_ch32_usbfs_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_ch32_usbfs_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_ch32_usbfs_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_ch32_usbfs_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_ch32_usbfs_udc.in_ep[ep_idx].ep_enable = true;
         USB_SET_TX_CTRL(ep_idx, USBFS_UEP_T_RES_NAK | USBFS_UEP_AUTO_TOG);
     }
diff --git a/port/ch32/usb_dc_usbhs.c b/port/ch32/usb_dc_usbhs.c
index 8cc9e0a6..faa0f4a7 100644
--- a/port/ch32/usb_dc_usbhs.c
+++ b/port/ch32/usb_dc_usbhs.c
@@ -101,24 +101,24 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return USB_SPEED_HIGH;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_ch32_usbhs_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_ch32_usbhs_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_ch32_usbhs_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_ch32_usbhs_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_ch32_usbhs_udc.out_ep[ep_idx].ep_enable = true;
         USBHS_DEVICE->ENDP_CONFIG |= (1 << (ep_idx + 16));
         USB_SET_RX_CTRL(ep_idx, USBHS_EP_R_RES_NAK | USBHS_EP_R_TOG_0 | USBHS_EP_R_AUTOTOG);
     } else {
-        g_ch32_usbhs_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_ch32_usbhs_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_ch32_usbhs_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_ch32_usbhs_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_ch32_usbhs_udc.in_ep[ep_idx].ep_enable = true;
         USBHS_DEVICE->ENDP_CONFIG |= (1 << (ep_idx));
         USB_SET_TX_CTRL(ep_idx, USBHS_EP_T_RES_NAK | USBHS_EP_T_TOG_0 | USBHS_EP_T_AUTOTOG);
     }
-    USB_SET_MAX_LEN(ep_idx, ep_cfg->ep_mps);
+    USB_SET_MAX_LEN(ep_idx, USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize));
     return 0;
 }
 
diff --git a/port/dwc2/usb_dc_dwc2.c b/port/dwc2/usb_dc_dwc2.c
index 5c68c320..d88513e7 100644
--- a/port/dwc2/usb_dc_dwc2.c
+++ b/port/dwc2/usb_dc_dwc2.c
@@ -727,36 +727,36 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return speed;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
     if (ep_idx > (USB_NUM_BIDIR_ENDPOINTS - 1)) {
-        USB_LOG_ERR("Ep addr %d overflow\r\n", ep_cfg->ep_addr);
+        USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress);
         return -1;
     }
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_dwc2_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_dwc2_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_dwc2_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_dwc2_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
 
         USB_OTG_DEV->DAINTMSK |= USB_OTG_DAINTMSK_OEPM & (uint32_t)(1UL << (16 + ep_idx));
 
         if ((USB_OTG_OUTEP(ep_idx)->DOEPCTL & USB_OTG_DOEPCTL_USBAEP) == 0) {
-            USB_OTG_OUTEP(ep_idx)->DOEPCTL |= (ep_cfg->ep_mps & USB_OTG_DOEPCTL_MPSIZ) |
-                                              ((uint32_t)ep_cfg->ep_type << 18) |
+            USB_OTG_OUTEP(ep_idx)->DOEPCTL |= (USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize) & USB_OTG_DOEPCTL_MPSIZ) |
+                                              ((uint32_t)USB_GET_ENDPOINT_TYPE(ep->bmAttributes) << 18) |
                                               USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                               USB_OTG_DOEPCTL_USBAEP;
         }
     } else {
-        g_dwc2_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_dwc2_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_dwc2_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_dwc2_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
 
         USB_OTG_DEV->DAINTMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << ep_idx);
 
         if ((USB_OTG_INEP(ep_idx)->DIEPCTL & USB_OTG_DIEPCTL_USBAEP) == 0) {
-            USB_OTG_INEP(ep_idx)->DIEPCTL |= (ep_cfg->ep_mps & USB_OTG_DIEPCTL_MPSIZ) |
-                                             ((uint32_t)ep_cfg->ep_type << 18) | (ep_idx << 22) |
+            USB_OTG_INEP(ep_idx)->DIEPCTL |= (USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize) & USB_OTG_DIEPCTL_MPSIZ) |
+                                             ((uint32_t)USB_GET_ENDPOINT_TYPE(ep->bmAttributes) << 18) | (ep_idx << 22) |
                                              USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                              USB_OTG_DIEPCTL_USBAEP;
         }
diff --git a/port/fsdev/usb_dc_fsdev.c b/port/fsdev/usb_dc_fsdev.c
index 295efe1e..06c0d570 100644
--- a/port/fsdev/usb_dc_fsdev.c
+++ b/port/fsdev/usb_dc_fsdev.c
@@ -121,19 +121,19 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return USB_SPEED_FULL;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
     if (ep_idx > (USB_NUM_BIDIR_ENDPOINTS - 1)) {
-        USB_LOG_ERR("Ep addr %d overflow\r\n", ep_cfg->ep_addr);
+        USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress);
         return -1;
     }
 
     uint16_t wEpRegVal;
 
     /* initialize Endpoint */
-    switch (ep_cfg->ep_type) {
+    switch (USB_GET_ENDPOINT_TYPE(ep->bmAttributes)) {
         case USB_ENDPOINT_TYPE_CONTROL:
             wEpRegVal = USB_EP_CONTROL;
             break;
@@ -157,42 +157,42 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
     PCD_SET_EPTYPE(USB, ep_idx, wEpRegVal);
 
     PCD_SET_EP_ADDRESS(USB, ep_idx, ep_idx);
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_fsdev_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_fsdev_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_fsdev_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_fsdev_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_fsdev_udc.out_ep[ep_idx].ep_enable = true;
         if (g_fsdev_udc.out_ep[ep_idx].ep_mps > g_fsdev_udc.out_ep[ep_idx].ep_pma_buf_len) {
             if (g_fsdev_udc.pma_offset + g_fsdev_udc.out_ep[ep_idx].ep_mps > USB_RAM_SIZE) {
-                USB_LOG_ERR("Ep pma %d overflow\r\n", ep_cfg->ep_addr);
+                USB_LOG_ERR("Ep pma %02x overflow\r\n", ep->bEndpointAddress);
                 return -1;
             }
-            g_fsdev_udc.out_ep[ep_idx].ep_pma_buf_len = ep_cfg->ep_mps;
+            g_fsdev_udc.out_ep[ep_idx].ep_pma_buf_len = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
             g_fsdev_udc.out_ep[ep_idx].ep_pma_addr = g_fsdev_udc.pma_offset;
             /*Set the endpoint Receive buffer address */
             PCD_SET_EP_RX_ADDRESS(USB, ep_idx, g_fsdev_udc.pma_offset);
-            g_fsdev_udc.pma_offset += ep_cfg->ep_mps;
+            g_fsdev_udc.pma_offset += USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
         }
         /*Set the endpoint Receive buffer counter*/
-        PCD_SET_EP_RX_CNT(USB, ep_idx, ep_cfg->ep_mps);
+        PCD_SET_EP_RX_CNT(USB, ep_idx, USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize));
         PCD_CLEAR_RX_DTOG(USB, ep_idx);
     } else {
-        g_fsdev_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_fsdev_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_fsdev_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_fsdev_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_fsdev_udc.in_ep[ep_idx].ep_enable = true;
         if (g_fsdev_udc.in_ep[ep_idx].ep_mps > g_fsdev_udc.in_ep[ep_idx].ep_pma_buf_len) {
             if (g_fsdev_udc.pma_offset + g_fsdev_udc.in_ep[ep_idx].ep_mps > USB_RAM_SIZE) {
-                USB_LOG_ERR("Ep pma %d overflow\r\n", ep_cfg->ep_addr);
+                USB_LOG_ERR("Ep pma %02x overflow\r\n", ep->bEndpointAddress);
                 return -1;
             }
-            g_fsdev_udc.in_ep[ep_idx].ep_pma_buf_len = ep_cfg->ep_mps;
+            g_fsdev_udc.in_ep[ep_idx].ep_pma_buf_len = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
             g_fsdev_udc.in_ep[ep_idx].ep_pma_addr = g_fsdev_udc.pma_offset;
             /*Set the endpoint Transmit buffer address */
             PCD_SET_EP_TX_ADDRESS(USB, ep_idx, g_fsdev_udc.pma_offset);
-            g_fsdev_udc.pma_offset += ep_cfg->ep_mps;
+            g_fsdev_udc.pma_offset += USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
         }
 
         PCD_CLEAR_TX_DTOG(USB, ep_idx);
-        if (ep_cfg->ep_type != USB_ENDPOINT_TYPE_ISOCHRONOUS) {
+        if (USB_GET_ENDPOINT_TYPE(ep->bmAttributes) != USB_ENDPOINT_TYPE_ISOCHRONOUS) {
             /* Configure NAK status for the Endpoint */
             PCD_SET_EP_TX_STATUS(USB, ep_idx, USB_EP_TX_NAK);
         } else {
diff --git a/port/hpm/usb_dc_hpm.c b/port/hpm/usb_dc_hpm.c
index 576498f6..380797db 100644
--- a/port/hpm/usb_dc_hpm.c
+++ b/port/hpm/usb_dc_hpm.c
@@ -111,26 +111,26 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return 0;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
     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);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
-    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;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_hpm_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_hpm_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_hpm_udc.out_ep[ep_idx].ep_enable = true;
     } 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;
+        g_hpm_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_hpm_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_hpm_udc.in_ep[ep_idx].ep_enable = true;
     }
 
-    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;
+    tmp_ep_cfg.xfer = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+    tmp_ep_cfg.ep_addr = ep->bEndpointAddress;
+    tmp_ep_cfg.max_packet_size = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
 
     usb_device_edpt_open(handle, &tmp_ep_cfg);
     return 0;
diff --git a/port/musb/usb_dc_musb.c b/port/musb/usb_dc_musb.c
index 96fbaca7..bf2c07d7 100644
--- a/port/musb/usb_dc_musb.c
+++ b/port/musb/usb_dc_musb.c
@@ -288,11 +288,11 @@ uint8_t usbd_force_full_speed(const uint8_t port)
     return (HWREGB(USB_BASE + MUSB_POWER_OFFSET) & USB_POWER_HSENAB);
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
     uint16_t used = 0;
     uint16_t fifo_size = 0;
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
     uint8_t old_ep_idx;
     uint32_t ui32Flags = 0;
     uint16_t ui32Register = 0;
@@ -308,19 +308,19 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
     }
 
     if (ep_idx > (USB_NUM_BIDIR_ENDPOINTS - 1)) {
-        USB_LOG_ERR("Ep addr %d overflow\r\n", ep_cfg->ep_addr);
+        USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress);
         return -1;
     }
 
     old_ep_idx = musb_get_active_ep();
     musb_set_active_ep(ep_idx);
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_musb_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_musb_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_musb_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_musb_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_musb_udc.out_ep[ep_idx].ep_enable = true;
 
-        HWREGH(USB_BASE + MUSB_IND_RXMAP_OFFSET) = ep_cfg->ep_mps;
+        HWREGH(USB_BASE + MUSB_IND_RXMAP_OFFSET) = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
 
         //
         // Allow auto clearing of RxPktRdy when packet of size max packet
@@ -348,7 +348,7 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         //
         // Enable isochronous mode if requested.
         //
-        if (ep_cfg->ep_type == 0x01) {
+        if (USB_GET_ENDPOINT_TYPE(ep->bmAttributes) == 0x01) {
             ui32Register |= USB_RXCSRH1_ISO;
         }
 
@@ -360,18 +360,18 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         else
             HWREGB(USB_BASE + MUSB_IND_RXCSRL_OFFSET) = USB_RXCSRL1_CLRDT;
 
-        fifo_size = musb_get_fifo_size(ep_cfg->ep_mps, &used);
+        fifo_size = musb_get_fifo_size(USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize), &used);
 
         HWREGB(USB_BASE + MUSB_RXFIFOSZ_OFFSET) = fifo_size & 0x0f;
         HWREGH(USB_BASE + MUSB_RXFIFOADD_OFFSET) = (g_musb_udc.fifo_size_offset >> 3);
 
         g_musb_udc.fifo_size_offset += used;
     } else {
-        g_musb_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_musb_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_musb_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_musb_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_musb_udc.in_ep[ep_idx].ep_enable = true;
 
-        HWREGH(USB_BASE + MUSB_IND_TXMAP_OFFSET) = ep_cfg->ep_mps;
+        HWREGH(USB_BASE + MUSB_IND_TXMAP_OFFSET) = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
 
         //
         // Allow auto setting of TxPktRdy when max packet size has been loaded
@@ -393,7 +393,7 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         //
         // Enable isochronous mode if requested.
         //
-        if (ep_cfg->ep_type == 0x01) {
+        if (USB_GET_ENDPOINT_TYPE(ep->bmAttributes) == 0x01) {
             ui32Register |= USB_TXCSRH1_ISO;
         }
 
@@ -405,7 +405,7 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         else
             HWREGB(USB_BASE + MUSB_IND_TXCSRL_OFFSET) = USB_TXCSRL1_CLRDT;
 
-        fifo_size = musb_get_fifo_size(ep_cfg->ep_mps, &used);
+        fifo_size = musb_get_fifo_size(USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize), &used);
 
         HWREGB(USB_BASE + MUSB_TXFIFOSZ_OFFSET) = fifo_size & 0x0f;
         HWREGH(USB_BASE + MUSB_TXFIFOADD_OFFSET) = (g_musb_udc.fifo_size_offset >> 3);
diff --git a/port/nrf5x/usb_dc_nrf5x.c b/port/nrf5x/usb_dc_nrf5x.c
index 0bf1bef0..9007e194 100644
--- a/port/nrf5x/usb_dc_nrf5x.c
+++ b/port/nrf5x/usb_dc_nrf5x.c
@@ -200,20 +200,20 @@ uint8_t usbd_get_port_speed(const uint8_t port)
  * @param[in]        ep_cfg : Endpoint configuration structure pointer
  * @retval           >=0 success otherwise failure
  */
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
   /*!< ep id */
-  uint8_t epid = USB_EP_GET_IDX(ep_cfg->ep_addr);
+  uint8_t epid = USB_EP_GET_IDX(ep->bEndpointAddress);
   /*!< ep max packet length */
-  uint8_t mps = ep_cfg->ep_mps;
-  if (USB_EP_DIR_IS_IN(ep_cfg->ep_addr))
+  uint8_t mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+  if (USB_EP_DIR_IS_IN(ep->bEndpointAddress))
   {
     /*!< In */
     usb_dc_cfg.ep_in[epid].mps = mps;
-    usb_dc_cfg.ep_in[epid].eptype = ep_cfg->ep_type;
+    usb_dc_cfg.ep_in[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
     usb_dc_cfg.ep_in[epid].ep_enable = true;
     /*!< Open ep */
-    if (ep_cfg->ep_type != USB_ENDPOINT_TYPE_ISOCHRONOUS)
+    if (USB_GET_ENDPOINT_TYPE(ep->bmAttributes) != USB_ENDPOINT_TYPE_ISOCHRONOUS)
     {
       /*!< Enable endpoint interrupt */
       NRF_USBD->INTENSET = (1 << (USBD_INTEN_ENDEPIN0_Pos + epid));
@@ -238,14 +238,14 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
       NRF_USBD->EPINEN |= USBD_EPINEN_ISOIN_Msk;
     }
   }
-  else if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr))
+  else if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress))
   {
     /*!< Out */
     usb_dc_cfg.ep_out[epid].mps = mps;
-    usb_dc_cfg.ep_out[epid].eptype = ep_cfg->ep_type;
+    usb_dc_cfg.ep_out[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
     usb_dc_cfg.ep_out[epid].ep_enable = true;
     /*!< Open ep */
-    if (ep_cfg->ep_type != USB_ENDPOINT_TYPE_ISOCHRONOUS)
+    if (USB_GET_ENDPOINT_TYPE(ep->bmAttributes) != USB_ENDPOINT_TYPE_ISOCHRONOUS)
     {
       NRF_USBD->INTENSET = (1 << (USBD_INTEN_ENDEPOUT0_Pos + epid));
       NRF_USBD->EPOUTEN |= (1 << (epid));
@@ -274,8 +274,8 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
   }
 
   /*!< Clear stall and reset DataToggle */
-  NRF_USBD->EPSTALL = (USBD_EPSTALL_STALL_UnStall << USBD_EPSTALL_STALL_Pos) | (ep_cfg->ep_addr);
-  NRF_USBD->DTOGGLE = (USBD_DTOGGLE_VALUE_Data0 << USBD_DTOGGLE_VALUE_Pos) | (ep_cfg->ep_addr);
+  NRF_USBD->EPSTALL = (USBD_EPSTALL_STALL_UnStall << USBD_EPSTALL_STALL_Pos) | (ep->bEndpointAddress);
+  NRF_USBD->DTOGGLE = (USBD_DTOGGLE_VALUE_Data0 << USBD_DTOGGLE_VALUE_Pos) | (ep->bEndpointAddress);
 
   __ISB();
   __DSB();
diff --git a/port/nuvoton/usb_dc_usbfs.c b/port/nuvoton/usb_dc_usbfs.c
index cb2b5975..f283a727 100644
--- a/port/nuvoton/usb_dc_usbfs.c
+++ b/port/nuvoton/usb_dc_usbfs.c
@@ -174,15 +174,15 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return USB_SPEED_FULL;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
-    if (USB_EP_DIR_IS_IN(ep_cfg->ep_addr)) {
+    if (USB_EP_DIR_IS_IN(ep->bEndpointAddress)) {
         uint8_t epnum = USBD_EPNUM_FROM_IN_EPIDX(ep_idx);
 
-        g_nuvoton_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_nuvoton_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_nuvoton_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_nuvoton_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_nuvoton_udc.in_ep[ep_idx].ep_enable = true;
         if (ep_idx == 0) {
             /* EP0 ==> control IN endpoint, address 0 */
@@ -194,8 +194,8 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
     } else {
         uint8_t epnum = USBD_EPNUM_FROM_OUT_EPIDX(ep_idx);
 
-        g_nuvoton_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_nuvoton_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_nuvoton_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_nuvoton_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
         g_nuvoton_udc.out_ep[ep_idx].ep_enable = true;
         if (ep_idx == 0) {
             /* EP1 ==> control OUT endpoint, address 0 */
diff --git a/port/pusb2/usb_dc_pusb2.c b/port/pusb2/usb_dc_pusb2.c
index d437783b..24a90adc 100644
--- a/port/pusb2/usb_dc_pusb2.c
+++ b/port/pusb2/usb_dc_pusb2.c
@@ -236,45 +236,45 @@ int usbd_set_address(const uint8_t addr)
     return 0;
 }
 
-static struct usb_endpoint_descriptor *usbd_get_ep0_desc(const struct usbd_endpoint_cfg *ep_cfg)
+static struct usb_endpoint_descriptor *usbd_get_ep0_desc(const struct usb_endpoint_descriptor *ep)
 {
     static struct usb_endpoint_descriptor ep0_desc;
 
     /* Config EP0 mps from speed */
-    ep0_desc.bEndpointAddress = ep_cfg->ep_addr;
+    ep0_desc.bEndpointAddress = ep->bEndpointAddress;
     ep0_desc.bDescriptorType = USB_DESCRIPTOR_TYPE_ENDPOINT;
-    ep0_desc.bmAttributes = ep_cfg->ep_type;
-    ep0_desc.wMaxPacketSize = ep_cfg->ep_mps;
+    ep0_desc.bmAttributes = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+    ep0_desc.wMaxPacketSize = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
     ep0_desc.bInterval = 0;
     ep0_desc.bLength = 7;
 
     return &ep0_desc;    
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
     struct pusb2_dc_ep_state *ep_state;
     uint32_t error;
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
         ep_state = &g_pusb2_udc.out_ep[ep_idx];
     } else {
         ep_state = &g_pusb2_udc.in_ep[ep_idx];
     }
 
-    ep_state->ep_mps = ep_cfg->ep_mps;
-    ep_state->ep_type = ep_cfg->ep_type;
-    ep_state->desc = usbd_get_ep0_desc(ep_cfg);
+    ep_state->ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+    ep_state->ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+    ep_state->desc = usbd_get_ep0_desc(ep);
 
     USB_ASSERT(ep_state->priv_ep != NULL);
-    USB_LOG_DBG("try to enable ep@0x%x 0x%x:0x%x\n", ep_cfg->ep_addr,
+    USB_LOG_DBG("try to enable ep@0x%x 0x%x:0x%x\n", ep->bEndpointAddress,
                 ep_state->priv_ep, ep_state->desc );
     error = FPUsb2DcEpEnable(&g_pusb2_udc.pusb2.device_ctrl,
                             ep_state->priv_ep,
                             (const FUsbEndpointDescriptor *)ep_state->desc);
     if (FPUSB2_SUCCESS != error){
-        USB_LOG_ERR("enable ep-%d failed, error = 0x%x\n", ep_cfg->ep_addr, error);
+        USB_LOG_ERR("enable ep-%d failed, error = 0x%x\n", ep->bEndpointAddress, error);
         return -1;
     }        
 
diff --git a/port/rp2040/usb_dc_rp2040.c b/port/rp2040/usb_dc_rp2040.c
index 97562264..3f011693 100644
--- a/port/rp2040/usb_dc_rp2040.c
+++ b/port/rp2040/usb_dc_rp2040.c
@@ -205,9 +205,9 @@ uint8_t usbd_get_port_speed(const uint8_t port)
     return USB_SPEED_FULL;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
     if (ep_idx == 0) {
         /**
@@ -222,10 +222,10 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         g_rp2040_udc.in_ep[ep_idx].dpram_data_buf = (uint8_t *)&usb_dpram->ep0_buf_a[0];
     }
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_rp2040_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_rp2040_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
-        g_rp2040_udc.out_ep[ep_idx].ep_addr = ep_cfg->ep_addr;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_rp2040_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_rp2040_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+        g_rp2040_udc.out_ep[ep_idx].ep_addr = ep->bEndpointAddress;
         g_rp2040_udc.out_ep[ep_idx].ep_enable = true;
         /*!< Get control reg */
         g_rp2040_udc.out_ep[ep_idx].buffer_control = &usb_dpram->ep_buf_ctrl[ep_idx].out;
@@ -241,9 +241,9 @@ int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
         }
 
     } else {
-        g_rp2040_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_rp2040_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
-        g_rp2040_udc.in_ep[ep_idx].ep_addr = ep_cfg->ep_addr;
+        g_rp2040_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_rp2040_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
+        g_rp2040_udc.in_ep[ep_idx].ep_addr = ep->bEndpointAddress;
         g_rp2040_udc.in_ep[ep_idx].ep_enable = true;
         /*!< Get control reg */
         g_rp2040_udc.in_ep[ep_idx].buffer_control = &usb_dpram->ep_buf_ctrl[ep_idx].in;
diff --git a/port/template/usb_dc.c b/port/template/usb_dc.c
index 097041f8..3216b28b 100644
--- a/port/template/usb_dc.c
+++ b/port/template/usb_dc.c
@@ -51,16 +51,16 @@ int usbd_set_address(const uint8_t addr)
     return 0;
 }
 
-int usbd_ep_open(const struct usbd_endpoint_cfg *ep_cfg)
+int usbd_ep_open(const struct usb_endpoint_descriptor *ep)
 {
-    uint8_t ep_idx = USB_EP_GET_IDX(ep_cfg->ep_addr);
+    uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress);
 
-    if (USB_EP_DIR_IS_OUT(ep_cfg->ep_addr)) {
-        g_xxx_udc.out_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_xxx_udc.out_ep[ep_idx].ep_type = ep_cfg->ep_type;
+    if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) {
+        g_xxx_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_xxx_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
     } else {
-        g_xxx_udc.in_ep[ep_idx].ep_mps = ep_cfg->ep_mps;
-        g_xxx_udc.in_ep[ep_idx].ep_type = ep_cfg->ep_type;
+        g_xxx_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize);
+        g_xxx_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes);
     }
     return 0;
 }