yemai/CherryUSB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor usb device intf and ep register

Browse Source
This commit is contained in:
sakumisu
2022-08-20 16:20:23 +08:00
parent 523d33506d
commit 3c94fca8d8
36 changed files with 326 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
class/audio/usbd_audio.c
View File

@@ -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)

3
class/audio/usbd_audio.h
View File

@@ -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);

27
class/cdc/usbd_cdc.c
View File

@@ -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)

4
class/cdc/usbd_cdc.h
View File

@@ -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);

13
class/dfu/usbd_dfu.c
View File

@@ -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;
}

3
class/dfu/usbd_dfu.h
View File

@@ -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
}

144
class/hid/usbd_hid.c
View File

@@ -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_hid *hid_class = usb_slist_entry(i, struct usbd_hid, list);
struct usbd_interface *match_intf = NULL;
if (hid_class->intf_num == intf_num) {
current_hid_class = hid_class;
usb_slist_for_each(i, &usbd_intf_head)
{
struct usbd_interface *intf = usb_slist_entry(i, struct usbd_interface, list);
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;
}
}
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;
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;
}
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);
}
intf->notify_handler = NULL;
void usbd_hid_descriptor_register(uint8_t intf_num, const uint8_t *desc)
{
// usbd_hid_cfg.hid_descriptor = desc;
}
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)

4
class/hid/usbd_hid.h
View File

@@ -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);

11
class/hub/usbd_hub.c
View File

@@ -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);
}
}

2
class/hub/usbd_hub.h
View File

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

43
class/msc/usbd_msc.c
View File

@@ -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;
}
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;
intf->class_handler = msc_storage_class_request_handler;
intf->custom_handler = NULL;
intf->vendor_handler = NULL;
intf->notify_handler = msc_storage_notify_handler;
usbd_interface_add_endpoint(&msc_intf, &mass_ep_data[0]);
usbd_interface_add_endpoint(&msc_intf, &mass_ep_data[1]);
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_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;
}

7
class/msc/usbd_msc.h
View File

@@ -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);

2
class/mtp/usbd_mtp.c
View File

@@ -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)
{

12
class/printer/usbd_printer.c
View File

@@ -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;
}

3
class/printer/usbd_printer.h
View File

@@ -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
}

40
class/video/usbd_video.c
View File

@@ -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;

6
class/video/usbd_video.h
View File

@@ -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);

24
core/usbd_core.c
View File

@@ -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 {

27
core/usbd_core.h
View File

@@ -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);

13
demo/audio_v1_mic_multichan_template.c
View File

@@ -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();

22
demo/audio_v1_mic_speaker_multichan_template.c
View File

@@ -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);

13
demo/audio_v2_mic_multichan_template.c
View File

@@ -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);

22
demo/audio_v2_mic_speaker_multichan_template.c
View File

@@ -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);

15
demo/audio_v2_speaker_multichan_template.c
View File

@@ -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);

40
demo/cdc_acm_hid_msc_template.c
View File

@@ -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_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_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_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;

24
demo/cdc_acm_msc_template.c
View File

@@ -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();
}

72
demo/cdc_acm_multi_template.c
View File

@@ -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_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_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_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_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_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_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_ep4);
usbd_add_endpoint(&cdc_in_ep4);
usbd_initialize();
}

26
demo/cdc_acm_template.c
View File

@@ -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();
}

21
demo/hid_custom_inout_template.c
View File

@@ -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();
}

10
demo/hid_keyboard_template.c
View File

@@ -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();
}

16
demo/hid_mouse_template.c
View File

@@ -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();

25
demo/midi_template.c
View File

@@ -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();
}

2
demo/msc_ram_template.c
View File

@@ -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();
}

13
demo/video_static_mjpeg_template.c
View File

@@ -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();
}

15
demo/winusb1.0_template.c
View File

@@ -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();

132
docs/source/api/api_device.rst
View File

@@ -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** 控制接口号
- **baudrate** 波特率
- **databits** 数据位
- **parity** 校验位
- **stopbits** 停止位
- **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** 控制接口号
- **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
""""""""""""""""""""""""""""""""""""