refactor usb device intf and ep register

class/audio/usbd_audio.c

@@ -373,8 +373,14 @@ static void audio_notify_handler(uint8_t event, void *arg)
     }
 }
 
-void usbd_audio_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
+struct usbd_interface *usbd_audio_alloc_intf(void)
 {
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
     intf->class_handler = audio_class_request_handler;
 #if CONFIG_USBDEV_AUDIO_VERSION < 0x0200
     intf->custom_handler = audio_custom_request_handler;
@@ -383,7 +389,8 @@ void usbd_audio_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
 #endif
     intf->vendor_handler = NULL;
     intf->notify_handler = audio_notify_handler;
-    usbd_class_add_interface(devclass, intf);
+
+    return intf;
 }
 
 void usbd_audio_add_entity(uint8_t entity_id, uint16_t bDescriptorSubtype)

class/audio/usbd_audio.h

@@ -12,7 +12,8 @@
 extern "C" {
 #endif
 
-void usbd_audio_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc audio interface driver */
+struct usbd_interface *usbd_audio_alloc_intf(void);
 
 void usbd_audio_open(uint8_t intf);
 void usbd_audio_close(uint8_t intf);

class/cdc/usbd_cdc.c

@@ -17,7 +17,7 @@ static int cdc_acm_class_request_handler(struct usb_setup_packet *setup, uint8_t
 
     struct cdc_line_coding line_coding;
     bool dtr, rts;
-    uint8_t intf = LO_BYTE(setup->wIndex);
+    uint8_t intf_num = LO_BYTE(setup->wIndex);
 
     switch (setup->bRequest) {
         case CDC_REQUEST_SET_LINE_CODING:
@@ -41,31 +41,31 @@ static int cdc_acm_class_request_handler(struct usb_setup_packet *setup, uint8_t
             /*******************************************************************************/
             memcpy(&line_coding, *data, setup->wLength);
             USB_LOG_DBG("Set intf:%d linecoding <%d %d %s %s>\r\n",
-                        intf,
+                        intf_num,
                         line_coding.dwDTERate,
                         line_coding.bDataBits,
                         parity_name[line_coding.bParityType],
                         stop_name[line_coding.bCharFormat]);
-            usbd_cdc_acm_set_line_coding(intf, &line_coding);
+            usbd_cdc_acm_set_line_coding(intf_num, &line_coding);
             break;
 
         case CDC_REQUEST_SET_CONTROL_LINE_STATE: {
             dtr = (setup->wValue & 0x0001);
             rts = (setup->wValue & 0x0002);
             USB_LOG_DBG("Set intf:%d DTR 0x%x,RTS 0x%x\r\n",
-                        intf,
+                        intf_num,
                         dtr,
                         rts);
-            usbd_cdc_acm_set_dtr(intf, dtr);
-            usbd_cdc_acm_set_rts(intf, rts);
+            usbd_cdc_acm_set_dtr(intf_num, dtr);
+            usbd_cdc_acm_set_rts(intf_num, rts);
         } break;
 
         case CDC_REQUEST_GET_LINE_CODING:
-            usbd_cdc_acm_get_line_coding(intf, &line_coding);
+            usbd_cdc_acm_get_line_coding(intf_num, &line_coding);
             memcpy(*data, &line_coding, 7);
             *len = 7;
             USB_LOG_DBG("Get intf:%d linecoding %d %d %d %d\r\n",
-                        intf,
+                        intf_num,
                         line_coding.dwDTERate,
                         line_coding.bCharFormat,
                         line_coding.bParityType,
@@ -90,13 +90,20 @@ static void cdc_notify_handler(uint8_t event, void *arg)
     }
 }
 
-void usbd_cdc_add_acm_interface(usbd_class_t *devclass, usbd_interface_t *intf)
+struct usbd_interface *usbd_cdc_acm_alloc_intf(void)
 {
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
     intf->class_handler = cdc_acm_class_request_handler;
     intf->custom_handler = NULL;
     intf->vendor_handler = NULL;
     intf->notify_handler = cdc_notify_handler;
-    usbd_class_add_interface(devclass, intf);
+
+    return intf;
 }
 
 __WEAK void usbd_cdc_acm_set_line_coding(uint8_t intf, struct cdc_line_coding *line_coding)

class/cdc/usbd_cdc.h

@@ -12,8 +12,8 @@
 extern "C" {
 #endif
 
-/* Register api */
-void usbd_cdc_add_acm_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc cdc acm interface driver */
+struct usbd_interface *usbd_cdc_acm_alloc_intf(void);
 
 /* Setup request command callback api */
 void usbd_cdc_acm_set_line_coding(uint8_t intf, struct cdc_line_coding *line_coding);

class/dfu/usbd_dfu.c

@@ -43,7 +43,6 @@ static void dfu_notify_handler(uint8_t event, void *arg)
 {
     switch (event) {
         case USBD_EVENT_RESET:
-
             break;
 
         default:
@@ -51,12 +50,18 @@ static void dfu_notify_handler(uint8_t event, void *arg)
     }
 }
 
-void usbd_dfu_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
+struct usbd_interface *usbd_dfu_alloc_intf(void)
 {
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
     intf->class_handler = dfu_class_request_handler;
     intf->custom_handler = NULL;
     intf->vendor_handler = NULL;
     intf->notify_handler = dfu_notify_handler;
 
-    usbd_class_add_interface(devclass, intf);
-}
+    return intf;
+}

class/dfu/usbd_dfu.h

@@ -12,7 +12,8 @@
 extern "C" {
 #endif
 
-void usbd_dfu_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc dfu interface driver */
+struct usbd_interface *usbd_dfu_alloc_intf(void);
 
 #ifdef __cplusplus
 }

class/hid/usbd_hid.c

@@ -6,32 +6,6 @@
 #include "usbd_core.h"
 #include "usbd_hid.h"
 
-struct usbd_hid {
-    const uint8_t *hid_descriptor;
-    const uint8_t *hid_report_descriptor;
-    uint32_t hid_report_descriptor_len;
-    uint8_t intf_num;
-    uint8_t report;
-    uint8_t idle_state;
-    uint8_t protocol;
-
-    usb_slist_t list;
-};
-
-static usb_slist_t usbd_hid_head = USB_SLIST_OBJECT_INIT(usbd_hid_head);
-
-static void usbd_hid_reset(void)
-{
-    usb_slist_t *i;
-    usb_slist_for_each(i, &usbd_hid_head)
-    {
-        struct usbd_hid *hid_intf = usb_slist_entry(i, struct usbd_hid, list);
-        hid_intf->report = 0;
-        hid_intf->idle_state = 0;
-        hid_intf->protocol = 0;
-    }
-}
-
 static int hid_custom_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
 {
     USB_LOG_DBG("HID Custom request: "
@@ -43,33 +17,34 @@ static int hid_custom_request_handler(struct usb_setup_packet *setup, uint8_t **
         uint8_t value = (uint8_t)(setup->wValue >> 8);
         uint8_t intf_num = (uint8_t)setup->wIndex;
 
-        struct usbd_hid *current_hid_class = NULL;
         usb_slist_t *i;
-        usb_slist_for_each(i, &usbd_hid_head)
+        struct usbd_interface *match_intf = NULL;
+
+        usb_slist_for_each(i, &usbd_intf_head)
         {
-            struct usbd_hid *hid_class = usb_slist_entry(i, struct usbd_hid, list);
+            struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
-            if (hid_class->intf_num == intf_num) {
-                current_hid_class = hid_class;
+            if (intf->intf_num == intf_num) {
+                match_intf = intf;
                 break;
             }
         }
 
-        if (current_hid_class == NULL) {
+        if (match_intf == NULL) {
             return -2;
         }
 
         switch (value) {
             case HID_DESCRIPTOR_TYPE_HID:
                 USB_LOG_INFO("get HID Descriptor\r\n");
-                *data = (uint8_t *)current_hid_class->hid_descriptor;
-                *len = current_hid_class->hid_descriptor[0];
+                // *data = (uint8_t *)match_intf->hid_descriptor;
+                // *len = match_intf->hid_descriptor[0];
                 break;
 
             case HID_DESCRIPTOR_TYPE_HID_REPORT:
                 USB_LOG_INFO("get Report Descriptor\r\n");
-                *data = (uint8_t *)current_hid_class->hid_report_descriptor;
-                *len = current_hid_class->hid_report_descriptor_len;
+                *data = (uint8_t *)match_intf->hid_report_descriptor;
+                *len = match_intf->hid_report_descriptor_len;
                 break;
 
             case HID_DESCRIPTOR_TYPE_HID_PHYSICAL:
@@ -93,50 +68,33 @@ static int hid_class_request_handler(struct usb_setup_packet *setup, uint8_t **d
                 "bRequest 0x%02x\r\n",
                 setup->bRequest);
 
-    struct usbd_hid *current_hid_class = NULL;
-    usb_slist_t *i;
-    uint8_t intf = LO_BYTE(setup->wIndex);
-
-    usb_slist_for_each(i, &usbd_hid_head)
-    {
-        struct usbd_hid *hid_class = usb_slist_entry(i, struct usbd_hid, list);
-        if (hid_class->intf_num == intf) {
-            current_hid_class = hid_class;
-            break;
-        }
-    }
-
-    if (current_hid_class == NULL) {
-        return -2;
-    }
+    uint8_t intf_num = LO_BYTE(setup->wIndex);
 
     switch (setup->bRequest) {
         case HID_REQUEST_GET_REPORT:
-            current_hid_class->report = usbh_hid_get_report(intf, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue)); /*report id ,report type*/
-            *data = (uint8_t *)&current_hid_class->report;
+            /* report id ,report type */
+            (*data)[0] = usbh_hid_get_report(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue));
             *len = 1;
             break;
         case HID_REQUEST_GET_IDLE:
-            current_hid_class->idle_state = usbh_hid_get_idle(intf, LO_BYTE(setup->wValue));
-            *data = (uint8_t *)&current_hid_class->idle_state;
+            (*data)[0] = usbh_hid_get_idle(intf_num, LO_BYTE(setup->wValue));
             *len = 1;
             break;
         case HID_REQUEST_GET_PROTOCOL:
-            current_hid_class->protocol = usbh_hid_get_protocol(intf);
-            *data = (uint8_t *)&current_hid_class->protocol;
+            (*data)[0] = usbh_hid_get_protocol(intf_num);
             *len = 1;
             break;
         case HID_REQUEST_SET_REPORT:
-            usbh_hid_set_report(intf, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), *data, *len); /*report id ,report type,report,report len*/
-            current_hid_class->report = **data;
+            /* report id ,report type, report, report len */
+            usbh_hid_set_report(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), *data, *len);
             break;
         case HID_REQUEST_SET_IDLE:
-            usbh_hid_set_idle(intf, LO_BYTE(setup->wValue), HI_BYTE(setup->wIndex)); /*report id ,duration*/
-            current_hid_class->idle_state = HI_BYTE(setup->wIndex);
+            /* report id, duration */
+            usbh_hid_set_idle(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wIndex));
             break;
         case HID_REQUEST_SET_PROTOCOL:
-            usbh_hid_set_protocol(intf, LO_BYTE(setup->wValue)); /*protocol*/
-            current_hid_class->protocol = LO_BYTE(setup->wValue);
+            /* protocol */
+            usbh_hid_set_protocol(intf_num, LO_BYTE(setup->wValue));
             break;
 
         default:
@@ -147,60 +105,22 @@ static int hid_class_request_handler(struct usb_setup_packet *setup, uint8_t **d
     return 0;
 }
 
-static void hid_notify_handler(uint8_t event, void *arg)
+struct usbd_interface *usbd_hid_alloc_intf(const uint8_t *desc, uint32_t desc_len)
 {
-    switch (event) {
-        case USBD_EVENT_RESET:
-            usbd_hid_reset();
-            break;
-        default:
-            break;
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
     }
-}
-
-int usbd_hid_alloc(uint8_t intf)
-{
-    struct usbd_hid *hid_class = usb_malloc(sizeof(struct usbd_hid));
-
-    if (hid_class == NULL) {
-        USB_LOG_ERR("no memory to alloc hid_class\r\n");
-        return -1;
-    }
-
-    memset(hid_class, 0, sizeof(struct usbd_hid));
-    hid_class->intf_num = intf;
-    usb_slist_add_tail(&usbd_hid_head, &hid_class->list);
-    return 0;
-}
 
-void usbd_hid_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
-{
     intf->class_handler = hid_class_request_handler;
     intf->custom_handler = hid_custom_request_handler;
     intf->vendor_handler = NULL;
-    intf->notify_handler = hid_notify_handler;
-    usbd_class_add_interface(devclass, intf);
-    usbd_hid_alloc(intf->intf_num);
-}
-
-void usbd_hid_descriptor_register(uint8_t intf_num, const uint8_t *desc)
-{
-    // usbd_hid_cfg.hid_descriptor = desc;
-}
+    intf->notify_handler = NULL;
 
-void usbd_hid_report_descriptor_register(uint8_t intf_num, const uint8_t *desc, uint32_t desc_len)
-{
-    usb_slist_t *i;
-    usb_slist_for_each(i, &usbd_hid_head)
-    {
-        struct usbd_hid *hid_class = usb_slist_entry(i, struct usbd_hid, list);
-
-        if (hid_class->intf_num == intf_num) {
-            hid_class->hid_report_descriptor = desc;
-            hid_class->hid_report_descriptor_len = desc_len;
-            return;
-        }
-    }
+    intf->hid_report_descriptor = desc;
+    intf->hid_report_descriptor_len = desc_len;
+    return intf;
 }
 
 __WEAK uint8_t usbh_hid_get_report(uint8_t intf, uint8_t report_id, uint8_t report_type)

class/hid/usbd_hid.h

@@ -12,8 +12,8 @@
 extern "C" {
 #endif
 
-/* Register api */
-void usbd_hid_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc hid interface driver */
+struct usbd_interface *usbd_hid_alloc_intf(const uint8_t *desc, uint32_t desc_len);
 
 /* Register desc api */
 void usbd_hid_descriptor_register(uint8_t intf_num, const uint8_t *desc);

class/hub/usbd_hub.c

@@ -70,13 +70,4 @@ static void hub_notify_handler(uint8_t event, void *arg)
         default:
             break;
     }
-}
-
-void usbd_hub_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
-{
-    intf->class_handler = NULL;
-    intf->custom_handler = hub_custom_request_handler;
-    intf->vendor_handler = NULL;
-    intf->notify_handler = hub_notify_handler;
-    usbd_class_add_interface(devclass, intf);
-}
+}

class/hub/usbd_hub.h

@@ -12,8 +12,6 @@
 extern "C" {
 #endif
 
-void usbd_hub_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
-
 #ifdef __cplusplus
 }
 #endif

class/msc/usbd_msc.c

@@ -22,7 +22,7 @@
 #define MSD_IN_EP_IDX  1
 
 /* Describe EndPoints configuration */
-static usbd_endpoint_t mass_ep_data[2];
+static struct usbd_endpoint mass_ep_data[2];
 
 /* MSC Bulk-only Stage */
 enum Stage {
@@ -822,7 +822,7 @@ static bool SCSI_CBWDecode(uint32_t nbytes)
     return ret;
 }
 
-static void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes)
+void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes)
 {
     switch (usbd_msc_cfg.stage) {
         case MSC_READ_CBW:
@@ -849,7 +849,7 @@ static void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes)
     }
 }
 
-static void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes)
+void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes)
 {
     switch (usbd_msc_cfg.stage) {
         case MSC_DATA_IN:
@@ -911,23 +911,26 @@ static void usbd_msc_thread(void *argument)
 }
 #endif
 
-static usbd_interface_t msc_intf = {
-    .class_handler = msc_storage_class_request_handler,
-    .vendor_handler = NULL,
-    .notify_handler = msc_storage_notify_handler,
-};
-
-void usbd_msc_class_init(uint8_t out_ep, uint8_t in_ep)
+struct usbd_interface *usbd_msc_alloc_intf(const uint8_t out_ep, const uint8_t in_ep)
 {
-    usbd_class_add_interface(NULL, &msc_intf);
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
+    intf->class_handler = msc_storage_class_request_handler;
+    intf->custom_handler = NULL;
+    intf->vendor_handler = NULL;
+    intf->notify_handler = msc_storage_notify_handler;
 
-    mass_ep_data[0].ep_addr = out_ep;
-    mass_ep_data[0].ep_cb = mass_storage_bulk_out;
-    mass_ep_data[1].ep_addr = in_ep;
-    mass_ep_data[1].ep_cb = mass_storage_bulk_in;
+    mass_ep_data[MSD_OUT_EP_IDX].ep_addr = out_ep;
+    mass_ep_data[MSD_OUT_EP_IDX].ep_cb = mass_storage_bulk_out;
+    mass_ep_data[MSD_IN_EP_IDX].ep_addr = in_ep;
+    mass_ep_data[MSD_IN_EP_IDX].ep_cb = mass_storage_bulk_in;
 
-    usbd_interface_add_endpoint(&msc_intf, &mass_ep_data[0]);
-    usbd_interface_add_endpoint(&msc_intf, &mass_ep_data[1]);
+    usbd_add_endpoint(&mass_ep_data[MSD_OUT_EP_IDX]);
+    usbd_add_endpoint(&mass_ep_data[MSD_IN_EP_IDX]);
 
     memset((uint8_t *)&usbd_msc_cfg, 0, sizeof(struct usbd_msc_cfg_priv));
 
@@ -935,7 +938,7 @@ void usbd_msc_class_init(uint8_t out_ep, uint8_t in_ep)
 
     if (usbd_msc_cfg.scsi_blk_size > CONFIG_USBDEV_MSC_BLOCK_SIZE) {
         USB_LOG_ERR("msc block buffer overflow\r\n");
-        return;
+        return NULL;
     }
 #ifdef CONFIG_USBDEV_MSC_THREAD
     msc_sem = usb_osal_sem_create(1);
@@ -945,4 +948,6 @@ void usbd_msc_class_init(uint8_t out_ep, uint8_t in_ep)
         return;
     }
 #endif
-}
+
+    return intf;
+}

class/msc/usbd_msc.h

@@ -12,7 +12,12 @@
 extern "C" {
 #endif
 
-void usbd_msc_class_init(uint8_t out_ep, uint8_t in_ep);
+/* Alloc msc interface driver */
+struct usbd_interface *usbd_msc_alloc_intf(const uint8_t out_ep, const uint8_t in_ep);
+
+void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes);
+void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes);
+
 void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint16_t *block_size);
 int usbd_msc_sector_read(uint32_t sector, uint8_t *buffer, uint32_t length);
 int usbd_msc_sector_write(uint32_t sector, uint8_t *buffer, uint32_t length);

class/mtp/usbd_mtp.c

@@ -21,7 +21,7 @@ struct mtp_cfg_priv {
 #define MSD_IN_EP_IDX  1
 
 /* Describe EndPoints configuration */
-static usbd_endpoint_t mtp_ep_data[2];
+static struct usbd_interface mtp_ep_data[2];
 
 static int mtp_class_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len)
 {

class/printer/usbd_printer.c

@@ -46,12 +46,18 @@ static void printer_notify_handler(uint8_t event, void *arg)
     }
 }
 
-void usbd_printer_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
+struct usbd_interface *usbd_printer_alloc_intf(void)
 {
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
     intf->class_handler = printer_class_request_handler;
     intf->custom_handler = NULL;
     intf->vendor_handler = NULL;
     intf->notify_handler = printer_notify_handler;
 
-    usbd_class_add_interface(devclass, intf);
-}
+    return intf;
+}

class/printer/usbd_printer.h

@@ -12,7 +12,8 @@
 extern "C" {
 #endif
 
-void usbd_printer_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc printer interface driver */
+struct usbd_interface *usbd_printer_alloc_intf(void);
 
 #ifdef __cplusplus
 }

class/video/usbd_video.c

@@ -17,12 +17,8 @@ struct usbd_video_cfg_priv {
     struct video_probe_and_commit_controls commit;
     uint8_t power_mode;
     uint8_t error_code;
-    uint8_t vcintf;
-    uint8_t vsintf;
     struct video_entity_info info[3];
 } usbd_video_cfg = {
-    .vcintf = 0xff,
-    .vsintf = 0xff,
     .info[0] = { .bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE, .bEntityId = 0x01, .wTerminalType = VIDEO_ITT_CAMERA },
     .info[1] = { .bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE, .bEntityId = 0x03, .wTerminalType = 0x00 },
     .info[2] = { .bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE, .bEntityId = 0x02, .wTerminalType = 0x00 },
@@ -672,13 +668,13 @@ static int video_class_request_handler(struct usb_setup_packet *setup, uint8_t *
     uint8_t intf_num = (uint8_t)setup->wIndex;
     uint8_t entity_id = (uint8_t)(setup->wIndex >> 8);
 
-    if (usbd_video_cfg.vcintf == intf_num) { /* Video Control Interface */
+    if (intf_num == 0) { /* Video Control Interface */
         if (entity_id == 0) {
             return usbd_video_control_request_handler(setup, data, len); /* Interface Control Requests */
         } else {
             return usbd_video_control_unit_terminal_request_handler(setup, data, len); /* Unit and Terminal Requests */
         }
-    } else if (usbd_video_cfg.vsintf == intf_num) {                 /* Video Stream Inteface */
+    } else if (intf_num == 1) {                                     /* Video Stream Inteface */
         return usbd_video_stream_request_handler(setup, data, len); /* Interface Stream Requests */
     }
     return -1;
@@ -707,21 +703,6 @@ static void video_notify_handler(uint8_t event, void *arg)
     }
 }
 
-void usbd_video_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
-{
-    intf->class_handler = video_class_request_handler;
-    intf->custom_handler = NULL;
-    intf->vendor_handler = NULL;
-    intf->notify_handler = video_notify_handler;
-    usbd_class_add_interface(devclass, intf);
-
-    if (usbd_video_cfg.vcintf == 0xff) {
-        usbd_video_cfg.vcintf = intf->intf_num;
-    } else if (usbd_video_cfg.vsintf == 0xff) {
-        usbd_video_cfg.vsintf = intf->intf_num;
-    }
-}
-
 void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize)
 {
     usbd_video_cfg.probe.hintUnion.bmHint = 0x01;
@@ -761,6 +742,23 @@ void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_
     usbd_video_cfg.commit.bMaxVersion = 0;
 }
 
+struct usbd_interface *usbd_video_alloc_intf(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize)
+{
+    struct usbd_interface *intf = usb_malloc(sizeof(struct usbd_interface));
+    if (intf == NULL) {
+        USB_LOG_ERR("no mem to alloc intf\r\n");
+        return NULL;
+    }
+
+    intf->class_handler = video_class_request_handler;
+    intf->custom_handler = NULL;
+    intf->vendor_handler = NULL;
+    intf->notify_handler = video_notify_handler;
+
+    usbd_video_probe_and_commit_controls_init(dwFrameInterval, dwMaxVideoFrameSize, dwMaxPayloadTransferSize);
+    return intf;
+}
+
 uint32_t usbd_video_mjpeg_payload_fill(uint8_t *input, uint32_t input_len, uint8_t *output, uint32_t *out_len)
 {
     uint32_t packets;

class/video/usbd_video.h

@@ -12,11 +12,13 @@
 extern "C" {
 #endif
 
-void usbd_video_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+/* Alloc video interface driver */
+struct usbd_interface *usbd_video_alloc_intf(uint32_t dwFrameInterval,
+                                             uint32_t dwMaxVideoFrameSize,
+                                             uint32_t dwMaxPayloadTransferSize);
 
 void usbd_video_open(uint8_t intf);
 void usbd_video_close(uint8_t intf);
-void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize);
 uint32_t usbd_video_mjpeg_payload_fill(uint8_t *input, uint32_t input_len, uint8_t *output, uint32_t *out_len);
 void usbd_video_mjpeg_payload_header_toggle(uint8_t *output, uint32_t packets);
 

core/usbd_core.c

@@ -51,7 +51,7 @@ USB_NOCACHE_RAM_SECTION struct usbd_core_cfg_priv {
 #endif
 } usbd_core_cfg;
 
-static usb_slist_t usbd_intf_head = USB_SLIST_OBJECT_INIT(usbd_intf_head);
+usb_slist_t usbd_intf_head = USB_SLIST_OBJECT_INIT(usbd_intf_head);
 
 static struct usb_msosv1_descriptor *msosv1_desc;
 static struct usb_msosv2_descriptor *msosv2_desc;
@@ -585,7 +585,7 @@ static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t **
     if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_INTERFACE) {
         usb_slist_for_each(i, &usbd_intf_head)
         {
-            usbd_interface_t *intf = usb_slist_entry(i, struct usbd_interface, list);
+            struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
             if (intf->class_handler && (intf->intf_num == (setup->wIndex & 0xFF))) {
                 return intf->class_handler(setup, data, len);
@@ -594,7 +594,7 @@ static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t **
     } else if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_ENDPOINT) {
         usb_slist_for_each(i, &usbd_intf_head)
         {
-            usbd_interface_t *intf = usb_slist_entry(i, struct usbd_interface, list);
+            struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
             if (intf->custom_handler && (intf->intf_num == ((setup->wIndex >> 8) & 0xFF))) {
                 return intf->custom_handler(setup, data, len);
@@ -656,7 +656,7 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t *
 
     usb_slist_for_each(i, &usbd_intf_head)
     {
-        usbd_interface_t *intf = usb_slist_entry(i, struct usbd_interface, list);
+        struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
         if (intf->vendor_handler && !intf->vendor_handler(setup, data, len)) {
             return 0;
@@ -684,7 +684,7 @@ static int usbd_custom_request_handler(struct usb_setup_packet *setup, uint8_t *
     usb_slist_t *i;
     usb_slist_for_each(i, &usbd_intf_head)
     {
-        usbd_interface_t *intf = usb_slist_entry(i, struct usbd_interface, list);
+        struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
         if (intf->custom_handler && (intf->intf_num == (setup->wIndex & 0xFF))) {
             return intf->custom_handler(setup, data, len);
@@ -741,7 +741,7 @@ static void usbd_class_event_notify_handler(uint8_t event, void *arg)
     usb_slist_t *i;
     usb_slist_for_each(i, &usbd_intf_head)
     {
-        usbd_interface_t *intf = usb_slist_entry(i, struct usbd_interface, list);
+        struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
 
         if (intf->notify_handler) {
             intf->notify_handler(event, arg);
@@ -952,25 +952,17 @@ void usbd_bos_desc_register(struct usb_bos_descriptor *desc)
     bos_desc = desc;
 }
 
-void usbd_class_register(usbd_class_t *devclass)
-{
-    // usb_slist_add_tail(&usbd_class_head, &devclass->list);
-    // usb_slist_init(&devclass->intf_list);
-}
-
-void usbd_class_add_interface(usbd_class_t *devclass, usbd_interface_t *intf)
+void usbd_add_interface(struct usbd_interface *intf)
 {
     static uint8_t intf_offset = 0;
 
     intf->intf_num = intf_offset;
     usb_slist_add_tail(&usbd_intf_head, &intf->list);
-    usb_slist_init(&intf->ep_list);
     intf_offset++;
 }
 
-void usbd_interface_add_endpoint(usbd_interface_t *intf, usbd_endpoint_t *ep)
+void usbd_add_endpoint(struct usbd_endpoint *ep)
 {
-    usb_slist_add_tail(&intf->ep_list, &ep->list);
     if (ep->ep_addr & 0x80) {
         usbd_core_cfg.in_ep_cb[ep->ep_addr & 0x7f] = ep->ep_cb;
     } else {

core/usbd_core.h

@@ -44,13 +44,14 @@ typedef int (*usbd_request_handler)(struct usb_setup_packet *setup, uint8_t **da
 typedef void (*usbd_endpoint_callback)(uint8_t ep, uint32_t nbytes);
 typedef void (*usbd_notify_handler)(uint8_t event, void *arg);
 
-typedef struct usbd_endpoint {
-    usb_slist_t list;
+extern usb_slist_t usbd_intf_head;
+
+struct usbd_endpoint {
     uint8_t ep_addr;
     usbd_endpoint_callback ep_cb;
-} usbd_endpoint_t;
+};
 
-typedef struct usbd_interface {
+struct usbd_interface {
     usb_slist_t list;
     /** Handler for USB Class specific commands*/
     usbd_request_handler class_handler;
@@ -60,23 +61,19 @@ typedef struct usbd_interface {
     usbd_request_handler custom_handler;
     /** Handler for USB event notify commands */
     usbd_notify_handler notify_handler;
+    const uint8_t *hid_report_descriptor;
+    uint32_t hid_report_descriptor_len;
     uint8_t intf_num;
-    usb_slist_t ep_list;
-} usbd_interface_t;
-
-typedef struct usbd_class {
-    usb_slist_t list;
-    const char *name;
-    usb_slist_t intf_list;
-} usbd_class_t;
+};
 
 void usbd_desc_register(const uint8_t *desc);
 void usbd_msosv1_desc_register(struct usb_msosv1_descriptor *desc);
 void usbd_msosv2_desc_register(struct usb_msosv2_descriptor *desc);
 void usbd_bos_desc_register(struct usb_bos_descriptor *desc);
-void usbd_class_register(usbd_class_t *devclass);
-void usbd_class_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
-void usbd_interface_add_endpoint(usbd_interface_t *intf, usbd_endpoint_t *ep);
+
+void usbd_add_interface(struct usbd_interface *intf);
+void usbd_add_endpoint(struct usbd_endpoint *ep);
+
 bool usb_device_is_configured(void);
 void usbd_configure_done_callback(void);
 int usbd_initialize(void);

demo/audio_v1_mic_multichan_template.c

@@ -161,15 +161,11 @@ void usbd_audio_close(uint8_t intf)
     tx_flag = 0;
 }
 
-static usbd_class_t audio_class;
-static usbd_interface_t audio_control_intf;
-static usbd_interface_t audio_stream_intf;
-
 void usbd_audio_iso_callback(uint8_t ep, uint32_t nbytes)
 {
 }
 
-static usbd_endpoint_t audio_in_ep = {
+static struct usbd_endpoint audio_in_ep = {
     .ep_cb = usbd_audio_iso_callback,
     .ep_addr = AUDIO_IN_EP
 };
@@ -177,9 +173,10 @@ static usbd_endpoint_t audio_in_ep = {
 void audio_init()
 {
     usbd_desc_register(audio_descriptor);
-    usbd_audio_add_interface(&audio_class, &audio_control_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf);
-    usbd_interface_add_endpoint(&audio_stream_intf, &audio_in_ep);
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_endpoint(&audio_in_ep);
+
     usbd_audio_add_entity(0x02, AUDIO_CONTROL_FEATURE_UNIT);
 
     usbd_initialize();

demo/audio_v1_mic_speaker_multichan_template.c

@@ -154,18 +154,13 @@ void usbd_audio_close(uint8_t intf)
     }
 }
 
-static usbd_class_t audio_class;
-static usbd_interface_t audio_control_intf;
-static usbd_interface_t audio_stream_intf;
-static usbd_interface_t audio_stream_intf2;
-
 #ifdef CONFIG_USB_HS
 #define AUDIO_OUT_EP_MPS 512
 #else
 #define AUDIO_OUT_EP_MPS 64
 #endif
 
-USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
 
 void usbd_configure_done_callback(void)
 {
@@ -182,12 +177,12 @@ void usbd_audio_in_callback(uint8_t ep, uint32_t bytes)
 {
 }
 
-static usbd_endpoint_t audio_in_ep = {
+static struct usbd_endpoint audio_in_ep = {
     .ep_cb = usbd_audio_in_callback,
     .ep_addr = AUDIO_IN_EP
 };
 
-static usbd_endpoint_t audio_out_ep = {
+static struct usbd_endpoint audio_out_ep = {
     .ep_cb = usbd_audio_out_callback,
     .ep_addr = AUDIO_OUT_EP
 };
@@ -195,11 +190,12 @@ static usbd_endpoint_t audio_out_ep = {
 void audio_init()
 {
     usbd_desc_register(audio_descriptor);
-    usbd_audio_add_interface(&audio_class, &audio_control_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf2);
-    usbd_interface_add_endpoint(&audio_stream_intf, &audio_in_ep);
-    usbd_interface_add_endpoint(&audio_stream_intf2, &audio_out_ep);
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_endpoint(&audio_in_ep);
+    usbd_add_endpoint(&audio_out_ep);
+
     usbd_audio_add_entity(0x02, AUDIO_CONTROL_FEATURE_UNIT);
     usbd_audio_add_entity(0x05, AUDIO_CONTROL_FEATURE_UNIT);
 

demo/audio_v2_mic_multichan_template.c

@@ -160,10 +160,6 @@ void usbd_audio_close(uint8_t intf)
     tx_flag = 0;
 }
 
-static usbd_class_t audio_class;
-static usbd_interface_t audio_control_intf;
-static usbd_interface_t audio_stream_intf;
-
 void usbd_configure_done_callback(void)
 {
     /* no out ep, do nothing */
@@ -173,7 +169,7 @@ void usbd_audio_iso_in_callback(uint8_t ep, uint32_t nbytes)
 {
 }
 
-static usbd_endpoint_t audio_in_ep = {
+static struct usbd_endpoint audio_in_ep = {
     .ep_cb = usbd_audio_iso_in_callback,
     .ep_addr = AUDIO_IN_EP
 };
@@ -181,9 +177,10 @@ static usbd_endpoint_t audio_in_ep = {
 void audio_init()
 {
     usbd_desc_register(audio_descriptor);
-    usbd_audio_add_interface(&audio_class, &audio_control_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf);
-    usbd_interface_add_endpoint(&audio_stream_intf, &audio_in_ep);
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_endpoint(&audio_in_ep);
+
     usbd_audio_add_entity(0x01, AUDIO_CONTROL_CLOCK_SOURCE);
     usbd_audio_add_entity(0x03, AUDIO_CONTROL_FEATURE_UNIT);
 

demo/audio_v2_mic_speaker_multichan_template.c

@@ -230,18 +230,13 @@ void usbd_audio_set_sampling_freq(uint8_t entity_id, uint8_t ep_ch, uint32_t sam
     }
 }
 
-static usbd_class_t audio_class;
-static usbd_interface_t audio_control_intf;
-static usbd_interface_t audio_stream_intf;
-static usbd_interface_t audio_stream_intf2;
-
 #ifdef CONFIG_USB_HS
 #define AUDIO_OUT_EP_MPS 512
 #else
 #define AUDIO_OUT_EP_MPS 64
 #endif
 
-USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
 
 void usbd_configure_done_callback(void)
 {
@@ -257,12 +252,12 @@ void usbd_audio_iso_in_callback(uint8_t ep, uint32_t nbytes)
 {
 }
 
-static usbd_endpoint_t audio_out_ep = {
+static struct usbd_endpoint audio_out_ep = {
     .ep_cb = usbd_audio_iso_out_callback,
     .ep_addr = AUDIO_OUT_EP
 };
 
-static usbd_endpoint_t audio_in_ep = {
+static struct usbd_endpoint audio_in_ep = {
     .ep_cb = usbd_audio_iso_in_callback,
     .ep_addr = AUDIO_IN_EP
 };
@@ -270,11 +265,12 @@ static usbd_endpoint_t audio_in_ep = {
 void audio_init()
 {
     usbd_desc_register(audio_descriptor);
-    usbd_audio_add_interface(&audio_class, &audio_control_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf2);
-    usbd_interface_add_endpoint(&audio_stream_intf, &audio_out_ep);
-    usbd_interface_add_endpoint(&audio_stream_intf2, &audio_in_ep);
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_endpoint(&audio_in_ep);
+    usbd_add_endpoint(&audio_out_ep);
+
     usbd_audio_add_entity(0x01, AUDIO_CONTROL_CLOCK_SOURCE);
     usbd_audio_add_entity(0x03, AUDIO_CONTROL_FEATURE_UNIT);
     usbd_audio_add_entity(0x05, AUDIO_CONTROL_CLOCK_SOURCE);

demo/audio_v2_speaker_multichan_template.c

@@ -159,17 +159,13 @@ void usbd_audio_close(uint8_t intf)
     rx_flag = 0;
 }
 
-static usbd_class_t audio_class;
-static usbd_interface_t audio_control_intf;
-static usbd_interface_t audio_stream_intf;
-
 #ifdef CONFIG_USB_HS
 #define AUDIO_OUT_EP_MPS 512
 #else
 #define AUDIO_OUT_EP_MPS 64
 #endif
 
-USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t out_buffer[AUDIO_OUT_EP_MPS];
 
 void usbd_configure_done_callback(void)
 {
@@ -181,7 +177,7 @@ void usbd_audio_iso_out_callback(uint8_t ep, uint32_t nbytes)
 {
 }
 
-static usbd_endpoint_t audio_out_ep = {
+static struct usbd_endpoint audio_out_ep = {
     .ep_cb = usbd_audio_iso_out_callback,
     .ep_addr = AUDIO_OUT_EP
 };
@@ -189,9 +185,10 @@ static usbd_endpoint_t audio_out_ep = {
 void audio_init()
 {
     usbd_desc_register(audio_descriptor);
-    usbd_audio_add_interface(&audio_class, &audio_control_intf);
-    usbd_audio_add_interface(&audio_class, &audio_stream_intf);
-    usbd_interface_add_endpoint(&audio_stream_intf, &audio_out_ep);
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_interface(usbd_audio_alloc_intf());
+    usbd_add_endpoint(&audio_out_ep);
+
     usbd_audio_add_entity(0x01, AUDIO_CONTROL_CLOCK_SOURCE);
     usbd_audio_add_entity(0x03, AUDIO_CONTROL_FEATURE_UNIT);
 

demo/cdc_acm_hid_msc_template.c

@@ -223,12 +223,6 @@ struct hid_mouse {
     int8_t wheel;
 };
 
-/*!< class */
-static usbd_class_t hid_class;
-
-/*!< interface */
-static usbd_interface_t hid_intf;
-
 /*!< mouse report */
 static struct hid_mouse mouse_cfg;
 
@@ -250,18 +244,11 @@ static void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes)
 }
 
 /*!< endpoint call back */
-static usbd_endpoint_t hid_in_ep = {
+static struct usbd_endpoint hid_in_ep = {
     .ep_cb = usbd_hid_int_callback,
     .ep_addr = HID_INT_EP
 };
 
-/*!< class */
-usbd_class_t cdc_class;
-/*!< interface one */
-usbd_interface_t cdc_cmd_intf;
-/*!< interface two */
-usbd_interface_t cdc_data_intf;
-
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[2048];
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[2048] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
 
@@ -299,12 +286,12 @@ void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes)
 }
 
 /*!< endpoint call back */
-usbd_endpoint_t cdc_out_ep = {
+struct usbd_endpoint cdc_out_ep = {
     .ep_addr = CDC_OUT_EP,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep = {
+struct usbd_endpoint cdc_in_ep = {
     .ep_addr = CDC_IN_EP,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
@@ -320,20 +307,15 @@ void cdc_acm_hid_msc_descriptor_init(void)
 {
     usbd_desc_register(cdc_acm_hid_msc_descriptor);
 
-    /*!< add interface */
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_cmd_intf);
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_data_intf);
-    /*!< interface add endpoint */
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_out_ep);
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_in_ep);
-
-    usbd_msc_class_init(MSC_OUT_EP, MSC_IN_EP);
-    /*!< add interface */
-    usbd_hid_add_interface(&hid_class, &hid_intf);
-    /*!< interface add endpoint */
-    usbd_interface_add_endpoint(&hid_intf, &hid_in_ep);
-    /*!< register report descriptor */
-    usbd_hid_report_descriptor_register(1, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE);
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep);
+    usbd_add_endpoint(&cdc_in_ep);
+
+    usbd_add_interface(usbd_msc_alloc_intf(MSC_OUT_EP, MSC_IN_EP));
+
+    usbd_add_interface(usbd_hid_alloc_intf(hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE));
+    usbd_add_endpoint(&hid_in_ep);
 
     /*!< init mouse report data */
     mouse_cfg.buttons = 0;

demo/cdc_acm_msc_template.c

@@ -98,13 +98,6 @@ static const uint8_t cdc_msc_descriptor[] = {
     0x00
 };
 
-/*!< class */
-usbd_class_t cdc_class;
-/*!< interface one */
-usbd_interface_t cdc_cmd_intf;
-/*!< interface two */
-usbd_interface_t cdc_data_intf;
-
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[2048];
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[2048] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
 
@@ -142,12 +135,12 @@ void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes)
 }
 
 /*!< endpoint call back */
-usbd_endpoint_t cdc_out_ep = {
+struct usbd_endpoint cdc_out_ep = {
     .ep_addr = CDC_OUT_EP,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep = {
+struct usbd_endpoint cdc_in_ep = {
     .ep_addr = CDC_IN_EP,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
@@ -156,14 +149,11 @@ usbd_endpoint_t cdc_in_ep = {
 void cdc_acm_msc_init(void)
 {
     usbd_desc_register(cdc_msc_descriptor);
-    /*!< add interface */
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_cmd_intf);
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_data_intf);
-    /*!< interface add endpoint */
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_out_ep);
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_in_ep);
-
-    usbd_msc_class_init(MSC_OUT_EP, MSC_IN_EP);
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep);
+    usbd_add_endpoint(&cdc_in_ep);
+    usbd_add_interface(usbd_msc_alloc_intf(MSC_OUT_EP, MSC_IN_EP));
 
     usbd_initialize();
 }

demo/cdc_acm_multi_template.c

@@ -108,13 +108,6 @@ static const uint8_t cdc_descriptor[] = {
     0x00
 };
 
-/*!< class */
-usbd_class_t cdc_class;
-/*!< interface one */
-usbd_interface_t cdc_cmd_intf;
-/*!< interface two */
-usbd_interface_t cdc_data_intf;
-
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[4][2048];
 USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[4][2048] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
 
@@ -154,59 +147,42 @@ void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes)
     }
 }
 
-/*!< endpoint call back */
-usbd_class_t cdc_class1;
-usbd_interface_t cdc_cmd_intf1;
-usbd_interface_t cdc_data_intf1;
-
-usbd_endpoint_t cdc_out_ep1 = {
+struct usbd_endpoint cdc_out_ep1 = {
     .ep_addr = CDC_OUT_EP,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep1 = {
+struct usbd_endpoint cdc_in_ep1 = {
     .ep_addr = CDC_IN_EP,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
 
-usbd_class_t cdc_class2;
-usbd_interface_t cdc_cmd_intf2;
-usbd_interface_t cdc_data_intf2;
-
-usbd_endpoint_t cdc_out_ep2 = {
+struct usbd_endpoint cdc_out_ep2 = {
     .ep_addr = CDC_OUT_EP2,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep2 = {
+struct usbd_endpoint cdc_in_ep2 = {
     .ep_addr = CDC_IN_EP2,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
 
-usbd_class_t cdc_class3;
-usbd_interface_t cdc_cmd_intf3;
-usbd_interface_t cdc_data_intf3;
-
-usbd_endpoint_t cdc_out_ep3 = {
+struct usbd_endpoint cdc_out_ep3 = {
     .ep_addr = CDC_OUT_EP3,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep3 = {
+struct usbd_endpoint cdc_in_ep3 = {
     .ep_addr = CDC_IN_EP3,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
 
-usbd_class_t cdc_class4;
-usbd_interface_t cdc_cmd_intf4;
-usbd_interface_t cdc_data_intf4;
-
-usbd_endpoint_t cdc_out_ep4 = {
+struct usbd_endpoint cdc_out_ep4 = {
     .ep_addr = CDC_OUT_EP4,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep4 = {
+struct usbd_endpoint cdc_in_ep4 = {
     .ep_addr = CDC_IN_EP4,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
@@ -216,25 +192,25 @@ void cdc_acm_multi_init(void)
 {
     usbd_desc_register(cdc_descriptor);
 
-    usbd_cdc_add_acm_interface(&cdc_class1, &cdc_cmd_intf1);
-    usbd_cdc_add_acm_interface(&cdc_class1, &cdc_data_intf1);
-    usbd_interface_add_endpoint(&cdc_data_intf1, &cdc_out_ep1);
-    usbd_interface_add_endpoint(&cdc_data_intf1, &cdc_in_ep1);
-
-    usbd_cdc_add_acm_interface(&cdc_class2, &cdc_cmd_intf2);
-    usbd_cdc_add_acm_interface(&cdc_class2, &cdc_data_intf2);
-    usbd_interface_add_endpoint(&cdc_data_intf2, &cdc_out_ep2);
-    usbd_interface_add_endpoint(&cdc_data_intf2, &cdc_in_ep2);
-
-    usbd_cdc_add_acm_interface(&cdc_class3, &cdc_cmd_intf3);
-    usbd_cdc_add_acm_interface(&cdc_class3, &cdc_data_intf3);
-    usbd_interface_add_endpoint(&cdc_data_intf3, &cdc_out_ep3);
-    usbd_interface_add_endpoint(&cdc_data_intf3, &cdc_in_ep3);
-
-    usbd_cdc_add_acm_interface(&cdc_class4, &cdc_cmd_intf4);
-    usbd_cdc_add_acm_interface(&cdc_class4, &cdc_data_intf4);
-    usbd_interface_add_endpoint(&cdc_data_intf4, &cdc_out_ep4);
-    usbd_interface_add_endpoint(&cdc_data_intf4, &cdc_in_ep4);
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep1);
+    usbd_add_endpoint(&cdc_in_ep1);
+
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep2);
+    usbd_add_endpoint(&cdc_in_ep2);
+
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep3);
+    usbd_add_endpoint(&cdc_in_ep3);
+
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep4);
+    usbd_add_endpoint(&cdc_in_ep4);
 
     usbd_initialize();
 }

demo/cdc_acm_template.c

@@ -93,15 +93,8 @@ static const uint8_t cdc_descriptor[] = {
     0x00
 };
 
-/*!< class */
-usbd_class_t cdc_class;
-/*!< interface one */
-usbd_interface_t cdc_cmd_intf;
-/*!< interface two */
-usbd_interface_t cdc_data_intf;
-
-uint8_t read_buffer[2048];
-uint8_t write_buffer[2048] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[2048];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[2048] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
 
 volatile bool ep_tx_busy_flag = false;
 
@@ -141,12 +134,12 @@ void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes)
 }
 
 /*!< endpoint call back */
-usbd_endpoint_t cdc_out_ep = {
+struct usbd_endpoint cdc_out_ep = {
     .ep_addr = CDC_OUT_EP,
     .ep_cb = usbd_cdc_acm_bulk_out
 };
 
-usbd_endpoint_t cdc_in_ep = {
+struct usbd_endpoint cdc_in_ep = {
     .ep_addr = CDC_IN_EP,
     .ep_cb = usbd_cdc_acm_bulk_in
 };
@@ -155,13 +148,10 @@ usbd_endpoint_t cdc_in_ep = {
 void cdc_acm_init(void)
 {
     usbd_desc_register(cdc_descriptor);
-    /*!< add interface */
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_cmd_intf);
-    usbd_cdc_add_acm_interface(&cdc_class, &cdc_data_intf);
-    /*!< interface add endpoint */
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_out_ep);
-    usbd_interface_add_endpoint(&cdc_data_intf, &cdc_in_ep);
-
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_interface(usbd_cdc_acm_alloc_intf());
+    usbd_add_endpoint(&cdc_out_ep);
+    usbd_add_endpoint(&cdc_in_ep);
     usbd_initialize();
 }
 

demo/hid_custom_inout_template.c

@@ -172,12 +172,6 @@ void usbd_configure_done_callback(void)
     usbd_ep_start_read(HIDRAW_OUT_EP, read_buffer, 64);
 }
 
-/*!< class */
-static usbd_class_t hid_class;
-
-/*!< interface one */
-static usbd_interface_t hid_intf_1;
-
 static void usbd_hid_custom_in_callback(uint8_t ep, uint32_t nbytes)
 {
     USB_LOG_RAW("actual in len:%d\r\n", nbytes);
@@ -193,12 +187,12 @@ static void usbd_hid_custom_out_callback(uint8_t ep, uint32_t nbytes)
     usbd_ep_start_read(HIDRAW_OUT_EP, read_buffer, 64);
 }
 
-static usbd_endpoint_t custom_in_ep = {
+static struct usbd_endpoint custom_in_ep = {
     .ep_cb = usbd_hid_custom_in_callback,
     .ep_addr = HIDRAW_IN_EP
 };
 
-static usbd_endpoint_t custom_out_ep = {
+static struct usbd_endpoint custom_out_ep = {
     .ep_cb = usbd_hid_custom_out_callback,
     .ep_addr = HIDRAW_OUT_EP
 };
@@ -213,14 +207,9 @@ static usbd_endpoint_t custom_out_ep = {
 void hid_custom_keyboard_init(void)
 {
     usbd_desc_register(hid_descriptor);
-    /*!< add interface ! the first interface */
-    usbd_hid_add_interface(&hid_class, &hid_intf_1);
-    /*!< interface0 add endpoint ! the first endpoint */
-    usbd_interface_add_endpoint(&hid_intf_1, &custom_in_ep);
-    /*!< interface0 add endpoint ! the second endpoint */
-    usbd_interface_add_endpoint(&hid_intf_1, &custom_out_ep);
-    /*!< register report descriptor interface 0 */
-    usbd_hid_report_descriptor_register(0, hid_custom_report_desc, HID_CUSTOM_REPORT_DESC_SIZE);
+    usbd_add_interface(usbd_hid_alloc_intf(hid_custom_report_desc, HID_CUSTOM_REPORT_DESC_SIZE));
+    usbd_add_endpoint(&custom_in_ep);
+    usbd_add_endpoint(&custom_out_ep);
 
     usbd_initialize();
 }

demo/hid_keyboard_template.c

@@ -177,9 +177,6 @@ void usbd_configure_done_callback(void)
     /* no out ep, do nothing */
 }
 
-static usbd_class_t hid_class;
-static usbd_interface_t hid_intf;
-
 #define HID_STATE_IDLE 0
 #define HID_STATE_BUSY 1
 
@@ -196,7 +193,7 @@ void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes)
     }
 }
 
-static usbd_endpoint_t hid_in_ep = {
+static struct usbd_endpoint hid_in_ep = {
     .ep_cb = usbd_hid_int_callback,
     .ep_addr = 0x81
 };
@@ -204,9 +201,8 @@ static usbd_endpoint_t hid_in_ep = {
 void hid_keyboard_init(void)
 {
     usbd_desc_register(hid_descriptor);
-    usbd_hid_add_interface(&hid_class, &hid_intf);
-    usbd_interface_add_endpoint(&hid_intf, &hid_in_ep);
-    usbd_hid_report_descriptor_register(0, hid_keyboard_report_desc, HID_KEYBOARD_REPORT_DESC_SIZE);
+    usbd_add_interface(usbd_hid_alloc_intf(hid_keyboard_report_desc, HID_KEYBOARD_REPORT_DESC_SIZE));
+    usbd_add_endpoint(&hid_in_ep);
 
     usbd_initialize();
 }

demo/hid_mouse_template.c

@@ -188,12 +188,6 @@ struct hid_mouse {
     int8_t wheel;
 };
 
-/*!< class */
-static usbd_class_t hid_class;
-
-/*!< interface */
-static usbd_interface_t hid_intf;
-
 /*!< mouse report */
 static struct hid_mouse mouse_cfg;
 
@@ -217,7 +211,7 @@ static void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes)
 }
 
 /*!< endpoint call back */
-static usbd_endpoint_t hid_in_ep = {
+static struct usbd_endpoint hid_in_ep = {
     .ep_cb = usbd_hid_int_callback,
     .ep_addr = 0x81
 };
@@ -232,12 +226,8 @@ static usbd_endpoint_t hid_in_ep = {
 void hid_mouse_init(void)
 {
     usbd_desc_register(hid_descriptor);
-    /*!< add interface */
-    usbd_hid_add_interface(&hid_class, &hid_intf);
-    /*!< interface add endpoint */
-    usbd_interface_add_endpoint(&hid_intf, &hid_in_ep);
-    /*!< register report descriptor */
-    usbd_hid_report_descriptor_register(0, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE);
+    usbd_add_interface(usbd_hid_alloc_intf(hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE));
+    usbd_add_endpoint(&hid_in_ep);
 
     usbd_initialize();
 

demo/midi_template.c

@@ -1,7 +1,7 @@
 #include "usbd_core.h"
 #include "usb_midi.h"
 
-USB_DESC_SECTION const uint8_t midi_descriptor[] = {
+const uint8_t midi_descriptor[] = {
     USB_DEVICE_DESCRIPTOR_INIT(USB_2_0, 0x00, 0x00, 0x00, USBD_VID, USBD_PID, 0x0100, 0x01),
     USB_CONFIG_DESCRIPTOR_INIT(USB_CONFIG_SIZE, 0x02, 0x01, USB_CONFIG_BUS_POWERED, USBD_MAX_POWER),
     // Standard AC Interface Descriptor
@@ -130,37 +130,34 @@ USB_DESC_SECTION const uint8_t midi_descriptor[] = {
     0x00
 };
 
-void usbd_midi_bulk_out(uint8_t ep)
+void usbd_midi_bulk_out(uint8_t ep, uint32_t nbytes)
 {
 }
 
-void usbd_midi_bulk_in(uint8_t ep)
+void usbd_midi_bulk_in(uint8_t ep, uint32_t nbytes)
 {
 }
 
-usbd_class_t midi_class;
-usbd_interface_t midi_cmd_intf;
-usbd_interface_t midi_data_intf;
+struct usbd_interface midi_cmd_intf;
+struct usbd_interface midi_data_intf;
 
-usbd_endpoint_t midi_out_ep = {
+struct usbd_endpoint midi_out_ep = {
     .ep_addr = MIDI_OUT_EP,
     .ep_cb = usbd_midi_bulk_out
 };
 
-usbd_endpoint_t midi_in_ep = {
+struct usbd_endpoint midi_in_ep = {
     .ep_addr = MIDI_IN_EP,
     .ep_cb = usbd_midi_bulk_in
 };
 
-
 void midi_init(void)
 {
     usbd_desc_register(midi_descriptor);
-
-    usbd_class_add_interface(&midi_class, &midi_cmd_intf);
-    usbd_class_add_interface(&midi_class, &midi_data_intf);
-    usbd_interface_add_endpoint(&midi_data_intf, &midi_out_ep);
-    usbd_interface_add_endpoint(&midi_data_intf, &midi_in_ep);
+    usbd_add_interface(&midi_cmd_intf);
+    usbd_add_interface(&midi_data_intf);
+    usbd_add_endpoint(&midi_out_ep);
+    usbd_add_endpoint(&midi_in_ep);
 
     usbd_initialize();
 }

demo/msc_ram_template.c

@@ -133,7 +133,7 @@ int usbd_msc_sector_write(uint32_t sector, uint8_t *buffer, uint32_t length)
 void msc_ram_init(void)
 {
     usbd_desc_register(msc_ram_descriptor);
-    usbd_msc_class_init(MSC_OUT_EP, MSC_IN_EP);
+    usbd_add_interface(usbd_msc_alloc_intf(MSC_OUT_EP, MSC_IN_EP));
 
     usbd_initialize();
 }

demo/video_static_mjpeg_template.c

@@ -154,10 +154,6 @@ void usbd_video_close(uint8_t intf)
     tx_flag = 0;
 }
 
-static usbd_class_t video_class;
-static usbd_interface_t video_control_intf;
-static usbd_interface_t video_stream_intf;
-
 volatile bool iso_tx_busy = false;
 
 void usbd_video_iso_callback(uint8_t ep, uint32_t nbytes)
@@ -165,7 +161,7 @@ void usbd_video_iso_callback(uint8_t ep, uint32_t nbytes)
     iso_tx_busy = false;
 }
 
-static usbd_endpoint_t video_in_ep = {
+static struct usbd_endpoint video_in_ep = {
     .ep_cb = usbd_video_iso_callback,
     .ep_addr = VIDEO_IN_EP
 };
@@ -173,11 +169,8 @@ static usbd_endpoint_t video_in_ep = {
 void video_init()
 {
     usbd_desc_register(video_descriptor);
-    usbd_video_add_interface(&video_class, &video_control_intf);
-    usbd_video_add_interface(&video_class, &video_stream_intf);
-    usbd_interface_add_endpoint(&video_stream_intf, &video_in_ep);
-
-    usbd_video_probe_and_commit_controls_init(CAM_FPS, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE);
+    usbd_add_interface(usbd_video_alloc_intf(CAM_FPS, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE));
+    usbd_add_endpoint(&video_in_ep);
 
     usbd_initialize();
 }

demo/winusb1.0_template.c

@@ -190,7 +190,7 @@ const uint8_t winusb_descriptor[] = {
 #define WINUSB_OUT_EP_MPS 64
 #endif
 
-uint8_t read_buffer[2048];
+USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[2048];
 
 void usbd_configure_done_callback(void)
 {
@@ -206,15 +206,14 @@ void usbd_winusb_in(uint8_t ep, uint32_t nbytes)
 {
 }
 
-usbd_class_t winusb_class;
-usbd_interface_t winusb_intf;
+struct usbd_interface winusb_intf;
 
-usbd_endpoint_t winusb_out_ep = {
+struct usbd_endpoint winusb_out_ep = {
     .ep_addr = WINUSB_OUT_EP,
     .ep_cb = usbd_winusb_out
 };
 
-usbd_endpoint_t winusb_in_ep = {
+struct usbd_endpoint winusb_in_ep = {
     .ep_addr = WINUSB_IN_EP,
     .ep_cb = usbd_winusb_in
 };
@@ -223,9 +222,9 @@ void daplink_winusb_init(void)
 {
     usbd_desc_register(winusb_descriptor);
     usbd_msosv1_desc_register(&msosv1_desc);
-    usbd_class_add_interface(&winusb_class, &winusb_intf);
-    usbd_interface_add_endpoint(&winusb_intf, &winusb_out_ep);
-    usbd_interface_add_endpoint(&winusb_intf, &winusb_in_ep);
+    usbd_add_interface(&winusb_intf);
+    usbd_add_endpoint(&winusb_out_ep);
+    usbd_add_endpoint(&winusb_in_ep);
 
     usbd_initialize();
 

docs/source/api/api_device.rst

@@ -1,13 +1,11 @@
 设备协议栈
 =========================
 
-关于设备协议栈 API 的实现过程，有兴趣的可以看我的 B 站视频。设备协议栈的 API 使用了大量的链表，如何使用相关 API,参考下面一张图，并且总结如下：
+设备协议栈主要负责枚举和驱动加载，枚举这边就不说了，驱动加载，也就是接口驱动加载，主要是依靠 `usbd_add_interface` 函数，记录传入的接口驱动保存到链表中，当主机进行类请求时就可以查找链表进行访问了。
+在调用 `usbd_desc_register` 以后需要进行接口注册和端点注册，口诀如下：
 
-- 有多少个 class 就调用多少次 `usbd_class_register`
-- 每个 class 有多少个接口就调用多少次 `usbd_class_add_interface`，已经支持的 class 接口就调用对应的 `usbd_xxx_class_add_interface`
-- 每个接口有多少个端点就调用多少次 `usbd_interface_add_endpoint`
-
-.. figure:: img/api_device1.png
+- 有多少个接口就调用多少次 `usbd_add_interface`，参数填各个 class alloc出来的 intf，如果没有 alloc 的intf 表示不需要加载。
+- 有多少个端点就调用多少次 `usbd_add_endpoint`，当中断完成时，会调用到注册的端点回调中。
 
 CORE
 -----------------
@@ -19,11 +17,10 @@ CORE
 
 .. code-block:: C
 
-    typedef struct usbd_endpoint {
-        usb_slist_t list;
+    struct usbd_endpoint {
         uint8_t ep_addr;
         usbd_endpoint_callback ep_cb;
-    } usbd_endpoint_t;
+    };
 
 - **list** 端点的链表节点
 - **ep_addr** 端点地址（带方向）
@@ -38,7 +35,7 @@ CORE
 
 .. code-block:: C
 
-    typedef struct usbd_interface {
+    struct usbd_interface {
         usb_slist_t list;
         /** Handler for USB Class specific commands*/
         usbd_request_handler class_handler;
@@ -48,9 +45,10 @@ CORE
         usbd_request_handler custom_handler;
         /** Handler for USB event notify commands */
         usbd_notify_handler notify_handler;
+        uint8_t *hid_report_descriptor;
+        uint8_t *hid_report_descriptor_len;
         uint8_t intf_num;
-        usb_slist_t ep_list;
-    } usbd_interface_t;
+    };
 
 - **list** 接口的链表节点
 - **class_handler** class setup 请求回调函数
@@ -60,23 +58,6 @@ CORE
 - **intf_num** 当前接口偏移
 - **ep_list** 端点的链表节点
 
-类结构体
-""""""""""""""""""""""""""""""""""""
-
-类结构体主要用于挂载接口链表。后期可能会删除，因为这个部分跟接口其实是有关系的。
-
-.. code-block:: C
-
-    typedef struct usbd_class {
-        usb_slist_t list;
-        const char *name;
-        usb_slist_t intf_list;
-    } usbd_class_t;
-
-- **list** 类的链表节点
-- **name** 类的名称
-- **intf_list** 接口的链表节点
-
 usbd_desc_register
 """"""""""""""""""""""""""""""""""""
 
@@ -132,29 +113,26 @@ usbd_class_register
 
 - **devclass**  USB 设备类的句柄
 
-usbd_class_add_interface
+usbd_add_interface
 """"""""""""""""""""""""""""""""""""
 
-``usbd_class_add_interface`` 用来给 USB 设备类增加接口，并将接口信息挂载在类的链表上。
+``usbd_add_interface`` 添加一个接口驱动。
 
 .. code-block:: C
 
-    void usbd_class_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+    void usbd_add_interface(struct usbd_interface *intf);
 
-- **devclass**  USB 设备类的句柄
 - **intf**   USB 设备接口的句柄
 
-usbd_interface_add_endpoint
+usbd_add_endpoint
 """"""""""""""""""""""""""""""""""""
 
-``usbd_interface_add_endpoint`` 用来给 USB 接口增加端点，并将端点信息挂载在接口的链表上。
+``usbd_add_endpoint`` 添加一个端点中断完成回调函数。
 
 .. code-block:: C
 
-    void usbd_interface_add_endpoint(usbd_interface_t *intf, usbd_endpoint_t *ep);
+    void usbd_add_endpoint(struct usbd_endpoint *ep);;
 
-
-- **intf**  USB 设备接口的句柄
 - **ep**    USB 设备端点的句柄
 
 usb_device_is_configured
@@ -191,20 +169,19 @@ usbd_initialize
 CDC ACM
 -----------------
 
-usbd_cdc_add_acm_interface
+usbd_cdc_acm_alloc_intf
 """"""""""""""""""""""""""""""""""""
 
-``usbd_cdc_add_acm_interface`` 用来给 USB CDC ACM 类添加接口，并实现该接口相关的函数。
+``usbd_cdc_acm_alloc_intf`` 用来申请一个 USB CDC ACM 类接口，并实现该接口相关的函数。
 
 - ``cdc_acm_class_request_handler`` 用来处理 USB CDC ACM 类 Setup 请求。
 - ``cdc_notify_handler`` 用来处理 USB CDC 其他中断回调函数。
 
 .. code-block:: C
 
-    void usbd_cdc_add_acm_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+    struct usbd_interface *usbd_cdc_acm_alloc_intf(void);
 
-- **devclass** 类的句柄
-- **intf**  接口句柄
+- **return**  接口句柄
 
 usbd_cdc_acm_set_line_coding
 """"""""""""""""""""""""""""""""""""
@@ -213,13 +190,22 @@ usbd_cdc_acm_set_line_coding
 
 .. code-block:: C
 
-    void usbd_cdc_acm_set_line_coding(uint8_t intf, uint32_t baudrate, uint8_t databits, uint8_t parity, uint8_t stopbits);
+    void usbd_cdc_acm_set_line_coding(uint8_t intf, struct cdc_line_coding *line_coding);
+
+- **intf** 控制接口号
+- **line_coding** 串口配置
+
+usbd_cdc_acm_get_line_coding
+""""""""""""""""""""""""""""""""""""
+
+``usbd_cdc_acm_get_line_coding`` 用来获取串口进行配置，如果仅使用 USB 而不用 串口，该接口不用用户实现，使用默认。
+
+.. code-block:: C
+
+    void usbd_cdc_acm_get_line_coding(uint8_t intf, struct cdc_line_coding *line_coding);
 
 - **intf** 控制接口号
-- **baudrate** 波特率
-- **databits**  数据位
-- **parity**  校验位
-- **stopbits**  停止位
+- **line_coding** 串口配置
 
 usbd_cdc_acm_set_dtr
 """"""""""""""""""""""""""""""""""""
@@ -263,10 +249,10 @@ CDC_ACM_DESCRIPTOR_INIT
 HID
 -----------------
 
-usbd_hid_add_interface
+usbd_hid_alloc_intf
 """"""""""""""""""""""""""""""""""""
 
-``usbd_hid_add_interface`` 用来给 USB HID 类添加接口，并实现该接口相关的函数：
+``usbd_hid_alloc_intf`` 用来申请一个 USB HID 类接口，并实现该接口相关的函数：
 
 - ``hid_class_request_handler`` 用来处理 USB HID 类的 Setup 请求。
 - ``hid_custom_request_handler`` 用来处理 USB HID 获取报告描述符请求。
@@ -274,30 +260,17 @@ usbd_hid_add_interface
 
 .. code-block:: C
 
-    void usbd_hid_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+    struct usbd_interface *usbd_hid_alloc_intf(const uint8_t *desc, uint32_t desc_len);
 
-- **devclass** 类的句柄
-- **intf**  接口句柄
-
-usbd_hid_report_descriptor_register
-""""""""""""""""""""""""""""""""""""""""""""
-
-``usbd_hid_report_descriptor_register``  用来注册 hid 报告描述符。
-
-.. code-block:: C
-
-    void usbd_hid_report_descriptor_register(uint8_t intf_num, const uint8_t *desc, uint32_t desc_len);
-
-- **intf_num** 当前 hid 报告描述符所在接口偏移
 - **desc** 报告描述符
 - **desc_len** 报告描述符长度
 
 MSC
 -----------------
 
-usbd_msc_class_init
+usbd_msc_alloc_intf
 """"""""""""""""""""""""""""""""""""
-``usbd_msc_class_init`` 用来给 MSC 类添加接口，并实现该接口相关函数，并且注册端点回调函数。（因为 msc bot 协议是固定的，所以不需要用于实现，因此端点回调函数自然不需要用户实现）。
+``usbd_msc_alloc_intf`` 用来申请一个 MSC 类接口，并实现该接口相关函数，并且注册端点回调函数。（因为 msc bot 协议是固定的，所以不需要用于实现，因此端点回调函数自然不需要用户实现）。
 
 - ``msc_storage_class_request_handler`` 用于处理 USB MSC Setup 中断请求。
 - ``msc_storage_notify_handler`` 用于实现 USB MSC 其他中断回调函数。
@@ -307,7 +280,7 @@ usbd_msc_class_init
 
 .. code-block:: C
 
-    void usbd_msc_class_init(uint8_t out_ep, uint8_t in_ep);
+    struct usbd_interface *usbd_msc_alloc_intf(const uint8_t out_ep, const uint8_t in_ep);
 
 - **out_ep**     out 端点地址
 - **in_ep**      in 端点地址
@@ -355,16 +328,16 @@ usbd_msc_sector_write
 UAC
 -----------------
 
-usbd_audio_add_interface
+usbd_audio_alloc_intf
 """"""""""""""""""""""""""""""""""""
-``usbd_audio_add_interface``  用来给 USB Audio 类添加接口，并实现该接口相关的函数：
+``usbd_audio_alloc_intf``  用来申请一个 USB Audio 类接口，并实现该接口相关的函数：
 
 - ``audio_class_request_handler`` 用于处理 USB Audio Setup 中断请求。
 - ``audio_notify_handler`` 用于实现 USB Audio 其他中断回调函数。
 
 .. code-block:: C
 
-    void usbd_audio_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+    struct usbd_interface *usbd_audio_alloc_intf(void);
 
 - **class** 类的句柄
 - **intf**  接口句柄
@@ -465,31 +438,22 @@ usbd_audio_set_pitch
 UVC
 -----------------
 
-usbd_video_add_interface
+usbd_video_alloc_intf
 """"""""""""""""""""""""""""""""""""
-``usbd_video_add_interface``  用来给 USB Video 类添加接口，并实现该接口相关的函数：
+``usbd_video_alloc_intf``  用来申请一个 USB Video 类接口，并实现该接口相关的函数：
 
 - ``video_class_request_handler`` 用于处理 USB Video Setup 中断请求。
 - ``video_notify_handler`` 用于实现 USB Video 其他中断回调函数。
 
 .. code-block:: C
 
-    void usbd_video_add_interface(usbd_class_t *devclass, usbd_interface_t *intf);
+    struct usbd_interface *usbd_video_alloc_intf(uint32_t dwFrameInterval,
+                                             uint32_t dwMaxVideoFrameSize,
+                                             uint32_t dwMaxPayloadTransferSize);
 
 - **class** 类的句柄
 - **intf**  接口句柄
 
-usbd_video_probe_and_commit_controls_init
-""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-
-``usbd_video_probe_and_commit_controls_init``  初始化视频传输每帧最大传输长度。
-
-.. code-block:: C
-
-    void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize);
-
-- **value** 为1 表示开启 stream 传输，为0 相反
-
 usbd_video_open
 """"""""""""""""""""""""""""""""""""