From d1c7fa8c191efa3028794b1d6965ea3229e14c85 Mon Sep 17 00:00:00 2001 From: sakumisu <1203593632@qq.com> Date: Tue, 6 Feb 2024 19:51:50 +0800 Subject: [PATCH] support multi port api for device --- cherryusb_config_template.h | 2 + class/audio/usbd_audio.c | 73 +-- class/audio/usbd_audio.h | 20 +- class/cdc/usbd_cdc.c | 24 +- class/cdc/usbd_cdc.h | 12 +- class/cdc/usbd_cdc_ecm.c | 43 +- class/cdc/usbd_cdc_ecm.h | 2 +- class/dfu/usbd_dfu.c | 4 +- class/hid/usbd_hid.c | 28 +- class/hid/usbd_hid.h | 18 +- class/msc/usbd_msc.c | 519 +++++++++--------- class/msc/usbd_msc.h | 12 +- class/template/usbd_xxx.c | 6 +- class/template/usbd_xxx.h | 2 +- class/video/usbd_video.c | 154 +++--- class/video/usbd_video.h | 8 +- class/wireless/usbd_rndis.c | 28 +- common/usb_dc.h | 38 +- core/usbd_core.c | 495 ++++++++--------- core/usbd_core.h | 28 +- demo/audio_v1_mic_multichan_template.c | 22 +- .../audio_v1_mic_speaker_multichan_template.c | 32 +- demo/audio_v2_mic_multichan_template.c | 22 +- .../audio_v2_mic_speaker_multichan_template.c | 34 +- demo/audio_v2_speaker_multichan_template.c | 26 +- demo/cdc_acm_hid_msc_template.c | 46 +- demo/cdc_acm_msc_template.c | 40 +- demo/cdc_acm_multi_template.c | 54 +- demo/cdc_acm_template.c | 30 +- demo/cdc_ecm_template.c | 10 +- demo/cdc_rndis_template.c | 10 +- demo/dfu_with_st_tool_template.c | 8 +- demo/hid_custom_inout_template.c | 24 +- demo/hid_keyboard_template.c | 16 +- demo/hid_mouse_template.c | 16 +- demo/midi_template.c | 20 +- demo/msc_ram_template.c | 16 +- demo/msc_storage_template.c | 16 +- demo/video_static_mjpeg_template.c | 28 +- demo/winusb1.0_template.c | 46 +- port/ch32/README.md | 7 - port/ch32/usb_ch58x_dc_usbfs.c | 494 +++++++++-------- port/ch32/usb_dc_usbfs.c | 34 +- port/ch32/usb_dc_usbhs.c | 34 +- port/dwc2/README.md | 7 - port/dwc2/usb_dc_dwc2.c | 34 +- port/ehci/README.md | 9 +- port/fsdev/README.md | 8 - port/fsdev/usb_dc_fsdev.c | 40 +- port/hpm/usb_dc_hpm.c | 152 ++--- port/musb/README.md | 9 +- port/musb/usb_dc_musb.c | 34 +- port/nuvoton/README.md | 7 - port/nuvoton/usb_dc_usbfs.c | 38 +- port/pusb2/usb_dc_pusb2.c | 28 +- port/template/usb_dc.c | 20 +- 56 files changed, 1487 insertions(+), 1500 deletions(-) diff --git a/cherryusb_config_template.h b/cherryusb_config_template.h index 033c5146..4c2c5a0a 100644 --- a/cherryusb_config_template.h +++ b/cherryusb_config_template.h @@ -146,6 +146,8 @@ /* ================ USB Device Port Configuration ================*/ +#define CONFIG_USBDEV_MAX_BUS 1 // for now, bus num must be 1 except hpm ip + #define USBD_IRQHandler USBD_IRQHandler #define USBD_BASE (0) #define CONFIG_USBDEV_EP_NUM 4 diff --git a/class/audio/usbd_audio.c b/class/audio/usbd_audio.c index 4478d459..c78c8ed7 100644 --- a/class/audio/usbd_audio.c +++ b/class/audio/usbd_audio.c @@ -17,9 +17,9 @@ struct usbd_audio_priv { struct audio_entity_info *table; uint8_t num; uint16_t uac_version; -} g_usbd_audio; +} g_usbd_audio[CONFIG_USBDEV_MAX_BUS]; -static int audio_class_endpoint_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int audio_class_endpoint_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t control_selector; uint32_t sampling_freq = 0; @@ -34,13 +34,13 @@ static int audio_class_endpoint_request_handler(struct usb_setup_packet *setup, case AUDIO_REQUEST_SET_CUR: memcpy((uint8_t *)&sampling_freq, *data, *len); USB_LOG_DBG("Set ep:0x%02x %d Hz\r\n", ep, (int)sampling_freq); - usbd_audio_set_sampling_freq(ep, sampling_freq); + usbd_audio_set_sampling_freq(busid, ep, sampling_freq); break; case AUDIO_REQUEST_GET_CUR: case AUDIO_REQUEST_GET_MIN: case AUDIO_REQUEST_GET_MAX: case AUDIO_REQUEST_GET_RES: - sampling_freq = usbd_audio_get_sampling_freq(ep); + sampling_freq = usbd_audio_get_sampling_freq(busid, ep); memcpy(*data, &sampling_freq, 3); USB_LOG_DBG("Get ep:0x%02x %d Hz\r\n", ep, (int)sampling_freq); *len = 3; @@ -55,7 +55,7 @@ static int audio_class_endpoint_request_handler(struct usb_setup_packet *setup, return 0; } -static int audio_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int audio_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("Audio Class request: " "bRequest 0x%02x\r\n", @@ -79,10 +79,10 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, ARG_UNUSED(mute_string); - for (uint8_t i = 0; i < g_usbd_audio.num; i++) { - if (g_usbd_audio.table[i].bEntityId == entity_id) { - subtype = g_usbd_audio.table[i].bDescriptorSubtype; - ep = g_usbd_audio.table[i].ep; + for (uint8_t i = 0; i < g_usbd_audio[busid].num; i++) { + if (g_usbd_audio[busid].table[i].bEntityId == entity_id) { + subtype = g_usbd_audio[busid].table[i].bDescriptorSubtype; + ep = g_usbd_audio[busid].table[i].ep; break; } } @@ -98,14 +98,14 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, case AUDIO_CONTROL_FEATURE_UNIT: switch (control_selector) { case AUDIO_FU_CONTROL_MUTE: - if (g_usbd_audio.uac_version < 0x0200) { + if (g_usbd_audio[busid].uac_version < 0x0200) { switch (setup->bRequest) { case AUDIO_REQUEST_SET_CUR: mute = (*data)[0]; - usbd_audio_set_mute(ep, ch, mute); + usbd_audio_set_mute(busid, ep, ch, mute); break; case AUDIO_REQUEST_GET_CUR: - (*data)[0] = usbd_audio_get_mute(ep, ch); + (*data)[0] = usbd_audio_get_mute(busid, ep, ch); *len = 1; break; default: @@ -116,11 +116,11 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, switch (setup->bRequest) { case AUDIO_REQUEST_CUR: if (setup->bmRequestType & USB_REQUEST_DIR_MASK) { - (*data)[0] = usbd_audio_get_mute(ep, ch); + (*data)[0] = usbd_audio_get_mute(busid, ep, ch); *len = 1; } else { mute = (*data)[0]; - usbd_audio_set_mute(ep, ch, mute); + usbd_audio_set_mute(busid, ep, ch, mute); } break; default: @@ -130,7 +130,7 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, } break; case AUDIO_FU_CONTROL_VOLUME: - if (g_usbd_audio.uac_version < 0x0200) { + if (g_usbd_audio[busid].uac_version < 0x0200) { switch (setup->bRequest) { case AUDIO_REQUEST_SET_CUR: memcpy(&volume, *data, *len); @@ -141,10 +141,10 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, } volume_db += 128; /* 0 ~ 255 */ USB_LOG_DBG("Set ep:0x%02x ch:%d volume:0x%04x\r\n", ep, ch, volume); - usbd_audio_set_volume(ep, ch, volume_db); + usbd_audio_set_volume(busid, ep, ch, volume_db); break; case AUDIO_REQUEST_GET_CUR: - volume_db = usbd_audio_get_volume(ep, ch); + volume_db = usbd_audio_get_volume(busid, ep, ch); volume_db -= 128; if (volume_db >= 0) { volume = volume_db * 256; @@ -177,7 +177,7 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, switch (setup->bRequest) { case AUDIO_REQUEST_CUR: if (setup->bmRequestType & USB_REQUEST_DIR_MASK) { - volume_db = usbd_audio_get_volume(ep, ch); + volume_db = usbd_audio_get_volume(busid, ep, ch); volume = volume_db; memcpy(*data, &volume, 2); *len = 2; @@ -185,7 +185,7 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, memcpy(&volume, *data, *len); volume_db = volume; USB_LOG_DBG("Set ep:0x%02x ch:%d volume:0x%02x\r\n", ep, ch, volume); - usbd_audio_set_volume(ep, ch, volume_db); + usbd_audio_set_volume(busid, ep, ch, volume_db); } break; case AUDIO_REQUEST_RANGE: @@ -216,14 +216,14 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, switch (setup->bRequest) { case AUDIO_REQUEST_CUR: if (setup->bmRequestType & USB_REQUEST_DIR_MASK) { - sampling_freq = usbd_audio_get_sampling_freq(ep); + sampling_freq = usbd_audio_get_sampling_freq(busid, ep); memcpy(*data, &sampling_freq, 4); USB_LOG_DBG("Get ep:0x%02x %d Hz\r\n", ep, (int)sampling_freq); *len = 4; } else { memcpy(&sampling_freq, *data, setup->wLength); USB_LOG_DBG("Set ep:0x%02x %d Hz\r\n", ep, (int)sampling_freq); - usbd_audio_set_sampling_freq(ep, sampling_freq); + usbd_audio_set_sampling_freq(busid, ep, sampling_freq); } break; case AUDIO_REQUEST_RANGE: @@ -231,7 +231,7 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t *sampling_freq_table = NULL; uint16_t num; - usbd_audio_get_sampling_freq_table(ep, &sampling_freq_table); + usbd_audio_get_sampling_freq_table(busid, ep, &sampling_freq_table); num = (uint16_t)((uint16_t)(sampling_freq_table[1] << 8) | ((uint16_t)sampling_freq_table[0])); memcpy(*data, sampling_freq_table, (12 * num + 2)); *len = (12 * num + 2); @@ -264,7 +264,7 @@ static int audio_class_interface_request_handler(struct usb_setup_packet *setup, return 0; } -static void audio_notify_handler(uint8_t event, void *arg) +static void audio_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: @@ -274,9 +274,9 @@ static void audio_notify_handler(uint8_t event, void *arg) case USBD_EVENT_SET_INTERFACE: { struct usb_interface_descriptor *intf = (struct usb_interface_descriptor *)arg; if (intf->bAlternateSetting) { - usbd_audio_open(intf->bInterfaceNumber); + usbd_audio_open(busid, intf->bInterfaceNumber); } else { - usbd_audio_close(intf->bInterfaceNumber); + usbd_audio_close(busid, intf->bInterfaceNumber); } } @@ -287,7 +287,8 @@ static void audio_notify_handler(uint8_t event, void *arg) } } -struct usbd_interface *usbd_audio_init_intf(struct usbd_interface *intf, +struct usbd_interface *usbd_audio_init_intf(uint8_t busid, + struct usbd_interface *intf, uint16_t uac_version, struct audio_entity_info *table, uint8_t num) @@ -304,40 +305,40 @@ struct usbd_interface *usbd_audio_init_intf(struct usbd_interface *intf, intf->notify_handler = audio_notify_handler; } - g_usbd_audio.uac_version = uac_version; - g_usbd_audio.table = table; - g_usbd_audio.num = num; + g_usbd_audio[busid].uac_version = uac_version; + g_usbd_audio[busid].table = table; + g_usbd_audio[busid].num = num; return intf; } -__WEAK void usbd_audio_set_volume(uint8_t ep, uint8_t ch, int volume) +__WEAK void usbd_audio_set_volume(uint8_t busid, uint8_t ep, uint8_t ch, int volume) { } -__WEAK int usbd_audio_get_volume(uint8_t ep, uint8_t ch) +__WEAK int usbd_audio_get_volume(uint8_t busid, uint8_t ep, uint8_t ch) { return 0; } -__WEAK void usbd_audio_set_mute(uint8_t ep, uint8_t ch, bool mute) +__WEAK void usbd_audio_set_mute(uint8_t busid, uint8_t ep, uint8_t ch, bool mute) { } -__WEAK bool usbd_audio_get_mute(uint8_t ep, uint8_t ch) +__WEAK bool usbd_audio_get_mute(uint8_t busid, uint8_t ep, uint8_t ch) { return 0; } -__WEAK void usbd_audio_set_sampling_freq(uint8_t ep, uint32_t sampling_freq) +__WEAK void usbd_audio_set_sampling_freq(uint8_t busid, uint8_t ep, uint32_t sampling_freq) { } -__WEAK uint32_t usbd_audio_get_sampling_freq(uint8_t ep) +__WEAK uint32_t usbd_audio_get_sampling_freq(uint8_t busid, uint8_t ep) { return 0; } -__WEAK void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_table) +__WEAK void usbd_audio_get_sampling_freq_table(uint8_t busid, uint8_t ep, uint8_t **sampling_freq_table) { } diff --git a/class/audio/usbd_audio.h b/class/audio/usbd_audio.h index 94fe07f5..442405a2 100644 --- a/class/audio/usbd_audio.h +++ b/class/audio/usbd_audio.h @@ -19,22 +19,22 @@ struct audio_entity_info { }; /* Init audio interface driver */ -struct usbd_interface *usbd_audio_init_intf(struct usbd_interface *intf, +struct usbd_interface *usbd_audio_init_intf(uint8_t busid, struct usbd_interface *intf, uint16_t uac_version, struct audio_entity_info *table, uint8_t num); -void usbd_audio_open(uint8_t intf); -void usbd_audio_close(uint8_t intf); +void usbd_audio_open(uint8_t busid, uint8_t intf); +void usbd_audio_close(uint8_t busid, uint8_t intf); -void usbd_audio_set_volume(uint8_t ep, uint8_t ch, int volume); -int usbd_audio_get_volume(uint8_t ep, uint8_t ch); -void usbd_audio_set_mute(uint8_t ep, uint8_t ch, bool mute); -bool usbd_audio_get_mute(uint8_t ep, uint8_t ch); -void usbd_audio_set_sampling_freq(uint8_t ep, uint32_t sampling_freq); -uint32_t usbd_audio_get_sampling_freq(uint8_t ep); +void usbd_audio_set_volume(uint8_t busid, uint8_t ep, uint8_t ch, int volume); +int usbd_audio_get_volume(uint8_t busid, uint8_t ep, uint8_t ch); +void usbd_audio_set_mute(uint8_t busid, uint8_t ep, uint8_t ch, bool mute); +bool usbd_audio_get_mute(uint8_t busid, uint8_t ep, uint8_t ch); +void usbd_audio_set_sampling_freq(uint8_t busid, uint8_t ep, uint32_t sampling_freq); +uint32_t usbd_audio_get_sampling_freq(uint8_t busid, uint8_t ep); -void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_table); +void usbd_audio_get_sampling_freq_table(uint8_t busid, uint8_t ep, uint8_t **sampling_freq_table); #ifdef __cplusplus } diff --git a/class/cdc/usbd_cdc.c b/class/cdc/usbd_cdc.c index 297ddc7a..50d13d7d 100644 --- a/class/cdc/usbd_cdc.c +++ b/class/cdc/usbd_cdc.c @@ -9,7 +9,7 @@ const char *stop_name[] = { "1", "1.5", "2" }; const char *parity_name[] = { "N", "O", "E", "M", "S" }; -static int cdc_acm_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int cdc_acm_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("CDC Class request: " "bRequest 0x%02x\r\n", @@ -47,7 +47,7 @@ static int cdc_acm_class_interface_request_handler(struct usb_setup_packet *setu parity_name[line_coding.bParityType], stop_name[line_coding.bCharFormat]); - usbd_cdc_acm_set_line_coding(intf_num, &line_coding); + usbd_cdc_acm_set_line_coding(busid, intf_num, &line_coding); break; case CDC_REQUEST_SET_CONTROL_LINE_STATE: @@ -57,12 +57,12 @@ static int cdc_acm_class_interface_request_handler(struct usb_setup_packet *setu intf_num, dtr, rts); - usbd_cdc_acm_set_dtr(intf_num, dtr); - usbd_cdc_acm_set_rts(intf_num, rts); + usbd_cdc_acm_set_dtr(busid, intf_num, dtr); + usbd_cdc_acm_set_rts(busid, intf_num, rts); break; case CDC_REQUEST_GET_LINE_CODING: - usbd_cdc_acm_get_line_coding(intf_num, &line_coding); + usbd_cdc_acm_get_line_coding(busid, intf_num, &line_coding); memcpy(*data, &line_coding, 7); *len = 7; USB_LOG_DBG("Get intf:%d linecoding %d %d %d %d\r\n", @@ -73,7 +73,7 @@ static int cdc_acm_class_interface_request_handler(struct usb_setup_packet *setu line_coding.bDataBits); break; case CDC_REQUEST_SEND_BREAK: - usbd_cdc_acm_send_break(intf_num); + usbd_cdc_acm_send_break(busid, intf_num); break; default: USB_LOG_WRN("Unhandled CDC Class bRequest 0x%02x\r\n", setup->bRequest); @@ -83,7 +83,7 @@ static int cdc_acm_class_interface_request_handler(struct usb_setup_packet *setu return 0; } -struct usbd_interface *usbd_cdc_acm_init_intf(struct usbd_interface *intf) +struct usbd_interface *usbd_cdc_acm_init_intf(uint8_t busid, struct usbd_interface *intf) { intf->class_interface_handler = cdc_acm_class_interface_request_handler; intf->class_endpoint_handler = NULL; @@ -93,11 +93,11 @@ struct usbd_interface *usbd_cdc_acm_init_intf(struct usbd_interface *intf) return intf; } -__WEAK void usbd_cdc_acm_set_line_coding(uint8_t intf, struct cdc_line_coding *line_coding) +__WEAK void usbd_cdc_acm_set_line_coding(uint8_t busid, uint8_t intf, struct cdc_line_coding *line_coding) { } -__WEAK void usbd_cdc_acm_get_line_coding(uint8_t intf, struct cdc_line_coding *line_coding) +__WEAK void usbd_cdc_acm_get_line_coding(uint8_t busid, uint8_t intf, struct cdc_line_coding *line_coding) { line_coding->dwDTERate = 2000000; line_coding->bDataBits = 8; @@ -105,14 +105,14 @@ __WEAK void usbd_cdc_acm_get_line_coding(uint8_t intf, struct cdc_line_coding *l line_coding->bCharFormat = 0; } -__WEAK void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr) +__WEAK void usbd_cdc_acm_set_dtr(uint8_t busid, uint8_t intf, bool dtr) { } -__WEAK void usbd_cdc_acm_set_rts(uint8_t intf, bool rts) +__WEAK void usbd_cdc_acm_set_rts(uint8_t busid, uint8_t intf, bool rts) { } -__WEAK void usbd_cdc_acm_send_break(uint8_t intf) +__WEAK void usbd_cdc_acm_send_break(uint8_t busid, uint8_t intf) { } diff --git a/class/cdc/usbd_cdc.h b/class/cdc/usbd_cdc.h index 90e08f4a..ebf3d029 100644 --- a/class/cdc/usbd_cdc.h +++ b/class/cdc/usbd_cdc.h @@ -13,14 +13,14 @@ extern "C" { #endif /* Init cdc acm interface driver */ -struct usbd_interface *usbd_cdc_acm_init_intf(struct usbd_interface *intf); +struct usbd_interface *usbd_cdc_acm_init_intf(uint8_t busid, struct usbd_interface *intf); /* Setup request command callback api */ -void usbd_cdc_acm_set_line_coding(uint8_t intf, struct cdc_line_coding *line_coding); -void usbd_cdc_acm_get_line_coding(uint8_t intf, struct cdc_line_coding *line_coding); -void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr); -void usbd_cdc_acm_set_rts(uint8_t intf, bool rts); -void usbd_cdc_acm_send_break(uint8_t intf); +void usbd_cdc_acm_set_line_coding(uint8_t busid, uint8_t intf, struct cdc_line_coding *line_coding); +void usbd_cdc_acm_get_line_coding(uint8_t busid, uint8_t intf, struct cdc_line_coding *line_coding); +void usbd_cdc_acm_set_dtr(uint8_t busid, uint8_t intf, bool dtr); +void usbd_cdc_acm_set_rts(uint8_t busid, uint8_t intf, bool rts); +void usbd_cdc_acm_send_break(uint8_t busid, uint8_t intf); #ifdef __cplusplus } diff --git a/class/cdc/usbd_cdc_ecm.c b/class/cdc/usbd_cdc_ecm.c index d9be91d4..70b5365c 100644 --- a/class/cdc/usbd_cdc_ecm.c +++ b/class/cdc/usbd_cdc_ecm.c @@ -75,11 +75,11 @@ void usbd_cdc_ecm_send_notify(uint8_t notifycode, uint8_t value, uint32_t *speed } if (bytes2send) { - usbd_ep_start_write(cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX].ep_addr, g_cdc_ecm_notify_buf, bytes2send); + usbd_ep_start_write(0, cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX].ep_addr, g_cdc_ecm_notify_buf, bytes2send); } } -static int cdc_ecm_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int cdc_ecm_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("CDC ECM Class request: " "bRequest 0x%02x\r\n", @@ -109,7 +109,7 @@ static int cdc_ecm_class_interface_request_handler(struct usb_setup_packet *setu return 0; } -void cdc_ecm_notify_handler(uint8_t event, void *arg) +void cdc_ecm_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: @@ -119,7 +119,7 @@ void cdc_ecm_notify_handler(uint8_t event, void *arg) g_cdc_ecm_rx_data_buffer = NULL; break; case USBD_EVENT_CONFIGURED: - usbd_ep_start_read(cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX].ep_addr, &g_cdc_ecm_rx_buffer[g_cdc_ecm_rx_data_length], CDC_ECM_MAX_PACKET_SIZE); + usbd_ep_start_read(0, cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX].ep_addr, &g_cdc_ecm_rx_buffer[g_cdc_ecm_rx_data_length], CDC_ECM_MAX_PACKET_SIZE); break; default: @@ -127,29 +127,29 @@ void cdc_ecm_notify_handler(uint8_t event, void *arg) } } -void cdc_ecm_bulk_out(uint8_t ep, uint32_t nbytes) +void cdc_ecm_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { g_cdc_ecm_rx_data_length += nbytes; if (nbytes < CDC_ECM_MAX_PACKET_SIZE) { g_cdc_ecm_rx_data_buffer = g_cdc_ecm_rx_buffer; - usbd_cdc_ecm_data_recv_done(); + usbd_cdc_ecm_data_recv_done(g_cdc_ecm_rx_buffer, g_cdc_ecm_rx_data_length); } else { - usbd_ep_start_read(ep, &g_cdc_ecm_rx_buffer[g_cdc_ecm_rx_data_length], CDC_ECM_MAX_PACKET_SIZE); + usbd_ep_start_read(0, ep, &g_cdc_ecm_rx_buffer[g_cdc_ecm_rx_data_length], CDC_ECM_MAX_PACKET_SIZE); } } -void cdc_ecm_bulk_in(uint8_t ep, uint32_t nbytes) +void cdc_ecm_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { if ((nbytes % CDC_ECM_MAX_PACKET_SIZE) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(ep, NULL, 0); + usbd_ep_start_write(0, ep, NULL, 0); } else { g_cdc_ecm_tx_data_length = 0; } } -void cdc_ecm_int_in(uint8_t ep, uint32_t nbytes) +void cdc_ecm_int_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { if (g_current_net_status == 1) { g_current_net_status = 2; @@ -157,28 +157,23 @@ void cdc_ecm_int_in(uint8_t ep, uint32_t nbytes) } } -uint8_t *usbd_cdc_ecm_get_tx_buffer(void) -{ - return g_cdc_ecm_tx_buffer; -} - -int usbd_cdc_ecm_start_write(uint32_t length) +int usbd_cdc_ecm_start_write(uint8_t *buf, uint32_t len) { if (g_cdc_ecm_tx_data_length > 0) { return -USB_ERR_BUSY; } - g_cdc_ecm_tx_data_length = length; + g_cdc_ecm_tx_data_length = len; USB_LOG_DBG("txlen:%d\r\n", g_cdc_ecm_tx_data_length); - return usbd_ep_start_write(cdc_ecm_ep_data[CDC_ECM_IN_EP_IDX].ep_addr, g_cdc_ecm_tx_buffer, g_cdc_ecm_tx_data_length); + return usbd_ep_start_write(0, cdc_ecm_ep_data[CDC_ECM_IN_EP_IDX].ep_addr, buf, g_cdc_ecm_tx_data_length); } void usbd_cdc_ecm_start_read_next(void) { g_cdc_ecm_rx_data_length = 0; g_cdc_ecm_rx_data_buffer = NULL; - usbd_ep_start_read(cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX].ep_addr, g_cdc_ecm_rx_buffer, CDC_ECM_MAX_PACKET_SIZE); + usbd_ep_start_read(0, cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX].ep_addr, g_cdc_ecm_rx_buffer, CDC_ECM_MAX_PACKET_SIZE); } #ifdef CONFIG_USBDEV_CDC_ECM_USING_LWIP @@ -223,7 +218,7 @@ int usbd_cdc_ecm_eth_tx(struct pbuf *p) g_cdc_ecm_tx_data_length = p->tot_len; - return usbd_cdc_ecm_start_write(g_cdc_ecm_tx_data_length); + return usbd_cdc_ecm_start_write(g_cdc_ecm_tx_buffer, g_cdc_ecm_tx_data_length); } #endif @@ -241,9 +236,9 @@ struct usbd_interface *usbd_cdc_ecm_init_intf(struct usbd_interface *intf, const cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX].ep_addr = int_ep; cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX].ep_cb = cdc_ecm_int_in; - usbd_add_endpoint(&cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX]); - usbd_add_endpoint(&cdc_ecm_ep_data[CDC_ECM_IN_EP_IDX]); - usbd_add_endpoint(&cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX]); + usbd_add_endpoint(0, &cdc_ecm_ep_data[CDC_ECM_OUT_EP_IDX]); + usbd_add_endpoint(0, &cdc_ecm_ep_data[CDC_ECM_IN_EP_IDX]); + usbd_add_endpoint(0, &cdc_ecm_ep_data[CDC_ECM_INT_EP_IDX]); return intf; } @@ -253,6 +248,6 @@ void usbd_cdc_ecm_set_connect_speed(uint32_t speed[2]) memcpy(g_connect_speed_table, speed, 8); } -__WEAK void usbd_cdc_ecm_data_recv_done(void) +__WEAK void usbd_cdc_ecm_data_recv_done(uint8_t *buf, uint32_t len) { } \ No newline at end of file diff --git a/class/cdc/usbd_cdc_ecm.h b/class/cdc/usbd_cdc_ecm.h index 9859fe7c..8d9e5c9f 100644 --- a/class/cdc/usbd_cdc_ecm.h +++ b/class/cdc/usbd_cdc_ecm.h @@ -24,7 +24,7 @@ void usbd_cdc_ecm_set_connect_speed(uint32_t speed[2]); /* Api for eth only without any net stack */ uint8_t *usbd_cdc_ecm_get_tx_buffer(void); void usbd_cdc_ecm_send_done(void); -int usbd_cdc_ecm_start_write(uint32_t length); +int usbd_cdc_ecm_start_write(uint8_t *buf, uint32_t len); void usbd_cdc_ecm_data_recv_done(uint8_t *buf, uint32_t len); void usbd_cdc_ecm_start_read_next(void); diff --git a/class/dfu/usbd_dfu.c b/class/dfu/usbd_dfu.c index 45714274..a870aee3 100644 --- a/class/dfu/usbd_dfu.c +++ b/class/dfu/usbd_dfu.c @@ -428,7 +428,7 @@ void dfu_request_abort(void) } } -static int dfu_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int dfu_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("DFU Class request: " "bRequest 0x%02x\r\n", @@ -464,7 +464,7 @@ static int dfu_class_interface_request_handler(struct usb_setup_packet *setup, u return 0; } -static void dfu_notify_handler(uint8_t event, void *arg) +static void dfu_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: diff --git a/class/hid/usbd_hid.c b/class/hid/usbd_hid.c index 6e325294..d98b82eb 100644 --- a/class/hid/usbd_hid.c +++ b/class/hid/usbd_hid.c @@ -6,7 +6,7 @@ #include "usbd_core.h" #include "usbd_hid.h" -static int hid_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int hid_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("HID Class request: " "bRequest 0x%02x\r\n", @@ -17,27 +17,27 @@ static int hid_class_interface_request_handler(struct usb_setup_packet *setup, u switch (setup->bRequest) { case HID_REQUEST_GET_REPORT: /* report id ,report type */ - usbd_hid_get_report(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), data, len); + usbd_hid_get_report(busid, intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), data, len); break; case HID_REQUEST_GET_IDLE: - (*data)[0] = usbd_hid_get_idle(intf_num, LO_BYTE(setup->wValue)); + (*data)[0] = usbd_hid_get_idle(busid, intf_num, LO_BYTE(setup->wValue)); *len = 1; break; case HID_REQUEST_GET_PROTOCOL: - (*data)[0] = usbd_hid_get_protocol(intf_num); + (*data)[0] = usbd_hid_get_protocol(busid, intf_num); *len = 1; break; case HID_REQUEST_SET_REPORT: /* report id ,report type, report, report len */ - usbd_hid_set_report(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), *data, *len); + usbd_hid_set_report(busid, intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue), *data, *len); break; case HID_REQUEST_SET_IDLE: /* report id, duration */ - usbd_hid_set_idle(intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue)); + usbd_hid_set_idle(busid, intf_num, LO_BYTE(setup->wValue), HI_BYTE(setup->wValue)); break; case HID_REQUEST_SET_PROTOCOL: /* protocol */ - usbd_hid_set_protocol(intf_num, LO_BYTE(setup->wValue)); + usbd_hid_set_protocol(busid, intf_num, LO_BYTE(setup->wValue)); break; default: @@ -48,7 +48,7 @@ static int hid_class_interface_request_handler(struct usb_setup_packet *setup, u return 0; } -struct usbd_interface *usbd_hid_init_intf(struct usbd_interface *intf, const uint8_t *desc, uint32_t desc_len) +struct usbd_interface *usbd_hid_init_intf(uint8_t busid, struct usbd_interface *intf, const uint8_t *desc, uint32_t desc_len) { intf->class_interface_handler = hid_class_interface_request_handler; intf->class_endpoint_handler = NULL; @@ -60,30 +60,30 @@ struct usbd_interface *usbd_hid_init_intf(struct usbd_interface *intf, const uin return intf; } -__WEAK void usbd_hid_get_report(uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t **data, uint32_t *len) +__WEAK void usbd_hid_get_report(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t **data, uint32_t *len) { (*data[0]) = 0; *len = 1; } -__WEAK uint8_t usbd_hid_get_idle(uint8_t intf, uint8_t report_id) +__WEAK uint8_t usbd_hid_get_idle(uint8_t busid, uint8_t intf, uint8_t report_id) { return 0; } -__WEAK uint8_t usbd_hid_get_protocol(uint8_t intf) +__WEAK uint8_t usbd_hid_get_protocol(uint8_t busid, uint8_t intf) { return 0; } -__WEAK void usbd_hid_set_report(uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t *report, uint32_t report_len) +__WEAK void usbd_hid_set_report(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t *report, uint32_t report_len) { } -__WEAK void usbd_hid_set_idle(uint8_t intf, uint8_t report_id, uint8_t duration) +__WEAK void usbd_hid_set_idle(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t duration) { } -__WEAK void usbd_hid_set_protocol(uint8_t intf, uint8_t protocol) +__WEAK void usbd_hid_set_protocol(uint8_t busid, uint8_t intf, uint8_t protocol) { } \ No newline at end of file diff --git a/class/hid/usbd_hid.h b/class/hid/usbd_hid.h index b63a010c..d5c3484f 100644 --- a/class/hid/usbd_hid.h +++ b/class/hid/usbd_hid.h @@ -13,19 +13,19 @@ extern "C" { #endif /* Init hid interface driver */ -struct usbd_interface *usbd_hid_init_intf(struct usbd_interface *intf, const uint8_t *desc, uint32_t desc_len); +struct usbd_interface *usbd_hid_init_intf(uint8_t busid, struct usbd_interface *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); -void usbd_hid_report_descriptor_register(uint8_t intf_num, const uint8_t *desc, uint32_t desc_len); +void usbd_hid_descriptor_register(uint8_t busid, uint8_t intf_num, const uint8_t *desc); +void usbd_hid_report_descriptor_register(uint8_t busid, uint8_t intf_num, const uint8_t *desc, uint32_t desc_len); /* Setup request command callback api */ -void usbd_hid_get_report(uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t **data, uint32_t *len); -uint8_t usbd_hid_get_idle(uint8_t intf, uint8_t report_id); -uint8_t usbd_hid_get_protocol(uint8_t intf); -void usbd_hid_set_report(uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t *report, uint32_t report_len); -void usbd_hid_set_idle(uint8_t intf, uint8_t report_id, uint8_t duration); -void usbd_hid_set_protocol(uint8_t intf, uint8_t protocol); +void usbd_hid_get_report(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t **data, uint32_t *len); +uint8_t usbd_hid_get_idle(uint8_t busid, uint8_t intf, uint8_t report_id); +uint8_t usbd_hid_get_protocol(uint8_t busid, uint8_t intf); +void usbd_hid_set_report(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t report_type, uint8_t *report, uint32_t report_len); +void usbd_hid_set_idle(uint8_t busid, uint8_t intf, uint8_t report_id, uint8_t duration); +void usbd_hid_set_protocol(uint8_t busid, uint8_t intf, uint8_t protocol); #ifdef __cplusplus } diff --git a/class/msc/usbd_msc.c b/class/msc/usbd_msc.c index d6e22d79..5599690b 100644 --- a/class/msc/usbd_msc.c +++ b/class/msc/usbd_msc.c @@ -15,7 +15,7 @@ #define MSD_IN_EP_IDX 1 /* Describe EndPoints configuration */ -static struct usbd_endpoint mass_ep_data[2]; +static struct usbd_endpoint mass_ep_data[CONFIG_USBDEV_MAX_BUS][2]; /* MSC Bulk-only Stage */ enum Stage { @@ -51,24 +51,24 @@ USB_NOCACHE_RAM_SECTION struct usbd_msc_priv { usb_osal_thread_t usbd_msc_thread; uint32_t nbytes; #endif -} g_usbd_msc; +} g_usbd_msc[CONFIG_USBDEV_MAX_BUS]; #ifdef CONFIG_USBDEV_MSC_THREAD static void usbdev_msc_thread(void *argument); #endif -static void usdb_msc_set_max_lun(void) +static void usdb_msc_set_max_lun(uint8_t busid) { - g_usbd_msc.max_lun = CONFIG_USBDEV_MSC_MAX_LUN - 1u; + g_usbd_msc[busid].max_lun = CONFIG_USBDEV_MSC_MAX_LUN - 1u; } -static void usbd_msc_reset(void) +static void usbd_msc_reset(uint8_t busid) { - g_usbd_msc.stage = MSC_READ_CBW; - g_usbd_msc.readonly = false; + g_usbd_msc[busid].stage = MSC_READ_CBW; + g_usbd_msc[busid].readonly = false; } -static int msc_storage_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int msc_storage_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("MSC Class request: " "bRequest 0x%02x\r\n", @@ -76,11 +76,11 @@ static int msc_storage_class_interface_request_handler(struct usb_setup_packet * switch (setup->bRequest) { case MSC_REQUEST_RESET: - usbd_msc_reset(); + usbd_msc_reset(busid); break; case MSC_REQUEST_GET_MAX_LUN: - (*data)[0] = g_usbd_msc.max_lun; + (*data)[0] = g_usbd_msc[busid].max_lun; *len = 1; break; @@ -92,37 +92,37 @@ static int msc_storage_class_interface_request_handler(struct usb_setup_packet * return 0; } -void msc_storage_notify_handler(uint8_t event, void *arg) +void msc_storage_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_INIT: #ifdef CONFIG_USBDEV_MSC_THREAD - g_usbd_msc.usbd_msc_mq = usb_osal_mq_create(1); - if (g_usbd_msc.usbd_msc_mq == NULL) { - USB_LOG_ERR("No memory to alloc for g_usbd_msc.usbd_msc_mq\r\n"); + g_usbd_msc[busid].usbd_msc_mq = usb_osal_mq_create(1); + if (g_usbd_msc[busid].usbd_msc_mq == NULL) { + USB_LOG_ERR("No memory to alloc for g_usbd_msc[busid].usbd_msc_mq\r\n"); } - g_usbd_msc.usbd_msc_thread = usb_osal_thread_create("usbd_msc", CONFIG_USBDEV_MSC_STACKSIZE, CONFIG_USBDEV_MSC_PRIO, usbdev_msc_thread, NULL); - if (g_usbd_msc.usbd_msc_thread == NULL) { - USB_LOG_ERR("No memory to alloc for g_usbd_msc.usbd_msc_thread\r\n"); + g_usbd_msc[busid].usbd_msc_thread = usb_osal_thread_create("usbd_msc", CONFIG_USBDEV_MSC_STACKSIZE, CONFIG_USBDEV_MSC_PRIO, usbdev_msc_thread, (void *)busid); + if (g_usbd_msc[busid].usbd_msc_thread == NULL) { + USB_LOG_ERR("No memory to alloc for g_usbd_msc[busid].usbd_msc_thread\r\n"); } #endif break; case USBD_EVENT_DEINIT: #ifdef CONFIG_USBDEV_MSC_THREAD - if (g_usbd_msc.usbd_msc_mq) { - usb_osal_mq_delete(g_usbd_msc.usbd_msc_mq); + if (g_usbd_msc[busid].usbd_msc_mq) { + usb_osal_mq_delete(g_usbd_msc[busid].usbd_msc_mq); } - if (g_usbd_msc.usbd_msc_thread) { - usb_osal_thread_delete(g_usbd_msc.usbd_msc_thread); + if (g_usbd_msc[busid].usbd_msc_thread) { + usb_osal_thread_delete(g_usbd_msc[busid].usbd_msc_thread); } #endif break; case USBD_EVENT_RESET: - usbd_msc_reset(); + usbd_msc_reset(busid); break; case USBD_EVENT_CONFIGURED: USB_LOG_DBG("Start reading cbw\r\n"); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_start_read(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc[busid].cbw, USB_SIZEOF_MSC_CBW); break; default: @@ -130,46 +130,46 @@ void msc_storage_notify_handler(uint8_t event, void *arg) } } -static void usbd_msc_bot_abort(void) +static void usbd_msc_bot_abort(uint8_t busid) { - if ((g_usbd_msc.cbw.bmFlags == 0) && (g_usbd_msc.cbw.dDataLength != 0)) { - usbd_ep_set_stall(mass_ep_data[MSD_OUT_EP_IDX].ep_addr); + if ((g_usbd_msc[busid].cbw.bmFlags == 0) && (g_usbd_msc[busid].cbw.dDataLength != 0)) { + usbd_ep_set_stall(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr); } - usbd_ep_set_stall(mass_ep_data[MSD_IN_EP_IDX].ep_addr); - usbd_ep_start_read(mass_ep_data[0].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_set_stall(busid, mass_ep_data[busid][MSD_IN_EP_IDX].ep_addr); + usbd_ep_start_read(busid, mass_ep_data[busid][0].ep_addr, (uint8_t *)&g_usbd_msc[busid].cbw, USB_SIZEOF_MSC_CBW); } -static void usbd_msc_send_csw(uint8_t CSW_Status) +static void usbd_msc_send_csw(uint8_t busid, uint8_t CSW_Status) { - g_usbd_msc.csw.dSignature = MSC_CSW_Signature; - g_usbd_msc.csw.bStatus = CSW_Status; + g_usbd_msc[busid].csw.dSignature = MSC_CSW_Signature; + g_usbd_msc[busid].csw.bStatus = CSW_Status; /* updating the State Machine , so that we wait CSW when this * transfer is complete, ie when we get a bulk in callback */ - g_usbd_msc.stage = MSC_WAIT_CSW; + g_usbd_msc[busid].stage = MSC_WAIT_CSW; USB_LOG_DBG("Send csw\r\n"); - usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.csw, sizeof(struct CSW)); + usbd_ep_start_write(busid, mass_ep_data[busid][MSD_IN_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc[busid].csw, sizeof(struct CSW)); } -static void usbd_msc_send_info(uint8_t *buffer, uint8_t size) +static void usbd_msc_send_info(uint8_t busid, uint8_t *buffer, uint8_t size) { - size = MIN(size, g_usbd_msc.cbw.dDataLength); + size = MIN(size, g_usbd_msc[busid].cbw.dDataLength); /* updating the State Machine , so that we send CSW when this * transfer is complete, ie when we get a bulk in callback */ - g_usbd_msc.stage = MSC_SEND_CSW; + g_usbd_msc[busid].stage = MSC_SEND_CSW; - usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, buffer, size); + usbd_ep_start_write(busid, mass_ep_data[busid][MSD_IN_EP_IDX].ep_addr, buffer, size); - g_usbd_msc.csw.dDataResidue -= size; - g_usbd_msc.csw.bStatus = CSW_STATUS_CMD_PASSED; + g_usbd_msc[busid].csw.dDataResidue -= size; + g_usbd_msc[busid].csw.bStatus = CSW_STATUS_CMD_PASSED; } -static bool SCSI_processWrite(uint32_t nbytes); -static bool SCSI_processRead(void); +static bool SCSI_processWrite(uint8_t busid, uint32_t nbytes); +static bool SCSI_processRead(uint8_t busid); /** * @brief SCSI_SetSenseData @@ -179,11 +179,11 @@ static bool SCSI_processRead(void); * @retval none */ -static void SCSI_SetSenseData(uint32_t KCQ) +static void SCSI_SetSenseData(uint8_t busid, uint32_t KCQ) { - g_usbd_msc.sKey = (uint8_t)(KCQ >> 16); - g_usbd_msc.ASC = (uint8_t)(KCQ >> 8); - g_usbd_msc.ASQ = (uint8_t)(KCQ); + g_usbd_msc[busid].sKey = (uint8_t)(KCQ >> 16); + g_usbd_msc[busid].ASC = (uint8_t)(KCQ >> 8); + g_usbd_msc[busid].ASQ = (uint8_t)(KCQ); } /** @@ -191,10 +191,10 @@ static void SCSI_SetSenseData(uint32_t KCQ) * */ -static bool SCSI_testUnitReady(uint8_t **data, uint32_t *len) +static bool SCSI_testUnitReady(uint8_t busid, uint8_t **data, uint32_t *len) { - if (g_usbd_msc.cbw.dDataLength != 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength != 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } *data = NULL; @@ -202,16 +202,16 @@ static bool SCSI_testUnitReady(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_requestSense(uint8_t **data, uint32_t *len) +static bool SCSI_requestSense(uint8_t busid, uint8_t **data, uint32_t *len) { uint8_t data_len = SCSIRESP_FIXEDSENSEDATA_SIZEOF; - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (g_usbd_msc.cbw.CB[4] < SCSIRESP_FIXEDSENSEDATA_SIZEOF) { - data_len = g_usbd_msc.cbw.CB[4]; + if (g_usbd_msc[busid].cbw.CB[4] < SCSIRESP_FIXEDSENSEDATA_SIZEOF) { + data_len = g_usbd_msc[busid].cbw.CB[4]; } uint8_t request_sense[SCSIRESP_FIXEDSENSEDATA_SIZEOF] = { @@ -235,9 +235,9 @@ static bool SCSI_requestSense(uint8_t **data, uint32_t *len) 0x00, }; - request_sense[2] = g_usbd_msc.sKey; - request_sense[12] = g_usbd_msc.ASC; - request_sense[13] = g_usbd_msc.ASQ; + request_sense[2] = g_usbd_msc[busid].sKey; + request_sense[12] = g_usbd_msc[busid].ASC; + request_sense[13] = g_usbd_msc[busid].ASQ; #if 0 request_sense[ 2] = 0x06; /* UNIT ATTENTION */ request_sense[12] = 0x28; /* Additional Sense Code: Not ready to ready transition */ @@ -264,7 +264,7 @@ static bool SCSI_requestSense(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_inquiry(uint8_t **data, uint32_t *len) +static bool SCSI_inquiry(uint8_t busid, uint8_t **data, uint32_t *len) { uint8_t data_len = SCSIRESP_INQUIRY_SIZEOF; @@ -311,25 +311,25 @@ static bool SCSI_inquiry(uint8_t **data, uint32_t *len) memcpy(&inquiry[16], CONFIG_USBDEV_MSC_PRODUCT_STRING, strlen(CONFIG_USBDEV_MSC_PRODUCT_STRING)); memcpy(&inquiry[32], CONFIG_USBDEV_MSC_VERSION_STRING, strlen(CONFIG_USBDEV_MSC_VERSION_STRING)); - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((g_usbd_msc.cbw.CB[1] & 0x01U) != 0U) { /* Evpd is set */ - if (g_usbd_msc.cbw.CB[2] == 0U) { /* Request for Supported Vital Product Data Pages*/ + if ((g_usbd_msc[busid].cbw.CB[1] & 0x01U) != 0U) { /* Evpd is set */ + if (g_usbd_msc[busid].cbw.CB[2] == 0U) { /* Request for Supported Vital Product Data Pages*/ data_len = 0x06; memcpy(*data, (uint8_t *)inquiry00, data_len); - } else if (g_usbd_msc.cbw.CB[2] == 0x80U) { /* Request for VPD page 0x80 Unit Serial Number */ + } else if (g_usbd_msc[busid].cbw.CB[2] == 0x80U) { /* Request for VPD page 0x80 Unit Serial Number */ data_len = 0x08; memcpy(*data, (uint8_t *)inquiry80, data_len); } else { /* Request Not supported */ - SCSI_SetSenseData(SCSI_KCQIR_INVALIDFIELDINCBA); + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDFIELDINCBA); return false; } } else { - if (g_usbd_msc.cbw.CB[4] < SCSIRESP_INQUIRY_SIZEOF) { - data_len = g_usbd_msc.cbw.CB[4]; + if (g_usbd_msc[busid].cbw.CB[4] < SCSIRESP_INQUIRY_SIZEOF) { + data_len = g_usbd_msc[busid].cbw.CB[4]; } memcpy(*data, (uint8_t *)inquiry, data_len); } @@ -338,21 +338,21 @@ static bool SCSI_inquiry(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_startStopUnit(uint8_t **data, uint32_t *len) +static bool SCSI_startStopUnit(uint8_t busid, uint8_t **data, uint32_t *len) { - if (g_usbd_msc.cbw.dDataLength != 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength != 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x1U) /* START=1 */ + if ((g_usbd_msc[busid].cbw.CB[4] & 0x3U) == 0x1U) /* START=1 */ { //SCSI_MEDIUM_UNLOCKED; - } else if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x2U) /* START=0 and LOEJ Load Eject=1 */ + } else if ((g_usbd_msc[busid].cbw.CB[4] & 0x3U) == 0x2U) /* START=0 and LOEJ Load Eject=1 */ { //SCSI_MEDIUM_EJECTED; - g_usbd_msc.popup = true; - } else if ((g_usbd_msc.cbw.CB[4] & 0x3U) == 0x3U) /* START=1 and LOEJ Load Eject=1 */ + g_usbd_msc[busid].popup = true; + } else if ((g_usbd_msc[busid].cbw.CB[4] & 0x3U) == 0x3U) /* START=1 and LOEJ Load Eject=1 */ { //SCSI_MEDIUM_UNLOCKED; } else { @@ -363,13 +363,13 @@ static bool SCSI_startStopUnit(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_preventAllowMediaRemoval(uint8_t **data, uint32_t *len) +static bool SCSI_preventAllowMediaRemoval(uint8_t busid, uint8_t **data, uint32_t *len) { - if (g_usbd_msc.cbw.dDataLength != 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength != 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (g_usbd_msc.cbw.CB[4] == 0U) { + if (g_usbd_msc[busid].cbw.CB[4] == 0U) { //SCSI_MEDIUM_UNLOCKED; } else { //SCSI_MEDIUM_LOCKED; @@ -379,20 +379,20 @@ static bool SCSI_preventAllowMediaRemoval(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_modeSense6(uint8_t **data, uint32_t *len) +static bool SCSI_modeSense6(uint8_t busid, uint8_t **data, uint32_t *len) { uint8_t data_len = 4; - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (g_usbd_msc.cbw.CB[4] < SCSIRESP_MODEPARAMETERHDR6_SIZEOF) { - data_len = g_usbd_msc.cbw.CB[4]; + if (g_usbd_msc[busid].cbw.CB[4] < SCSIRESP_MODEPARAMETERHDR6_SIZEOF) { + data_len = g_usbd_msc[busid].cbw.CB[4]; } uint8_t sense6[SCSIRESP_MODEPARAMETERHDR6_SIZEOF] = { 0x03, 0x00, 0x00, 0x00 }; - if (g_usbd_msc.readonly) { + if (g_usbd_msc[busid].readonly) { sense6[2] = 0x80; } memcpy(*data, (uint8_t *)sense6, data_len); @@ -400,16 +400,16 @@ static bool SCSI_modeSense6(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_modeSense10(uint8_t **data, uint32_t *len) +static bool SCSI_modeSense10(uint8_t busid, uint8_t **data, uint32_t *len) { uint8_t data_len = 27; - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if (g_usbd_msc.cbw.CB[8] < 27) { - data_len = g_usbd_msc.cbw.CB[8]; + if (g_usbd_msc[busid].cbw.CB[8] < 27) { + data_len = g_usbd_msc[busid].cbw.CB[8]; } uint8_t sense10[27] = { @@ -447,10 +447,10 @@ static bool SCSI_modeSense10(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) +static bool SCSI_readFormatCapacity(uint8_t busid, uint8_t **data, uint32_t *len) { - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } uint8_t format_capacity[SCSIRESP_READFORMATCAPACITIES_SIZEOF] = { @@ -458,15 +458,15 @@ static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) 0x00, 0x00, 0x08, /* Capacity List Length */ - (uint8_t)((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] >> 24) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] >> 16) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] >> 8) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] >> 0) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] >> 24) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] >> 16) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] >> 8) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] >> 0) & 0xff), 0x02, /* Descriptor Code: Formatted Media */ 0x00, - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 8) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 0) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 8) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 0) & 0xff), }; memcpy(*data, (uint8_t *)format_capacity, SCSIRESP_READFORMATCAPACITIES_SIZEOF); @@ -474,23 +474,23 @@ static bool SCSI_readFormatCapacity(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_readCapacity10(uint8_t **data, uint32_t *len) +static bool SCSI_readCapacity10(uint8_t busid, uint8_t **data, uint32_t *len) { - if (g_usbd_msc.cbw.dDataLength == 0U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (g_usbd_msc[busid].cbw.dDataLength == 0U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } uint8_t capacity10[SCSIRESP_READCAPACITY10_SIZEOF] = { - (uint8_t)(((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] - 1) >> 24) & 0xff), - (uint8_t)(((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] - 1) >> 16) & 0xff), - (uint8_t)(((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] - 1) >> 8) & 0xff), - (uint8_t)(((g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN] - 1) >> 0) & 0xff), + (uint8_t)(((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] - 1) >> 24) & 0xff), + (uint8_t)(((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] - 1) >> 16) & 0xff), + (uint8_t)(((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] - 1) >> 8) & 0xff), + (uint8_t)(((g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN] - 1) >> 0) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 24) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 16) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 8) & 0xff), - (uint8_t)((g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN] >> 0) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 24) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 16) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 8) & 0xff), + (uint8_t)((g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN] >> 0) & 0xff), }; memcpy(*data, (uint8_t *)capacity10, SCSIRESP_READCAPACITY10_SIZEOF); @@ -498,283 +498,283 @@ static bool SCSI_readCapacity10(uint8_t **data, uint32_t *len) return true; } -static bool SCSI_read10(uint8_t **data, uint32_t *len) +static bool SCSI_read10(uint8_t busid, uint8_t **data, uint32_t *len) { - if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc.cbw.dDataLength == 0U)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (((g_usbd_msc[busid].cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc[busid].cbw.dDataLength == 0U)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); + g_usbd_msc[busid].start_sector = GET_BE32(&g_usbd_msc[busid].cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc[busid].start_sector); - g_usbd_msc.nsectors = GET_BE16(&g_usbd_msc.cbw.CB[7]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); + g_usbd_msc[busid].nsectors = GET_BE16(&g_usbd_msc[busid].cbw.CB[7]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc[busid].nsectors); - if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN]) { - SCSI_SetSenseData(SCSI_KCQIR_LBAOUTOFRANGE); + if ((g_usbd_msc[busid].start_sector + g_usbd_msc[busid].nsectors) > g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN]) { + SCSI_SetSenseData(busid, SCSI_KCQIR_LBAOUTOFRANGE); USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (g_usbd_msc.cbw.dDataLength != (g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN])) { + if (g_usbd_msc[busid].cbw.dDataLength != (g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN])) { USB_LOG_ERR("scsi_blk_len does not match with dDataLength\r\n"); return false; } - g_usbd_msc.stage = MSC_DATA_IN; + g_usbd_msc[busid].stage = MSC_DATA_IN; #ifdef CONFIG_USBDEV_MSC_THREAD - usb_osal_mq_send(g_usbd_msc.usbd_msc_mq, MSC_DATA_IN); + usb_osal_mq_send(g_usbd_msc[busid].usbd_msc_mq, MSC_DATA_IN); return true; #else - return SCSI_processRead(); + return SCSI_processRead(busid); #endif } -static bool SCSI_read12(uint8_t **data, uint32_t *len) +static bool SCSI_read12(uint8_t busid, uint8_t **data, uint32_t *len) { - if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc.cbw.dDataLength == 0U)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (((g_usbd_msc[busid].cbw.bmFlags & 0x80U) != 0x80U) || (g_usbd_msc[busid].cbw.dDataLength == 0U)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); + g_usbd_msc[busid].start_sector = GET_BE32(&g_usbd_msc[busid].cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc[busid].start_sector); - g_usbd_msc.nsectors = GET_BE32(&g_usbd_msc.cbw.CB[6]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); + g_usbd_msc[busid].nsectors = GET_BE32(&g_usbd_msc[busid].cbw.CB[6]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc[busid].nsectors); - if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN]) { - SCSI_SetSenseData(SCSI_KCQIR_LBAOUTOFRANGE); + if ((g_usbd_msc[busid].start_sector + g_usbd_msc[busid].nsectors) > g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN]) { + SCSI_SetSenseData(busid, SCSI_KCQIR_LBAOUTOFRANGE); USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (g_usbd_msc.cbw.dDataLength != (g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN])) { + if (g_usbd_msc[busid].cbw.dDataLength != (g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN])) { USB_LOG_ERR("scsi_blk_len does not match with dDataLength\r\n"); return false; } - g_usbd_msc.stage = MSC_DATA_IN; + g_usbd_msc[busid].stage = MSC_DATA_IN; #ifdef CONFIG_USBDEV_MSC_THREAD - usb_osal_mq_send(g_usbd_msc.usbd_msc_mq, MSC_DATA_IN); + usb_osal_mq_send(g_usbd_msc[busid].usbd_msc_mq, MSC_DATA_IN); return true; #else - return SCSI_processRead(); + return SCSI_processRead(busid); #endif } -static bool SCSI_write10(uint8_t **data, uint32_t *len) +static bool SCSI_write10(uint8_t busid, uint8_t **data, uint32_t *len) { uint32_t data_len = 0; - if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (((g_usbd_msc[busid].cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc[busid].cbw.dDataLength == 0U)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); + g_usbd_msc[busid].start_sector = GET_BE32(&g_usbd_msc[busid].cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc[busid].start_sector); - g_usbd_msc.nsectors = GET_BE16(&g_usbd_msc.cbw.CB[7]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); + g_usbd_msc[busid].nsectors = GET_BE16(&g_usbd_msc[busid].cbw.CB[7]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc[busid].nsectors); - data_len = g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]; - if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN]) { + data_len = g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]; + if ((g_usbd_msc[busid].start_sector + g_usbd_msc[busid].nsectors) > g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN]) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (g_usbd_msc.cbw.dDataLength != data_len) { + if (g_usbd_msc[busid].cbw.dDataLength != data_len) { return false; } - g_usbd_msc.stage = MSC_DATA_OUT; + g_usbd_msc[busid].stage = MSC_DATA_OUT; data_len = MIN(data_len, CONFIG_USBDEV_MSC_MAX_BUFSIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); + usbd_ep_start_read(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr, g_usbd_msc[busid].block_buffer, data_len); return true; } -static bool SCSI_write12(uint8_t **data, uint32_t *len) +static bool SCSI_write12(uint8_t busid, uint8_t **data, uint32_t *len) { uint32_t data_len = 0; - if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (((g_usbd_msc[busid].cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc[busid].cbw.dDataLength == 0U)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - g_usbd_msc.start_sector = GET_BE32(&g_usbd_msc.cbw.CB[2]); /* Logical Block Address of First Block */ - USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc.start_sector); + g_usbd_msc[busid].start_sector = GET_BE32(&g_usbd_msc[busid].cbw.CB[2]); /* Logical Block Address of First Block */ + USB_LOG_DBG("lba: 0x%04x\r\n", g_usbd_msc[busid].start_sector); - g_usbd_msc.nsectors = GET_BE32(&g_usbd_msc.cbw.CB[6]); /* Number of Blocks to transfer */ - USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc.nsectors); + g_usbd_msc[busid].nsectors = GET_BE32(&g_usbd_msc[busid].cbw.CB[6]); /* Number of Blocks to transfer */ + USB_LOG_DBG("nsectors: 0x%02x\r\n", g_usbd_msc[busid].nsectors); - data_len = g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]; - if ((g_usbd_msc.start_sector + g_usbd_msc.nsectors) > g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN]) { + data_len = g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]; + if ((g_usbd_msc[busid].start_sector + g_usbd_msc[busid].nsectors) > g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN]) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (g_usbd_msc.cbw.dDataLength != data_len) { + if (g_usbd_msc[busid].cbw.dDataLength != data_len) { return false; } - g_usbd_msc.stage = MSC_DATA_OUT; + g_usbd_msc[busid].stage = MSC_DATA_OUT; data_len = MIN(data_len, CONFIG_USBDEV_MSC_MAX_BUFSIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); + usbd_ep_start_read(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr, g_usbd_msc[busid].block_buffer, data_len); return true; } /* do not use verify to reduce code size */ #if 0 -static bool SCSI_verify10(uint8_t **data, uint32_t *len) +static bool SCSI_verify10(uint8_t busid, uint8_t **data, uint32_t *len) { /* Logical Block Address of First Block */ uint32_t lba = 0; uint32_t blk_num = 0; - if ((g_usbd_msc.cbw.CB[1] & 0x02U) == 0x00U) { + if ((g_usbd_msc[busid].cbw.CB[1] & 0x02U) == 0x00U) { return true; } - if (((g_usbd_msc.cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc.cbw.dDataLength == 0U)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if (((g_usbd_msc[busid].cbw.bmFlags & 0x80U) != 0x00U) || (g_usbd_msc[busid].cbw.dDataLength == 0U)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - if ((g_usbd_msc.cbw.CB[1] & 0x02U) == 0x02U) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDFIELDINCBA); + if ((g_usbd_msc[busid].cbw.CB[1] & 0x02U) == 0x02U) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDFIELDINCBA); return false; /* Error, Verify Mode Not supported*/ } - lba = GET_BE32(&g_usbd_msc.cbw.CB[2]); + lba = GET_BE32(&g_usbd_msc[busid].cbw.CB[2]); USB_LOG_DBG("lba: 0x%x\r\n", lba); - g_usbd_msc.scsi_blk_addr = lba * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]; + g_usbd_msc[busid].scsi_blk_addr = lba * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]; /* Number of Blocks to transfer */ - blk_num = GET_BE16(&g_usbd_msc.cbw.CB[7]); + blk_num = GET_BE16(&g_usbd_msc[busid].cbw.CB[7]); USB_LOG_DBG("num (block) : 0x%x\r\n", blk_num); - g_usbd_msc.scsi_blk_len = blk_num * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]; + g_usbd_msc[busid].scsi_blk_len = blk_num * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]; - if ((lba + blk_num) > g_usbd_msc.scsi_blk_nbr[g_usbd_msc.cbw.bLUN]) { + if ((lba + blk_num) > g_usbd_msc[busid].scsi_blk_nbr[g_usbd_msc[busid].cbw.bLUN]) { USB_LOG_ERR("LBA out of range\r\n"); return false; } - if (g_usbd_msc.cbw.dDataLength != g_usbd_msc.scsi_blk_len) { + if (g_usbd_msc[busid].cbw.dDataLength != g_usbd_msc[busid].scsi_blk_len) { return false; } - g_usbd_msc.stage = MSC_DATA_OUT; + g_usbd_msc[busid].stage = MSC_DATA_OUT; return true; } #endif -static bool SCSI_processRead(void) +static bool SCSI_processRead(uint8_t busid) { uint32_t transfer_len; - USB_LOG_DBG("read lba:%d\r\n", g_usbd_msc.start_sector); + USB_LOG_DBG("read lba:%d\r\n", g_usbd_msc[busid].start_sector); - transfer_len = MIN(g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN], CONFIG_USBDEV_MSC_MAX_BUFSIZE); + transfer_len = MIN(g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN], CONFIG_USBDEV_MSC_MAX_BUFSIZE); - if (usbd_msc_sector_read(g_usbd_msc.cbw.bLUN, g_usbd_msc.start_sector, g_usbd_msc.block_buffer, transfer_len) != 0) { - SCSI_SetSenseData(SCSI_KCQHE_UREINRESERVEDAREA); + if (usbd_msc_sector_read(busid, g_usbd_msc[busid].cbw.bLUN, g_usbd_msc[busid].start_sector, g_usbd_msc[busid].block_buffer, transfer_len) != 0) { + SCSI_SetSenseData(busid, SCSI_KCQHE_UREINRESERVEDAREA); return false; } - usbd_ep_start_write(mass_ep_data[MSD_IN_EP_IDX].ep_addr, g_usbd_msc.block_buffer, transfer_len); + usbd_ep_start_write(busid, mass_ep_data[busid][MSD_IN_EP_IDX].ep_addr, g_usbd_msc[busid].block_buffer, transfer_len); - g_usbd_msc.start_sector += (transfer_len / g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]); - g_usbd_msc.nsectors -= (transfer_len / g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]); - g_usbd_msc.csw.dDataResidue -= transfer_len; + g_usbd_msc[busid].start_sector += (transfer_len / g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]); + g_usbd_msc[busid].nsectors -= (transfer_len / g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]); + g_usbd_msc[busid].csw.dDataResidue -= transfer_len; - if (g_usbd_msc.nsectors == 0) { - g_usbd_msc.stage = MSC_SEND_CSW; + if (g_usbd_msc[busid].nsectors == 0) { + g_usbd_msc[busid].stage = MSC_SEND_CSW; } return true; } -static bool SCSI_processWrite(uint32_t nbytes) +static bool SCSI_processWrite(uint8_t busid, uint32_t nbytes) { uint32_t data_len = 0; - USB_LOG_DBG("write lba:%d\r\n", g_usbd_msc.start_sector); + USB_LOG_DBG("write lba:%d\r\n", g_usbd_msc[busid].start_sector); - if (usbd_msc_sector_write(g_usbd_msc.cbw.bLUN, g_usbd_msc.start_sector, g_usbd_msc.block_buffer, nbytes) != 0) { - SCSI_SetSenseData(SCSI_KCQHE_WRITEFAULT); + if (usbd_msc_sector_write(busid, g_usbd_msc[busid].cbw.bLUN, g_usbd_msc[busid].start_sector, g_usbd_msc[busid].block_buffer, nbytes) != 0) { + SCSI_SetSenseData(busid, SCSI_KCQHE_WRITEFAULT); return false; } - g_usbd_msc.start_sector += (nbytes / g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]); - g_usbd_msc.nsectors -= (nbytes / g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN]); - g_usbd_msc.csw.dDataResidue -= nbytes; + g_usbd_msc[busid].start_sector += (nbytes / g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]); + g_usbd_msc[busid].nsectors -= (nbytes / g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN]); + g_usbd_msc[busid].csw.dDataResidue -= nbytes; - if (g_usbd_msc.nsectors == 0) { - usbd_msc_send_csw(CSW_STATUS_CMD_PASSED); + if (g_usbd_msc[busid].nsectors == 0) { + usbd_msc_send_csw(busid, CSW_STATUS_CMD_PASSED); } else { - data_len = MIN(g_usbd_msc.nsectors * g_usbd_msc.scsi_blk_size[g_usbd_msc.cbw.bLUN], CONFIG_USBDEV_MSC_MAX_BUFSIZE); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, g_usbd_msc.block_buffer, data_len); + data_len = MIN(g_usbd_msc[busid].nsectors * g_usbd_msc[busid].scsi_blk_size[g_usbd_msc[busid].cbw.bLUN], CONFIG_USBDEV_MSC_MAX_BUFSIZE); + usbd_ep_start_read(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr, g_usbd_msc[busid].block_buffer, data_len); } return true; } -static bool SCSI_CBWDecode(uint32_t nbytes) +static bool SCSI_CBWDecode(uint8_t busid, uint32_t nbytes) { - uint8_t *buf2send = g_usbd_msc.block_buffer; + uint8_t *buf2send = g_usbd_msc[busid].block_buffer; uint32_t len2send = 0; bool ret = false; if (nbytes != sizeof(struct CBW)) { USB_LOG_ERR("size != sizeof(cbw)\r\n"); - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } - g_usbd_msc.csw.dTag = g_usbd_msc.cbw.dTag; - g_usbd_msc.csw.dDataResidue = g_usbd_msc.cbw.dDataLength; + g_usbd_msc[busid].csw.dTag = g_usbd_msc[busid].cbw.dTag; + g_usbd_msc[busid].csw.dDataResidue = g_usbd_msc[busid].cbw.dDataLength; - if ((g_usbd_msc.cbw.dSignature != MSC_CBW_Signature) || (g_usbd_msc.cbw.bCBLength < 1) || (g_usbd_msc.cbw.bCBLength > 16)) { - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); + if ((g_usbd_msc[busid].cbw.dSignature != MSC_CBW_Signature) || (g_usbd_msc[busid].cbw.bCBLength < 1) || (g_usbd_msc[busid].cbw.bCBLength > 16)) { + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); return false; } else { - USB_LOG_DBG("Decode CB:0x%02x\r\n", g_usbd_msc.cbw.CB[0]); - switch (g_usbd_msc.cbw.CB[0]) { + USB_LOG_DBG("Decode CB:0x%02x\r\n", g_usbd_msc[busid].cbw.CB[0]); + switch (g_usbd_msc[busid].cbw.CB[0]) { case SCSI_CMD_TESTUNITREADY: - ret = SCSI_testUnitReady(&buf2send, &len2send); + ret = SCSI_testUnitReady(busid, &buf2send, &len2send); break; case SCSI_CMD_REQUESTSENSE: - ret = SCSI_requestSense(&buf2send, &len2send); + ret = SCSI_requestSense(busid, &buf2send, &len2send); break; case SCSI_CMD_INQUIRY: - ret = SCSI_inquiry(&buf2send, &len2send); + ret = SCSI_inquiry(busid, &buf2send, &len2send); break; case SCSI_CMD_STARTSTOPUNIT: - ret = SCSI_startStopUnit(&buf2send, &len2send); + ret = SCSI_startStopUnit(busid, &buf2send, &len2send); break; case SCSI_CMD_PREVENTMEDIAREMOVAL: - ret = SCSI_preventAllowMediaRemoval(&buf2send, &len2send); + ret = SCSI_preventAllowMediaRemoval(busid, &buf2send, &len2send); break; case SCSI_CMD_MODESENSE6: - ret = SCSI_modeSense6(&buf2send, &len2send); + ret = SCSI_modeSense6(busid, &buf2send, &len2send); break; case SCSI_CMD_MODESENSE10: - ret = SCSI_modeSense10(&buf2send, &len2send); + ret = SCSI_modeSense10(busid, &buf2send, &len2send); break; case SCSI_CMD_READFORMATCAPACITIES: - ret = SCSI_readFormatCapacity(&buf2send, &len2send); + ret = SCSI_readFormatCapacity(busid, &buf2send, &len2send); break; case SCSI_CMD_READCAPACITY10: - ret = SCSI_readCapacity10(&buf2send, &len2send); + ret = SCSI_readCapacity10(busid, &buf2send, &len2send); break; case SCSI_CMD_READ10: - ret = SCSI_read10(NULL, 0); + ret = SCSI_read10(busid, NULL, 0); break; case SCSI_CMD_READ12: - ret = SCSI_read12(NULL, 0); + ret = SCSI_read12(busid, NULL, 0); break; case SCSI_CMD_WRITE10: - ret = SCSI_write10(NULL, 0); + ret = SCSI_write10(busid, NULL, 0); break; case SCSI_CMD_WRITE12: - ret = SCSI_write12(NULL, 0); + ret = SCSI_write12(busid, NULL, 0); break; case SCSI_CMD_VERIFY10: //ret = SCSI_verify10(NULL, 0); @@ -782,45 +782,45 @@ static bool SCSI_CBWDecode(uint32_t nbytes) break; default: - SCSI_SetSenseData(SCSI_KCQIR_INVALIDCOMMAND); - USB_LOG_WRN("unsupported cmd:0x%02x\r\n", g_usbd_msc.cbw.CB[0]); + SCSI_SetSenseData(busid, SCSI_KCQIR_INVALIDCOMMAND); + USB_LOG_WRN("unsupported cmd:0x%02x\r\n", g_usbd_msc[busid].cbw.CB[0]); ret = false; break; } } if (ret) { - if (g_usbd_msc.stage == MSC_READ_CBW) { + if (g_usbd_msc[busid].stage == MSC_READ_CBW) { if (len2send) { USB_LOG_DBG("Send info len:%d\r\n", len2send); - usbd_msc_send_info(buf2send, len2send); + usbd_msc_send_info(busid, buf2send, len2send); } else { - usbd_msc_send_csw(CSW_STATUS_CMD_PASSED); + usbd_msc_send_csw(busid, CSW_STATUS_CMD_PASSED); } } } return ret; } -void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes) +void mass_storage_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { - switch (g_usbd_msc.stage) { + switch (g_usbd_msc[busid].stage) { case MSC_READ_CBW: - if (SCSI_CBWDecode(nbytes) == false) { - USB_LOG_ERR("Command:0x%02x decode err\r\n", g_usbd_msc.cbw.CB[0]); - usbd_msc_bot_abort(); + if (SCSI_CBWDecode(busid, nbytes) == false) { + USB_LOG_ERR("Command:0x%02x decode err\r\n", g_usbd_msc[busid].cbw.CB[0]); + usbd_msc_bot_abort(busid); return; } break; case MSC_DATA_OUT: - switch (g_usbd_msc.cbw.CB[0]) { + switch (g_usbd_msc[busid].cbw.CB[0]) { case SCSI_CMD_WRITE10: case SCSI_CMD_WRITE12: #ifdef CONFIG_USBDEV_MSC_THREAD - g_usbd_msc.nbytes = nbytes; - usb_osal_mq_send(g_usbd_msc.usbd_msc_mq, MSC_DATA_OUT); + g_usbd_msc[busid].nbytes = nbytes; + usb_osal_mq_send(g_usbd_msc[busid].usbd_msc_mq, MSC_DATA_OUT); #else - if (SCSI_processWrite(nbytes) == false) { - usbd_msc_send_csw(CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ + if (SCSI_processWrite(busid, nbytes) == false) { + usbd_msc_send_csw(busid, CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ } #endif break; @@ -833,18 +833,18 @@ void mass_storage_bulk_out(uint8_t ep, uint32_t nbytes) } } -void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes) +void mass_storage_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { - switch (g_usbd_msc.stage) { + switch (g_usbd_msc[busid].stage) { case MSC_DATA_IN: - switch (g_usbd_msc.cbw.CB[0]) { + switch (g_usbd_msc[busid].cbw.CB[0]) { case SCSI_CMD_READ10: case SCSI_CMD_READ12: #ifdef CONFIG_USBDEV_MSC_THREAD - usb_osal_mq_send(g_usbd_msc.usbd_msc_mq, MSC_DATA_IN); + usb_osal_mq_send(g_usbd_msc[busid].usbd_msc_mq, MSC_DATA_IN); #else - if (SCSI_processRead() == false) { - usbd_msc_send_csw(CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ + if (SCSI_processRead(busid) == false) { + usbd_msc_send_csw(busid, CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ return; } #endif @@ -855,14 +855,14 @@ void mass_storage_bulk_in(uint8_t ep, uint32_t nbytes) break; /*the device has to send a CSW*/ case MSC_SEND_CSW: - usbd_msc_send_csw(CSW_STATUS_CMD_PASSED); + usbd_msc_send_csw(busid, CSW_STATUS_CMD_PASSED); break; /*the host has received the CSW*/ case MSC_WAIT_CSW: - g_usbd_msc.stage = MSC_READ_CBW; + g_usbd_msc[busid].stage = MSC_READ_CBW; USB_LOG_DBG("Start reading cbw\r\n"); - usbd_ep_start_read(mass_ep_data[MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc.cbw, USB_SIZEOF_MSC_CBW); + usbd_ep_start_read(busid, mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr, (uint8_t *)&g_usbd_msc[busid].cbw, USB_SIZEOF_MSC_CBW); break; default: @@ -875,20 +875,21 @@ static void usbdev_msc_thread(void *argument) { uintptr_t event; int ret; + uint8_t busid = (uint8_t)argument; while (1) { - ret = usb_osal_mq_recv(g_usbd_msc.usbd_msc_mq, (uintptr_t *)&event, USB_OSAL_WAITING_FOREVER); + ret = usb_osal_mq_recv(g_usbd_msc[busid].usbd_msc_mq, (uintptr_t *)&event, USB_OSAL_WAITING_FOREVER); if (ret < 0) { continue; } USB_LOG_DBG("%d\r\n", event); if (event == MSC_DATA_OUT) { - if (SCSI_processWrite(g_usbd_msc.nbytes) == false) { - usbd_msc_send_csw(CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ + if (SCSI_processWrite(busid, g_usbd_msc[busid].nbytes) == false) { + usbd_msc_send_csw(busid, CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ } } else if (event == MSC_DATA_IN) { - if (SCSI_processRead() == false) { - usbd_msc_send_csw(CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ + if (SCSI_processRead(busid) == false) { + usbd_msc_send_csw(busid, CSW_STATUS_CMD_FAILED); /* send fail status to host,and the host will retry*/ } } else { } @@ -896,28 +897,28 @@ static void usbdev_msc_thread(void *argument) } #endif -struct usbd_interface *usbd_msc_init_intf(struct usbd_interface *intf, const uint8_t out_ep, const uint8_t in_ep) +struct usbd_interface *usbd_msc_init_intf(uint8_t busid, struct usbd_interface *intf, const uint8_t out_ep, const uint8_t in_ep) { intf->class_interface_handler = msc_storage_class_interface_request_handler; intf->class_endpoint_handler = NULL; intf->vendor_handler = NULL; intf->notify_handler = msc_storage_notify_handler; - 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; + mass_ep_data[busid][MSD_OUT_EP_IDX].ep_addr = out_ep; + mass_ep_data[busid][MSD_OUT_EP_IDX].ep_cb = mass_storage_bulk_out; + mass_ep_data[busid][MSD_IN_EP_IDX].ep_addr = in_ep; + mass_ep_data[busid][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]); + usbd_add_endpoint(busid, &mass_ep_data[busid][MSD_OUT_EP_IDX]); + usbd_add_endpoint(busid, &mass_ep_data[busid][MSD_IN_EP_IDX]); - memset((uint8_t *)&g_usbd_msc, 0, sizeof(struct usbd_msc_priv)); + memset((uint8_t *)&g_usbd_msc[busid], 0, sizeof(struct usbd_msc_priv)); - usdb_msc_set_max_lun(); - for (uint8_t i = 0u; i <= g_usbd_msc.max_lun; i++) { - usbd_msc_get_cap(i, &g_usbd_msc.scsi_blk_nbr[i], &g_usbd_msc.scsi_blk_size[i]); + usdb_msc_set_max_lun(busid); + for (uint8_t i = 0u; i <= g_usbd_msc[busid].max_lun; i++) { + usbd_msc_get_cap(busid, i, &g_usbd_msc[busid].scsi_blk_nbr[i], &g_usbd_msc[busid].scsi_blk_size[i]); - if (g_usbd_msc.scsi_blk_size[i] > CONFIG_USBDEV_MSC_MAX_BUFSIZE) { + if (g_usbd_msc[busid].scsi_blk_size[i] > CONFIG_USBDEV_MSC_MAX_BUFSIZE) { USB_LOG_ERR("msc block buffer overflow\r\n"); return NULL; } @@ -926,12 +927,12 @@ struct usbd_interface *usbd_msc_init_intf(struct usbd_interface *intf, const uin return intf; } -void usbd_msc_set_readonly(bool readonly) +void usbd_msc_set_readonly(uint8_t busid, bool readonly) { - g_usbd_msc.readonly = readonly; + g_usbd_msc[busid].readonly = readonly; } -bool usbd_msc_set_popup(void) +bool usbd_msc_set_popup(uint8_t busid) { - return g_usbd_msc.popup; + return g_usbd_msc[busid].popup; } diff --git a/class/msc/usbd_msc.h b/class/msc/usbd_msc.h index 43fa8ba8..c71f64a2 100644 --- a/class/msc/usbd_msc.h +++ b/class/msc/usbd_msc.h @@ -14,16 +14,16 @@ extern "C" { #endif /* Init msc interface driver */ -struct usbd_interface *usbd_msc_init_intf(struct usbd_interface *intf, +struct usbd_interface *usbd_msc_init_intf(uint8_t busid, struct usbd_interface *intf, const uint8_t out_ep, const uint8_t in_ep); -void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint32_t *block_size); -int usbd_msc_sector_read(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length); -int usbd_msc_sector_write(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length); +void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size); +int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length); +int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length); -void usbd_msc_set_readonly(bool readonly); -bool usbd_msc_set_popup(void); +void usbd_msc_set_readonly(uint8_t busid, bool readonly); +bool usbd_msc_set_popup(uint8_t busid); #ifdef __cplusplus } diff --git a/class/template/usbd_xxx.c b/class/template/usbd_xxx.c index 68348ff9..aa4bc01b 100644 --- a/class/template/usbd_xxx.c +++ b/class/template/usbd_xxx.c @@ -1,7 +1,7 @@ #include "usbd_core.h" #include "usbd_xxx.h" -static int xxx_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int xxx_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_WRN("XXX Class request: " "bRequest 0x%02x\r\n", @@ -16,7 +16,7 @@ static int xxx_class_interface_request_handler(struct usb_setup_packet *setup, u return 0; } -static void xxx_notify_handler(uint8_t event, void *arg) +static void xxx_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: @@ -28,7 +28,7 @@ static void xxx_notify_handler(uint8_t event, void *arg) } } -struct usbd_interface *usbd_xxx_init_intf(struct usbd_interface *intf) +struct usbd_interface *usbd_xxx_init_intf(uint8_t busid, struct usbd_interface *intf) { intf->class_interface_handler = xxx_class_interface_request_handler; intf->class_endpoint_handler = NULL; diff --git a/class/template/usbd_xxx.h b/class/template/usbd_xxx.h index e77856e8..8230c302 100644 --- a/class/template/usbd_xxx.h +++ b/class/template/usbd_xxx.h @@ -7,7 +7,7 @@ extern "C" { #endif -struct usbd_interface *usbd_xxx_init_intf(struct usbd_interface *intf); +struct usbd_interface *usbd_xxx_init_intf(uint8_t busid, struct usbd_interface *intf); #ifdef __cplusplus } diff --git a/class/video/usbd_video.c b/class/video/usbd_video.c index 0289ed7e..07059ee0 100644 --- a/class/video/usbd_video.c +++ b/class/video/usbd_video.c @@ -18,9 +18,9 @@ struct usbd_video_priv { uint8_t power_mode; uint8_t error_code; struct video_entity_info info[3]; -} g_usbd_video; +} g_usbd_video[CONFIG_USBDEV_MAX_BUS]; -static int usbd_video_control_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_video_control_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t control_selector = (uint8_t)(setup->wValue >> 8); @@ -60,13 +60,13 @@ static int usbd_video_control_request_handler(struct usb_setup_packet *setup, ui return 0; } -static int usbd_video_control_unit_terminal_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_video_control_unit_terminal_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t entity_id = (uint8_t)(setup->wIndex >> 8); uint8_t control_selector = (uint8_t)(setup->wValue >> 8); for (uint8_t i = 0; i < 3; i++) { - struct video_entity_info *entity_info = &g_usbd_video.info[i]; + struct video_entity_info *entity_info = &g_usbd_video[busid].info[i]; if (entity_info->bEntityId == entity_id) { switch (entity_info->bDescriptorSubtype) { case VIDEO_VC_HEADER_DESCRIPTOR_SUBTYPE: @@ -546,7 +546,7 @@ static int usbd_video_control_unit_terminal_request_handler(struct usb_setup_pac } break; default: - g_usbd_video.error_code = 0x06; + g_usbd_video[busid].error_code = 0x06; USB_LOG_WRN("Unhandled Video Class control selector 0x%02x\r\n", control_selector); return -1; } @@ -564,7 +564,7 @@ static int usbd_video_control_unit_terminal_request_handler(struct usb_setup_pac return 0; } -static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_video_stream_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t control_selector = (uint8_t)(setup->wValue >> 8); @@ -572,10 +572,10 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_PROBE_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_SET_CUR: - //memcpy((uint8_t *)&g_usbd_video.probe, *data, setup->wLength); + //memcpy((uint8_t *)&g_usbd_video[busid].probe, *data, setup->wLength); break; case VIDEO_REQUEST_GET_CUR: - memcpy(*data, (uint8_t *)&g_usbd_video.probe, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video[busid].probe, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; @@ -583,7 +583,7 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_REQUEST_GET_MAX: case VIDEO_REQUEST_GET_RES: case VIDEO_REQUEST_GET_DEF: - memcpy(*data, (uint8_t *)&g_usbd_video.probe, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video[busid].probe, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; case VIDEO_REQUEST_GET_LEN: @@ -604,17 +604,17 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_COMMIT_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_SET_CUR: - //memcpy((uint8_t *)&g_usbd_video.commit, *data, setup->wLength); + //memcpy((uint8_t *)&g_usbd_video[busid].commit, *data, setup->wLength); break; case VIDEO_REQUEST_GET_CUR: - memcpy(*data, (uint8_t *)&g_usbd_video.commit, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video[busid].commit, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; case VIDEO_REQUEST_GET_MIN: case VIDEO_REQUEST_GET_MAX: case VIDEO_REQUEST_GET_RES: case VIDEO_REQUEST_GET_DEF: - memcpy(*data, (uint8_t *)&g_usbd_video.commit, setup->wLength); + memcpy(*data, (uint8_t *)&g_usbd_video[busid].commit, setup->wLength); *len = sizeof(struct video_probe_and_commit_controls); break; @@ -636,7 +636,7 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin case VIDEO_VS_STREAM_ERROR_CODE_CONTROL: switch (setup->bRequest) { case VIDEO_REQUEST_GET_CUR: - (*data)[0] = g_usbd_video.error_code; + (*data)[0] = g_usbd_video[busid].error_code; *len = 1; break; case VIDEO_REQUEST_GET_INFO: @@ -655,7 +655,7 @@ static int usbd_video_stream_request_handler(struct usb_setup_packet *setup, uin return 0; } -static int video_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int video_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { USB_LOG_DBG("Video Class request: " "bRequest 0x%02x\r\n", @@ -666,30 +666,30 @@ static int video_class_interface_request_handler(struct usb_setup_packet *setup, if (intf_num == 0) { /* Video Control Interface */ if (entity_id == 0) { - return usbd_video_control_request_handler(setup, data, len); /* Interface Control Requests */ + return usbd_video_control_request_handler(busid, setup, data, len); /* Interface Control Requests */ } else { - return usbd_video_control_unit_terminal_request_handler(setup, data, len); /* Unit and Terminal Requests */ + return usbd_video_control_unit_terminal_request_handler(busid, setup, data, len); /* Unit and Terminal Requests */ } } else if (intf_num == 1) { /* Video Stream Inteface */ - return usbd_video_stream_request_handler(setup, data, len); /* Interface Stream Requests */ + return usbd_video_stream_request_handler(busid, setup, data, len); /* Interface Stream Requests */ } return -1; } -static void video_notify_handler(uint8_t event, void *arg) +static void video_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: - g_usbd_video.error_code = 0; - g_usbd_video.power_mode = 0; + g_usbd_video[busid].error_code = 0; + g_usbd_video[busid].power_mode = 0; break; case USBD_EVENT_SET_INTERFACE: { struct usb_interface_descriptor *intf = (struct usb_interface_descriptor *)arg; if (intf->bAlternateSetting == 1) { - usbd_video_open(intf->bInterfaceNumber); + usbd_video_open(busid, intf->bInterfaceNumber); } else { - usbd_video_close(intf->bInterfaceNumber); + usbd_video_close(busid, intf->bInterfaceNumber); } } @@ -699,46 +699,46 @@ static void video_notify_handler(uint8_t event, void *arg) } } -void usbd_video_probe_and_commit_controls_init(uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize) +void usbd_video_probe_and_commit_controls_init(uint8_t busid, uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize) { - g_usbd_video.probe.hintUnion.bmHint = 0x01; - g_usbd_video.probe.hintUnion1.bmHint = 0; - g_usbd_video.probe.bFormatIndex = 1; - g_usbd_video.probe.bFrameIndex = 1; - g_usbd_video.probe.dwFrameInterval = dwFrameInterval; - g_usbd_video.probe.wKeyFrameRate = 0; - g_usbd_video.probe.wPFrameRate = 0; - g_usbd_video.probe.wCompQuality = 0; - g_usbd_video.probe.wCompWindowSize = 0; - g_usbd_video.probe.wDelay = 0; - g_usbd_video.probe.dwMaxVideoFrameSize = dwMaxVideoFrameSize; - g_usbd_video.probe.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; - g_usbd_video.probe.dwClockFrequency = 0; - g_usbd_video.probe.bmFramingInfo = 0; - g_usbd_video.probe.bPreferedVersion = 0; - g_usbd_video.probe.bMinVersion = 0; - g_usbd_video.probe.bMaxVersion = 0; + g_usbd_video[busid].probe.hintUnion.bmHint = 0x01; + g_usbd_video[busid].probe.hintUnion1.bmHint = 0; + g_usbd_video[busid].probe.bFormatIndex = 1; + g_usbd_video[busid].probe.bFrameIndex = 1; + g_usbd_video[busid].probe.dwFrameInterval = dwFrameInterval; + g_usbd_video[busid].probe.wKeyFrameRate = 0; + g_usbd_video[busid].probe.wPFrameRate = 0; + g_usbd_video[busid].probe.wCompQuality = 0; + g_usbd_video[busid].probe.wCompWindowSize = 0; + g_usbd_video[busid].probe.wDelay = 0; + g_usbd_video[busid].probe.dwMaxVideoFrameSize = dwMaxVideoFrameSize; + g_usbd_video[busid].probe.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; + g_usbd_video[busid].probe.dwClockFrequency = 0; + g_usbd_video[busid].probe.bmFramingInfo = 0; + g_usbd_video[busid].probe.bPreferedVersion = 0; + g_usbd_video[busid].probe.bMinVersion = 0; + g_usbd_video[busid].probe.bMaxVersion = 0; - g_usbd_video.commit.hintUnion.bmHint = 0x01; - g_usbd_video.commit.hintUnion1.bmHint = 0; - g_usbd_video.commit.bFormatIndex = 1; - g_usbd_video.commit.bFrameIndex = 1; - g_usbd_video.commit.dwFrameInterval = dwFrameInterval; - g_usbd_video.commit.wKeyFrameRate = 0; - g_usbd_video.commit.wPFrameRate = 0; - g_usbd_video.commit.wCompQuality = 0; - g_usbd_video.commit.wCompWindowSize = 0; - g_usbd_video.commit.wDelay = 0; - g_usbd_video.commit.dwMaxVideoFrameSize = dwMaxVideoFrameSize; - g_usbd_video.commit.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; - g_usbd_video.commit.dwClockFrequency = 0; - g_usbd_video.commit.bmFramingInfo = 0; - g_usbd_video.commit.bPreferedVersion = 0; - g_usbd_video.commit.bMinVersion = 0; - g_usbd_video.commit.bMaxVersion = 0; + g_usbd_video[busid].commit.hintUnion.bmHint = 0x01; + g_usbd_video[busid].commit.hintUnion1.bmHint = 0; + g_usbd_video[busid].commit.bFormatIndex = 1; + g_usbd_video[busid].commit.bFrameIndex = 1; + g_usbd_video[busid].commit.dwFrameInterval = dwFrameInterval; + g_usbd_video[busid].commit.wKeyFrameRate = 0; + g_usbd_video[busid].commit.wPFrameRate = 0; + g_usbd_video[busid].commit.wCompQuality = 0; + g_usbd_video[busid].commit.wCompWindowSize = 0; + g_usbd_video[busid].commit.wDelay = 0; + g_usbd_video[busid].commit.dwMaxVideoFrameSize = dwMaxVideoFrameSize; + g_usbd_video[busid].commit.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize; + g_usbd_video[busid].commit.dwClockFrequency = 0; + g_usbd_video[busid].commit.bmFramingInfo = 0; + g_usbd_video[busid].commit.bPreferedVersion = 0; + g_usbd_video[busid].commit.bMinVersion = 0; + g_usbd_video[busid].commit.bMaxVersion = 0; } -struct usbd_interface *usbd_video_init_intf(struct usbd_interface *intf, +struct usbd_interface *usbd_video_init_intf(uint8_t busid, struct usbd_interface *intf, uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize) @@ -748,39 +748,39 @@ struct usbd_interface *usbd_video_init_intf(struct usbd_interface *intf, intf->vendor_handler = NULL; intf->notify_handler = video_notify_handler; - g_usbd_video.info[0].bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE; - g_usbd_video.info[0].bEntityId = 0x01; - g_usbd_video.info[0].wTerminalType = VIDEO_ITT_CAMERA; - g_usbd_video.info[1].bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE; - g_usbd_video.info[1].bEntityId = 0x03; - g_usbd_video.info[1].wTerminalType = 0x00; - g_usbd_video.info[2].bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE; - g_usbd_video.info[2].bEntityId = 0x02; - g_usbd_video.info[2].wTerminalType = 0x00; + g_usbd_video[busid].info[0].bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE; + g_usbd_video[busid].info[0].bEntityId = 0x01; + g_usbd_video[busid].info[0].wTerminalType = VIDEO_ITT_CAMERA; + g_usbd_video[busid].info[1].bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE; + g_usbd_video[busid].info[1].bEntityId = 0x03; + g_usbd_video[busid].info[1].wTerminalType = 0x00; + g_usbd_video[busid].info[2].bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE; + g_usbd_video[busid].info[2].bEntityId = 0x02; + g_usbd_video[busid].info[2].wTerminalType = 0x00; - usbd_video_probe_and_commit_controls_init(dwFrameInterval, dwMaxVideoFrameSize, dwMaxPayloadTransferSize); + usbd_video_probe_and_commit_controls_init(busid, 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 usbd_video_mjpeg_payload_fill(uint8_t busid, uint8_t *input, uint32_t input_len, uint8_t *output, uint32_t *out_len) { uint32_t packets; uint32_t last_packet_size; uint32_t picture_pos = 0; static uint8_t uvc_header[2] = { 0x02, 0x80 }; - packets = (input_len + (g_usbd_video.probe.dwMaxPayloadTransferSize - 2) ) / (g_usbd_video.probe.dwMaxPayloadTransferSize - 2); - last_packet_size = input_len - ((packets - 1) * (g_usbd_video.probe.dwMaxPayloadTransferSize - 2)); + packets = (input_len + (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2) ) / (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2); + last_packet_size = input_len - ((packets - 1) * (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2)); for (size_t i = 0; i < packets; i++) { - output[g_usbd_video.probe.dwMaxPayloadTransferSize * i] = uvc_header[0]; - output[g_usbd_video.probe.dwMaxPayloadTransferSize * i + 1] = uvc_header[1]; + output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i] = uvc_header[0]; + output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i + 1] = uvc_header[1]; if (i == (packets - 1)) { - memcpy(&output[2 + g_usbd_video.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], last_packet_size); - output[g_usbd_video.probe.dwMaxPayloadTransferSize * i + 1] |= (1 << 1); + memcpy(&output[2 + g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i], &input[picture_pos], last_packet_size); + output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i + 1] |= (1 << 1); } else { - memcpy(&output[2 + g_usbd_video.probe.dwMaxPayloadTransferSize * i], &input[picture_pos], g_usbd_video.probe.dwMaxPayloadTransferSize - 2); - picture_pos += g_usbd_video.probe.dwMaxPayloadTransferSize - 2; + memcpy(&output[2 + g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i], &input[picture_pos], g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2); + picture_pos += g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2; } } uvc_header[1] ^= 1; diff --git a/class/video/usbd_video.h b/class/video/usbd_video.h index 75d7f9ed..5044af69 100644 --- a/class/video/usbd_video.h +++ b/class/video/usbd_video.h @@ -13,14 +13,14 @@ extern "C" { #endif /* Init video interface driver */ -struct usbd_interface *usbd_video_init_intf(struct usbd_interface *intf, +struct usbd_interface *usbd_video_init_intf(uint8_t busid, struct usbd_interface *intf, uint32_t dwFrameInterval, uint32_t dwMaxVideoFrameSize, uint32_t dwMaxPayloadTransferSize); -void usbd_video_open(uint8_t intf); -void usbd_video_close(uint8_t intf); -uint32_t usbd_video_mjpeg_payload_fill(uint8_t *input, uint32_t input_len, uint8_t *output, uint32_t *out_len); +void usbd_video_open(uint8_t busid, uint8_t intf); +void usbd_video_close(uint8_t busid, uint8_t intf); +uint32_t usbd_video_mjpeg_payload_fill(uint8_t busid, uint8_t *input, uint32_t input_len, uint8_t *output, uint32_t *out_len); #ifdef __cplusplus } diff --git a/class/wireless/usbd_rndis.c b/class/wireless/usbd_rndis.c index ee20c5d4..e030e16b 100644 --- a/class/wireless/usbd_rndis.c +++ b/class/wireless/usbd_rndis.c @@ -105,10 +105,10 @@ static void rndis_notify_rsp(void) { memset(NOTIFY_RESPONSE_AVAILABLE, 0, 8); NOTIFY_RESPONSE_AVAILABLE[0] = 0x01; - usbd_ep_start_write(rndis_ep_data[RNDIS_INT_EP_IDX].ep_addr, NOTIFY_RESPONSE_AVAILABLE, 8); + usbd_ep_start_write(0, rndis_ep_data[RNDIS_INT_EP_IDX].ep_addr, NOTIFY_RESPONSE_AVAILABLE, 8); } -static int rndis_class_interface_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int rndis_class_interface_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { switch (setup->bRequest) { case CDC_REQUEST_SEND_ENCAPSULATED_COMMAND: @@ -426,7 +426,7 @@ static int rndis_keepalive_cmd_handler(uint8_t *data, uint32_t len) return 0; } -static void rndis_notify_handler(uint8_t event, void *arg) +static void rndis_notify_handler(uint8_t busid, uint8_t event, void *arg) { switch (event) { case USBD_EVENT_RESET: @@ -436,7 +436,7 @@ static void rndis_notify_handler(uint8_t event, void *arg) g_rndis_rx_data_length = 0; g_rndis_tx_data_length = 0; g_usbd_rndis.link_status = NDIS_MEDIA_STATE_CONNECTED; - usbd_ep_start_read(rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); + usbd_ep_start_read(0, rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); break; default: @@ -444,14 +444,14 @@ static void rndis_notify_handler(uint8_t event, void *arg) } } -void rndis_bulk_out(uint8_t ep, uint32_t nbytes) +void rndis_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { rndis_data_packet_t *hdr; hdr = (rndis_data_packet_t *)g_rndis_rx_buffer; g_rndis_rx_data_buffer = g_rndis_rx_buffer; if ((hdr->MessageType != NDIS_PACKET_TYPE_DIRECTED) || (nbytes != hdr->MessageLength)) { - usbd_ep_start_read(rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); + usbd_ep_start_read(0, rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); return; } @@ -462,17 +462,17 @@ void rndis_bulk_out(uint8_t ep, uint32_t nbytes) usbd_rndis_data_recv_done(); } -void rndis_bulk_in(uint8_t ep, uint32_t nbytes) +void rndis_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { if ((nbytes % RNDIS_MAX_PACKET_SIZE) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(ep, NULL, 0); + usbd_ep_start_write(0, ep, NULL, 0); } else { g_rndis_tx_data_length = 0; } } -void rndis_int_in(uint8_t ep, uint32_t nbytes) +void rndis_int_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { //USB_LOG_DBG("len:%d\r\n", nbytes); } @@ -496,7 +496,7 @@ struct pbuf *usbd_rndis_eth_rx(void) USB_LOG_DBG("rxlen:%d\r\n", g_rndis_rx_data_length); g_rndis_rx_data_length = 0; - usbd_ep_start_read(rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); + usbd_ep_start_read(0, rndis_ep_data[RNDIS_OUT_EP_IDX].ep_addr, g_rndis_rx_buffer, sizeof(g_rndis_rx_buffer)); return p; } @@ -536,7 +536,7 @@ int usbd_rndis_eth_tx(struct pbuf *p) g_rndis_tx_data_length = sizeof(rndis_data_packet_t) + p->tot_len; USB_LOG_DBG("txlen:%d\r\n", g_rndis_tx_data_length); - return usbd_ep_start_write(rndis_ep_data[RNDIS_IN_EP_IDX].ep_addr, g_rndis_tx_buffer, g_rndis_tx_data_length); + return usbd_ep_start_write(0, rndis_ep_data[RNDIS_IN_EP_IDX].ep_addr, g_rndis_tx_buffer, g_rndis_tx_data_length); } #endif struct usbd_interface *usbd_rndis_init_intf(struct usbd_interface *intf, @@ -557,9 +557,9 @@ struct usbd_interface *usbd_rndis_init_intf(struct usbd_interface *intf, rndis_ep_data[RNDIS_INT_EP_IDX].ep_addr = int_ep; rndis_ep_data[RNDIS_INT_EP_IDX].ep_cb = rndis_int_in; - usbd_add_endpoint(&rndis_ep_data[RNDIS_OUT_EP_IDX]); - usbd_add_endpoint(&rndis_ep_data[RNDIS_IN_EP_IDX]); - usbd_add_endpoint(&rndis_ep_data[RNDIS_INT_EP_IDX]); + usbd_add_endpoint(0, &rndis_ep_data[RNDIS_OUT_EP_IDX]); + usbd_add_endpoint(0, &rndis_ep_data[RNDIS_IN_EP_IDX]); + usbd_add_endpoint(0, &rndis_ep_data[RNDIS_INT_EP_IDX]); intf->class_interface_handler = rndis_class_interface_request_handler; intf->class_endpoint_handler = NULL; diff --git a/common/usb_dc.h b/common/usb_dc.h index fe4b597b..3e195bc2 100644 --- a/common/usb_dc.h +++ b/common/usb_dc.h @@ -16,13 +16,13 @@ extern "C" { * @brief init device controller registers. * @return On success will return 0, and others indicate fail. */ -int usb_dc_init(void); +int usb_dc_init(uint8_t busid); /** * @brief deinit device controller registers. * @return On success will return 0, and others indicate fail. */ -int usb_dc_deinit(void); +int usb_dc_deinit(uint8_t busid); /** * @brief Set USB device address @@ -31,7 +31,7 @@ int usb_dc_deinit(void); * * @return On success will return 0, and others indicate fail. */ -int usbd_set_address(const uint8_t addr); +int usbd_set_address(uint8_t busid, const uint8_t addr); /** * @brief Get USB device speed @@ -40,7 +40,7 @@ int usbd_set_address(const uint8_t addr); * * @return port speed, USB_SPEED_LOW or USB_SPEED_FULL or USB_SPEED_HIGH */ -uint8_t usbd_get_port_speed(const uint8_t port); +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port); /** * @brief configure and enable endpoint. @@ -49,7 +49,7 @@ uint8_t usbd_get_port_speed(const uint8_t port); * * @return On success will return 0, and others indicate fail. */ -int usbd_ep_open(const struct usb_endpoint_descriptor *ep); +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep); /** * @brief Disable the selected endpoint @@ -58,7 +58,7 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep); * * @return On success will return 0, and others indicate fail. */ -int usbd_ep_close(const uint8_t ep); +int usbd_ep_close(uint8_t busid, const uint8_t ep); /** * @brief Set stall condition for the selected endpoint @@ -68,7 +68,7 @@ int usbd_ep_close(const uint8_t ep); * * @return On success will return 0, and others indicate fail. */ -int usbd_ep_set_stall(const uint8_t ep); +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep); /** * @brief Clear stall condition for the selected endpoint @@ -78,7 +78,7 @@ int usbd_ep_set_stall(const uint8_t ep); * * @return On success will return 0, and others indicate fail. */ -int usbd_ep_clear_stall(const uint8_t ep); +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep); /** * @brief Check if the selected endpoint is stalled @@ -89,7 +89,7 @@ int usbd_ep_clear_stall(const uint8_t ep); * * @return On success will return 0, and others indicate fail. */ -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled); +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled); /** * @brief Setup in ep transfer setting and start transfer. @@ -108,7 +108,7 @@ int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled); * be zero for a zero length status packet. * @return 0 on success, negative errno code on fail. */ -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len); +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len); /** * @brief Setup out ep transfer setting and start transfer. @@ -127,40 +127,40 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len * * @return 0 on success, negative errno code on fail. */ -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len); +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len); /* usb dcd irq callback */ /** * @brief Usb connect irq callback. */ -void usbd_event_connect_handler(void); +void usbd_event_connect_handler(uint8_t busid); /** * @brief Usb disconnect irq callback. */ -void usbd_event_disconnect_handler(void); +void usbd_event_disconnect_handler(uint8_t busid); /** * @brief Usb resume irq callback. */ -void usbd_event_resume_handler(void); +void usbd_event_resume_handler(uint8_t busid); /** * @brief Usb suspend irq callback. */ -void usbd_event_suspend_handler(void); +void usbd_event_suspend_handler(uint8_t busid); /** * @brief Usb reset irq callback. */ -void usbd_event_reset_handler(void); +void usbd_event_reset_handler(uint8_t busid); /** * @brief Usb setup packet recv irq callback. * @param[in] psetup setup packet. */ -void usbd_event_ep0_setup_complete_handler(uint8_t *psetup); +void usbd_event_ep0_setup_complete_handler(uint8_t busid, uint8_t *psetup); /** * @brief In ep transfer complete irq callback. @@ -168,7 +168,7 @@ void usbd_event_ep0_setup_complete_handler(uint8_t *psetup); * listed in the device configuration table * @param[in] nbytes How many nbytes have transferred. */ -void usbd_event_ep_in_complete_handler(uint8_t ep, uint32_t nbytes); +void usbd_event_ep_in_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes); /** * @brief Out ep transfer complete irq callback. @@ -176,7 +176,7 @@ void usbd_event_ep_in_complete_handler(uint8_t ep, uint32_t nbytes); * listed in the device configuration table * @param[in] nbytes How many nbytes have transferred. */ -void usbd_event_ep_out_complete_handler(uint8_t ep, uint32_t nbytes); +void usbd_event_ep_out_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes); #ifdef __cplusplus } diff --git a/core/usbd_core.c b/core/usbd_core.c index dc7da00c..c02f0e5e 100644 --- a/core/usbd_core.c +++ b/core/usbd_core.c @@ -1,6 +1,4 @@ /* - * Copyright (C) 2006 Bertrik Sikken (bertrik@sikken.nl) - * Copyright (c) 2016 Intel Corporation * Copyright (c) 2022, sakumisu * * SPDX-License-Identifier: Apache-2.0 @@ -63,9 +61,11 @@ USB_NOCACHE_RAM_SECTION struct usbd_core_priv { struct usbd_tx_rx_msg tx_msg[USB_EP_IN_NUM]; struct usbd_tx_rx_msg rx_msg[USB_EP_OUT_NUM]; -} g_usbd_core; -static void usbd_class_event_notify_handler(uint8_t event, void *arg); + void (*event_handler)(uint8_t event); +} g_usbd_core[CONFIG_USBDEV_MAX_BUS]; + +static void usbd_class_event_notify_handler(uint8_t busid, uint8_t event, void *arg); static void usbd_print_setup(struct usb_setup_packet *setup) { @@ -78,9 +78,9 @@ static void usbd_print_setup(struct usb_setup_packet *setup) setup->wLength); } -static bool is_device_configured(void) +static bool is_device_configured(uint8_t busid) { - return (g_usbd_core.configuration != 0); + return (g_usbd_core[busid].configuration != 0); } /** @@ -93,14 +93,14 @@ static bool is_device_configured(void) * * @return true if successfully configured and enabled */ -static bool usbd_set_endpoint(const struct usb_endpoint_descriptor *ep) +static bool usbd_set_endpoint(uint8_t busid, const struct usb_endpoint_descriptor *ep) { USB_LOG_INFO("Open ep:0x%02x type:%u mps:%u\r\n", ep->bEndpointAddress, USB_GET_ENDPOINT_TYPE(ep->bmAttributes), USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize)); - return usbd_ep_open(ep) == 0 ? true : false; + return usbd_ep_open(busid, ep) == 0 ? true : false; } /** * @brief Disable endpoint for transferring data @@ -112,13 +112,13 @@ static bool usbd_set_endpoint(const struct usb_endpoint_descriptor *ep) * * @return true if successfully deconfigured and disabled */ -static bool usbd_reset_endpoint(const struct usb_endpoint_descriptor *ep) +static bool usbd_reset_endpoint(uint8_t busid, const struct usb_endpoint_descriptor *ep) { USB_LOG_INFO("Close ep:0x%02x type:%u\r\n", ep->bEndpointAddress, USB_GET_ENDPOINT_TYPE(ep->bmAttributes)); - return usbd_ep_close(ep->bEndpointAddress) == 0 ? true : false; + return usbd_ep_close(busid, ep->bEndpointAddress) == 0 ? true : false; } /** @@ -134,7 +134,7 @@ static bool usbd_reset_endpoint(const struct usb_endpoint_descriptor *ep) * @return true if the descriptor was found, false otherwise */ #ifdef CONFIG_USBDEV_ADVANCE_DESC -static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *len) +static bool usbd_get_descriptor(uint8_t busid, uint16_t type_index, uint8_t **data, uint32_t *len) { uint8_t type = 0U; uint8_t index = 0U; @@ -147,7 +147,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l switch (type) { case USB_DESCRIPTOR_TYPE_DEVICE: - desc = g_usbd_core.descriptors->device_descriptor_callback(g_usbd_core.speed); + desc = g_usbd_core[busid].descriptors->device_descriptor_callback(g_usbd_core[busid].speed); if (desc == NULL) { found = false; break; @@ -155,7 +155,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l desc_len = desc[0]; break; case USB_DESCRIPTOR_TYPE_CONFIGURATION: - desc = g_usbd_core.descriptors->config_descriptor_callback(g_usbd_core.speed); + desc = g_usbd_core[busid].descriptors->config_descriptor_callback(g_usbd_core[busid].speed); if (desc == NULL) { found = false; break; @@ -166,15 +166,15 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l if (index == USB_OSDESC_STRING_DESC_INDEX) { USB_LOG_INFO("read MS OS 2.0 descriptor string\r\n"); - if (!g_usbd_core.descriptors->msosv1_descriptor) { + if (!g_usbd_core[busid].descriptors->msosv1_descriptor) { found = false; break; } - desc = (uint8_t *)g_usbd_core.descriptors->msosv1_descriptor->string; - desc_len = g_usbd_core.descriptors->msosv1_descriptor->string[0]; + desc = (uint8_t *)g_usbd_core[busid].descriptors->msosv1_descriptor->string; + desc_len = g_usbd_core[busid].descriptors->msosv1_descriptor->string[0]; } else { - desc = g_usbd_core.descriptors->string_descriptor_callback(g_usbd_core.speed, index); + desc = g_usbd_core[busid].descriptors->string_descriptor_callback(g_usbd_core[busid].speed, index); if (desc == NULL) { found = false; break; @@ -183,7 +183,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l } break; case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER: - desc = g_usbd_core.descriptors->device_quality_descriptor_callback(g_usbd_core.speed); + desc = g_usbd_core[busid].descriptors->device_quality_descriptor_callback(g_usbd_core[busid].speed); if (desc == NULL) { found = false; break; @@ -191,7 +191,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l desc_len = desc[0]; break; case USB_DESCRIPTOR_TYPE_OTHER_SPEED: - desc = g_usbd_core.descriptors->other_speed_descriptor_callback(g_usbd_core.speed); + desc = g_usbd_core[busid].descriptors->other_speed_descriptor_callback(g_usbd_core[busid].speed); if (desc == NULL) { found = false; break; @@ -202,13 +202,13 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l case USB_DESCRIPTOR_TYPE_BINARY_OBJECT_STORE: USB_LOG_INFO("read BOS descriptor string\r\n"); - if (!g_usbd_core.descriptors->bos_descriptor) { + if (!g_usbd_core[busid].descriptors->bos_descriptor) { found = false; break; } - desc = (uint8_t *)g_usbd_core.descriptors->bos_descriptor->string; - desc_len = g_usbd_core.descriptors->bos_descriptor->string_len; + desc = (uint8_t *)g_usbd_core[busid].descriptors->bos_descriptor->string; + desc_len = g_usbd_core[busid].descriptors->bos_descriptor->string_len; break; default: @@ -227,7 +227,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l return found; } #else -static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *len) +static bool usbd_get_descriptor(uint8_t busid, uint16_t type_index, uint8_t **data, uint32_t *len) { uint8_t type = 0U; uint8_t index = 0U; @@ -241,25 +241,25 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l if ((type == USB_DESCRIPTOR_TYPE_STRING) && (index == USB_OSDESC_STRING_DESC_INDEX)) { USB_LOG_INFO("read MS OS 2.0 descriptor string\r\n"); - if (!g_usbd_core.msosv1_desc) { + if (!g_usbd_core[busid].msosv1_desc) { return false; } - //*data = (uint8_t *)g_usbd_core.msosv1_desc->string; - memcpy(*data, (uint8_t *)g_usbd_core.msosv1_desc->string, g_usbd_core.msosv1_desc->string[0]); - *len = g_usbd_core.msosv1_desc->string[0]; + //*data = (uint8_t *)g_usbd_core[busid].msosv1_desc->string; + memcpy(*data, (uint8_t *)g_usbd_core[busid].msosv1_desc->string, g_usbd_core[busid].msosv1_desc->string[0]); + *len = g_usbd_core[busid].msosv1_desc->string[0]; return true; } else if (type == USB_DESCRIPTOR_TYPE_BINARY_OBJECT_STORE) { USB_LOG_INFO("read BOS descriptor string\r\n"); - if (!g_usbd_core.bos_desc) { + if (!g_usbd_core[busid].bos_desc) { return false; } - //*data = g_usbd_core.bos_desc->string; - memcpy(*data, (uint8_t *)g_usbd_core.bos_desc->string, g_usbd_core.bos_desc->string_len); - *len = g_usbd_core.bos_desc->string_len; + //*data = g_usbd_core[busid].bos_desc->string; + memcpy(*data, (uint8_t *)g_usbd_core[busid].bos_desc->string, g_usbd_core[busid].bos_desc->string_len); + *len = g_usbd_core[busid].bos_desc->string_len; return true; } /* @@ -275,7 +275,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l return false; } - p = (uint8_t *)g_usbd_core.descriptors; + p = (uint8_t *)g_usbd_core[busid].descriptors; cur_index = 0U; @@ -326,7 +326,7 @@ static bool usbd_get_descriptor(uint16_t type_index, uint8_t **data, uint32_t *l * * @return true if successfully configured false if error or unconfigured */ -static bool usbd_set_configuration(uint8_t config_index, uint8_t alt_setting) +static bool usbd_set_configuration(uint8_t busid, uint8_t config_index, uint8_t alt_setting) { uint8_t cur_alt_setting = 0xFF; uint8_t cur_config = 0xFF; @@ -336,9 +336,9 @@ static bool usbd_set_configuration(uint8_t config_index, uint8_t alt_setting) uint32_t current_desc_len = 0; #ifdef CONFIG_USBDEV_ADVANCE_DESC - p = g_usbd_core.descriptors->config_descriptor_callback(g_usbd_core.speed); + p = g_usbd_core[busid].descriptors->config_descriptor_callback(g_usbd_core[busid].speed); #else - p = (uint8_t *)g_usbd_core.descriptors; + p = (uint8_t *)g_usbd_core[busid].descriptors; #endif /* configure endpoints for this configuration/altsetting */ while (p[DESC_bLength] != 0U) { @@ -369,7 +369,7 @@ static bool usbd_set_configuration(uint8_t config_index, uint8_t alt_setting) break; } - found = usbd_set_endpoint((struct usb_endpoint_descriptor *)p); + found = usbd_set_endpoint(busid, (struct usb_endpoint_descriptor *)p); break; default: @@ -395,7 +395,7 @@ static bool usbd_set_configuration(uint8_t config_index, uint8_t alt_setting) * * @return true if successfully configured false if error or unconfigured */ -static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) +static bool usbd_set_interface(uint8_t busid, uint8_t iface, uint8_t alt_setting) { const uint8_t *if_desc = NULL; struct usb_endpoint_descriptor *ep_desc; @@ -407,9 +407,9 @@ static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) uint32_t current_desc_len = 0; #ifdef CONFIG_USBDEV_ADVANCE_DESC - p = g_usbd_core.descriptors->config_descriptor_callback(g_usbd_core.speed); + p = g_usbd_core[busid].descriptors->config_descriptor_callback(g_usbd_core[busid].speed); #else - p = (uint8_t *)g_usbd_core.descriptors; + p = (uint8_t *)g_usbd_core[busid].descriptors; #endif USB_LOG_DBG("iface %u alt_setting %u\r\n", iface, alt_setting); @@ -441,9 +441,9 @@ static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) ep_desc = (struct usb_endpoint_descriptor *)p; if (cur_alt_setting != alt_setting) { - ret = usbd_reset_endpoint(ep_desc); + ret = usbd_reset_endpoint(busid, ep_desc); } else { - ret = usbd_set_endpoint(ep_desc); + ret = usbd_set_endpoint(busid, ep_desc); } } @@ -461,7 +461,7 @@ static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) } } - usbd_class_event_notify_handler(USBD_EVENT_SET_INTERFACE, (void *)if_desc); + usbd_class_event_notify_handler(busid, USBD_EVENT_SET_INTERFACE, (void *)if_desc); return ret; } @@ -475,7 +475,7 @@ static bool usbd_set_interface(uint8_t iface, uint8_t alt_setting) * * @return true if the request was handled successfully */ -static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static bool usbd_std_device_req_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint16_t value = setup->wValue; bool ret = true; @@ -493,26 +493,26 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t case USB_REQUEST_SET_FEATURE: if (value == USB_FEATURE_REMOTE_WAKEUP) { if (setup->bRequest == USB_REQUEST_SET_FEATURE) { - usbd_event_handler(USBD_EVENT_SET_REMOTE_WAKEUP); + g_usbd_core[busid].event_handler(USBD_EVENT_SET_REMOTE_WAKEUP); } else { - usbd_event_handler(USBD_EVENT_CLR_REMOTE_WAKEUP); + g_usbd_core[busid].event_handler(USBD_EVENT_CLR_REMOTE_WAKEUP); } } else if (value == USB_FEATURE_TEST_MODE) { #ifdef CONFIG_USBDEV_TEST_MODE - g_usbd_core.test_mode = true; - usbd_execute_test_mode(setup); + g_usbd_core[busid].test_mode = true; + usbd_execute_test_mode(busid, setup); #endif } *len = 0; break; case USB_REQUEST_SET_ADDRESS: - usbd_set_address(value); + usbd_set_address(busid, value); *len = 0; break; case USB_REQUEST_GET_DESCRIPTOR: - ret = usbd_get_descriptor(value, data, len); + ret = usbd_get_descriptor(busid, value, data, len); break; case USB_REQUEST_SET_DESCRIPTOR: @@ -520,19 +520,19 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t break; case USB_REQUEST_GET_CONFIGURATION: - *data = (uint8_t *)&g_usbd_core.configuration; + *data = (uint8_t *)&g_usbd_core[busid].configuration; *len = 1; break; case USB_REQUEST_SET_CONFIGURATION: value &= 0xFF; - if (!usbd_set_configuration(value, 0)) { + if (!usbd_set_configuration(busid, value, 0)) { ret = false; } else { - g_usbd_core.configuration = value; - usbd_class_event_notify_handler(USBD_EVENT_CONFIGURED, NULL); - usbd_event_handler(USBD_EVENT_CONFIGURED); + g_usbd_core[busid].configuration = value; + usbd_class_event_notify_handler(busid, USBD_EVENT_CONFIGURED, NULL); + g_usbd_core[busid].event_handler(USBD_EVENT_CONFIGURED); } *len = 0; break; @@ -559,15 +559,14 @@ static bool usbd_std_device_req_handler(struct usb_setup_packet *setup, uint8_t * * @return true if the request was handled successfully */ -static bool usbd_std_interface_req_handler(struct usb_setup_packet *setup, - uint8_t **data, uint32_t *len) +static bool usbd_std_interface_req_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t type = HI_BYTE(setup->wValue); uint8_t intf_num = LO_BYTE(setup->wIndex); bool ret = true; /* Only when device is configured, then interface requests can be valid. */ - if (!is_device_configured()) { + if (!is_device_configured(busid)) { return false; } @@ -582,8 +581,8 @@ static bool usbd_std_interface_req_handler(struct usb_setup_packet *setup, if (type == 0x22) { /* HID_DESCRIPTOR_TYPE_HID_REPORT */ USB_LOG_INFO("read hid report descriptor\r\n"); - for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { - struct usbd_interface *intf = g_usbd_core.intf[i]; + for (uint8_t i = 0; i < g_usbd_core[busid].intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core[busid].intf[i]; if (intf && (intf->intf_num == intf_num)) { //*data = (uint8_t *)intf->hid_report_descriptor; @@ -605,7 +604,7 @@ static bool usbd_std_interface_req_handler(struct usb_setup_packet *setup, break; case USB_REQUEST_SET_INTERFACE: - usbd_set_interface(setup->wIndex, setup->wValue); + usbd_set_interface(busid, setup->wIndex, setup->wValue); *len = 0; break; @@ -626,13 +625,13 @@ static bool usbd_std_interface_req_handler(struct usb_setup_packet *setup, * * @return true if the request was handled successfully */ -static bool usbd_std_endpoint_req_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static bool usbd_std_endpoint_req_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint8_t ep = (uint8_t)setup->wIndex; bool ret = true; /* Only when device is configured, then endpoint requests can be valid. */ - if (!is_device_configured()) { + if (!is_device_configured(busid)) { return false; } @@ -646,7 +645,7 @@ static bool usbd_std_endpoint_req_handler(struct usb_setup_packet *setup, uint8_ if (setup->wValue == USB_FEATURE_ENDPOINT_HALT) { USB_LOG_ERR("ep:%02x clear halt\r\n", ep); - usbd_ep_clear_stall(ep); + usbd_ep_clear_stall(busid, ep); break; } else { ret = false; @@ -657,7 +656,7 @@ static bool usbd_std_endpoint_req_handler(struct usb_setup_packet *setup, uint8_ if (setup->wValue == USB_FEATURE_ENDPOINT_HALT) { USB_LOG_ERR("ep:%02x set halt\r\n", ep); - usbd_ep_set_stall(ep); + usbd_ep_set_stall(busid, ep); } else { ret = false; } @@ -684,27 +683,27 @@ static bool usbd_std_endpoint_req_handler(struct usb_setup_packet *setup, uint8_ * * @return true if the request was handled successfully */ -static int usbd_standard_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_standard_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { int rc = 0; switch (setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) { case USB_REQUEST_RECIPIENT_DEVICE: - if (usbd_std_device_req_handler(setup, data, len) == false) { + if (usbd_std_device_req_handler(busid, setup, data, len) == false) { rc = -1; } break; case USB_REQUEST_RECIPIENT_INTERFACE: - if (usbd_std_interface_req_handler(setup, data, len) == false) { + if (usbd_std_interface_req_handler(busid, setup, data, len) == false) { rc = -1; } break; case USB_REQUEST_RECIPIENT_ENDPOINT: - if (usbd_std_endpoint_req_handler(setup, data, len) == false) { + if (usbd_std_endpoint_req_handler(busid, setup, data, len) == false) { rc = -1; } @@ -729,22 +728,22 @@ static int usbd_standard_request_handler(struct usb_setup_packet *setup, uint8_t * * @return true if the request was handled successfully */ -static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_class_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_INTERFACE) { - for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { - struct usbd_interface *intf = g_usbd_core.intf[i]; + for (uint8_t i = 0; i < g_usbd_core[busid].intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core[busid].intf[i]; if (intf && intf->class_interface_handler && (intf->intf_num == (setup->wIndex & 0xFF))) { - return intf->class_interface_handler(setup, data, len); + return intf->class_interface_handler(busid, setup, data, len); } } } else if ((setup->bmRequestType & USB_REQUEST_RECIPIENT_MASK) == USB_REQUEST_RECIPIENT_ENDPOINT) { - for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { - struct usbd_interface *intf = g_usbd_core.intf[i]; + for (uint8_t i = 0; i < g_usbd_core[busid].intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core[busid].intf[i]; if (intf && intf->class_endpoint_handler) { - return intf->class_endpoint_handler(setup, data, len); + return intf->class_endpoint_handler(busid, setup, data, len); } } } @@ -762,33 +761,33 @@ static int usbd_class_request_handler(struct usb_setup_packet *setup, uint8_t ** * * @return true if the request was handled successfully */ -static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static int usbd_vendor_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { uint32_t desclen; #ifdef CONFIG_USBDEV_ADVANCE_DESC - if (g_usbd_core.descriptors->msosv1_descriptor) { - if (setup->bRequest == g_usbd_core.descriptors->msosv1_descriptor->vendor_code) { + if (g_usbd_core[busid].descriptors->msosv1_descriptor) { + if (setup->bRequest == g_usbd_core[busid].descriptors->msosv1_descriptor->vendor_code) { switch (setup->wIndex) { case 0x04: USB_LOG_INFO("get Compat ID\r\n"); - desclen = g_usbd_core.descriptors->msosv1_descriptor->compat_id[0] + - (g_usbd_core.descriptors->msosv1_descriptor->compat_id[1] << 8) + - (g_usbd_core.descriptors->msosv1_descriptor->compat_id[2] << 16) + - (g_usbd_core.descriptors->msosv1_descriptor->compat_id[3] << 24); + desclen = g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id[0] + + (g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id[1] << 8) + + (g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id[2] << 16) + + (g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id[3] << 24); - //*data = (uint8_t *)g_usbd_core.descriptors->msosv1_descriptor->compat_id; - memcpy(*data, g_usbd_core.descriptors->msosv1_descriptor->compat_id, desclen); + //*data = (uint8_t *)g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id; + memcpy(*data, g_usbd_core[busid].descriptors->msosv1_descriptor->compat_id, desclen); *len = desclen; return 0; case 0x05: USB_LOG_INFO("get Compat id properties\r\n"); - desclen = g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue][0] + - (g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue][1] << 8) + - (g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue][2] << 16) + - (g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue][3] << 24); + desclen = g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue][0] + + (g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue][1] << 8) + + (g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue][2] << 16) + + (g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue][3] << 24); - //*data = (uint8_t *)g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue]; - memcpy(*data, g_usbd_core.descriptors->msosv1_descriptor->comp_id_property[setup->wValue], desclen); + //*data = (uint8_t *)g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue]; + memcpy(*data, g_usbd_core[busid].descriptors->msosv1_descriptor->comp_id_property[setup->wValue], desclen); *len = desclen; return 0; default: @@ -796,31 +795,31 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * return -1; } } - } else if (g_usbd_core.descriptors->msosv2_descriptor) { - if (setup->bRequest == g_usbd_core.descriptors->msosv2_descriptor->vendor_code) { + } else if (g_usbd_core[busid].descriptors->msosv2_descriptor) { + if (setup->bRequest == g_usbd_core[busid].descriptors->msosv2_descriptor->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET MS OS 2.0 Descriptor\r\n"); - desclen = g_usbd_core.descriptors->msosv2_descriptor->compat_id_len; - //*data = (uint8_t *)g_usbd_core.descriptors->msosv2_descriptor->compat_id; - memcpy(*data, g_usbd_core.descriptors->msosv2_descriptor->compat_id, desclen); - *len = g_usbd_core.descriptors->msosv2_descriptor->compat_id_len; + desclen = g_usbd_core[busid].descriptors->msosv2_descriptor->compat_id_len; + //*data = (uint8_t *)g_usbd_core[busid].descriptors->msosv2_descriptor->compat_id; + memcpy(*data, g_usbd_core[busid].descriptors->msosv2_descriptor->compat_id, desclen); + *len = g_usbd_core[busid].descriptors->msosv2_descriptor->compat_id_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); return -1; } } - } else if (g_usbd_core.descriptors->webusb_url_descriptor) { - if (setup->bRequest == g_usbd_core.descriptors->webusb_url_descriptor->vendor_code) { + } else if (g_usbd_core[busid].descriptors->webusb_url_descriptor) { + if (setup->bRequest == g_usbd_core[busid].descriptors->webusb_url_descriptor->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET Webusb url Descriptor\r\n"); - desclen = g_usbd_core.descriptors->webusb_url_descriptor->string_len; - //*data = (uint8_t *)g_usbd_core.descriptors->webusb_url_descriptor->string; - memcpy(*data, g_usbd_core.descriptors->webusb_url_descriptor->string, desclen); + desclen = g_usbd_core[busid].descriptors->webusb_url_descriptor->string_len; + //*data = (uint8_t *)g_usbd_core[busid].descriptors->webusb_url_descriptor->string; + memcpy(*data, g_usbd_core[busid].descriptors->webusb_url_descriptor->string, desclen); *len = desclen; return 0; default: @@ -830,27 +829,27 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * } } #else - if (g_usbd_core.msosv1_desc) { - if (setup->bRequest == g_usbd_core.msosv1_desc->vendor_code) { + if (g_usbd_core[busid].msosv1_desc) { + if (setup->bRequest == g_usbd_core[busid].msosv1_desc->vendor_code) { switch (setup->wIndex) { case 0x04: USB_LOG_INFO("get Compat ID\r\n"); //*data = (uint8_t *)msosv1_desc->compat_id; - desclen = g_usbd_core.msosv1_desc->compat_id[0] + - (g_usbd_core.msosv1_desc->compat_id[1] << 8) + - (g_usbd_core.msosv1_desc->compat_id[2] << 16) + - (g_usbd_core.msosv1_desc->compat_id[3] << 24); - memcpy(*data, g_usbd_core.msosv1_desc->compat_id, desclen); + desclen = g_usbd_core[busid].msosv1_desc->compat_id[0] + + (g_usbd_core[busid].msosv1_desc->compat_id[1] << 8) + + (g_usbd_core[busid].msosv1_desc->compat_id[2] << 16) + + (g_usbd_core[busid].msosv1_desc->compat_id[3] << 24); + memcpy(*data, g_usbd_core[busid].msosv1_desc->compat_id, desclen); *len = desclen; return 0; case 0x05: USB_LOG_INFO("get Compat id properties\r\n"); //*data = (uint8_t *)msosv1_desc->comp_id_property[setup->wValue]; - desclen = g_usbd_core.msosv1_desc->comp_id_property[setup->wValue][0] + - (g_usbd_core.msosv1_desc->comp_id_property[setup->wValue][1] << 8) + - (g_usbd_core.msosv1_desc->comp_id_property[setup->wValue][2] << 16) + - (g_usbd_core.msosv1_desc->comp_id_property[setup->wValue][3] << 24); - memcpy(*data, g_usbd_core.msosv1_desc->comp_id_property[setup->wValue], desclen); + desclen = g_usbd_core[busid].msosv1_desc->comp_id_property[setup->wValue][0] + + (g_usbd_core[busid].msosv1_desc->comp_id_property[setup->wValue][1] << 8) + + (g_usbd_core[busid].msosv1_desc->comp_id_property[setup->wValue][2] << 16) + + (g_usbd_core[busid].msosv1_desc->comp_id_property[setup->wValue][3] << 24); + memcpy(*data, g_usbd_core[busid].msosv1_desc->comp_id_property[setup->wValue], desclen); *len = desclen; return 0; default: @@ -858,14 +857,14 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * return -1; } } - } else if (g_usbd_core.msosv2_desc) { - if (setup->bRequest == g_usbd_core.msosv2_desc->vendor_code) { + } else if (g_usbd_core[busid].msosv2_desc) { + if (setup->bRequest == g_usbd_core[busid].msosv2_desc->vendor_code) { switch (setup->wIndex) { case WINUSB_REQUEST_GET_DESCRIPTOR_SET: USB_LOG_INFO("GET MS OS 2.0 Descriptor\r\n"); //*data = (uint8_t *)msosv2_desc->compat_id; - memcpy(*data, g_usbd_core.msosv2_desc->compat_id, g_usbd_core.msosv2_desc->compat_id_len); - *len = g_usbd_core.msosv2_desc->compat_id_len; + memcpy(*data, g_usbd_core[busid].msosv2_desc->compat_id, g_usbd_core[busid].msosv2_desc->compat_id_len); + *len = g_usbd_core[busid].msosv2_desc->compat_id_len; return 0; default: USB_LOG_ERR("unknown vendor code\r\n"); @@ -874,10 +873,10 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * } } #endif - for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { - struct usbd_interface *intf = g_usbd_core.intf[i]; + for (uint8_t i = 0; i < g_usbd_core[busid].intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core[busid].intf[i]; - if (intf && intf->vendor_handler && (intf->vendor_handler(setup, data, len) == 0)) { + if (intf && intf->vendor_handler && (intf->vendor_handler(busid, setup, data, len) == 0)) { return 0; } } @@ -894,32 +893,32 @@ static int usbd_vendor_request_handler(struct usb_setup_packet *setup, uint8_t * * * @return true if the request was handles successfully */ -static bool usbd_setup_request_handler(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) +static bool usbd_setup_request_handler(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len) { switch (setup->bmRequestType & USB_REQUEST_TYPE_MASK) { case USB_REQUEST_STANDARD: #ifndef CONFIG_USB_HS - //g_usbd_core.speed = USB_SPEED_FULL; /* next time will support getting device speed */ - if ((setup->bRequest == 0x06) && (setup->wValue == 0x0600) && (g_usbd_core.speed <= USB_SPEED_FULL)) { + //g_usbd_core[busid].speed = USB_SPEED_FULL; /* next time will support getting device speed */ + if ((setup->bRequest == 0x06) && (setup->wValue == 0x0600) && (g_usbd_core[busid].speed <= USB_SPEED_FULL)) { USB_LOG_WRN("Ignore DQD in fs\r\n"); /* Device Qualifier Descriptor */ return false; } #endif - if (usbd_standard_request_handler(setup, data, len) < 0) { + if (usbd_standard_request_handler(busid, setup, data, len) < 0) { USB_LOG_ERR("standard request error\r\n"); usbd_print_setup(setup); return false; } break; case USB_REQUEST_CLASS: - if (usbd_class_request_handler(setup, data, len) < 0) { + if (usbd_class_request_handler(busid, setup, data, len) < 0) { USB_LOG_ERR("class request error\r\n"); usbd_print_setup(setup); return false; } break; case USB_REQUEST_VENDOR: - if (usbd_vendor_request_handler(setup, data, len) < 0) { + if (usbd_vendor_request_handler(busid, setup, data, len) < 0) { USB_LOG_ERR("vendor request error\r\n"); usbd_print_setup(setup); return false; @@ -933,51 +932,51 @@ static bool usbd_setup_request_handler(struct usb_setup_packet *setup, uint8_t * return true; } -static void usbd_class_event_notify_handler(uint8_t event, void *arg) +static void usbd_class_event_notify_handler(uint8_t busid, uint8_t event, void *arg) { - for (uint8_t i = 0; i < g_usbd_core.intf_offset; i++) { - struct usbd_interface *intf = g_usbd_core.intf[i]; + for (uint8_t i = 0; i < g_usbd_core[busid].intf_offset; i++) { + struct usbd_interface *intf = g_usbd_core[busid].intf[i]; if (arg) { struct usb_interface_descriptor *desc = (struct usb_interface_descriptor *)arg; if (intf && intf->notify_handler && (desc->bInterfaceNumber == (intf->intf_num))) { - intf->notify_handler(event, arg); + intf->notify_handler(busid, event, arg); } } else { if (intf && intf->notify_handler) { - intf->notify_handler(event, arg); + intf->notify_handler(busid, event, arg); } } } } -void usbd_event_connect_handler(void) +void usbd_event_connect_handler(uint8_t busid) { - usbd_event_handler(USBD_EVENT_CONNECTED); + g_usbd_core[busid].event_handler(USBD_EVENT_CONNECTED); } -void usbd_event_disconnect_handler(void) +void usbd_event_disconnect_handler(uint8_t busid) { - usbd_event_handler(USBD_EVENT_DISCONNECTED); + g_usbd_core[busid].event_handler(USBD_EVENT_DISCONNECTED); } -void usbd_event_resume_handler(void) +void usbd_event_resume_handler(uint8_t busid) { - usbd_event_handler(USBD_EVENT_RESUME); + g_usbd_core[busid].event_handler(USBD_EVENT_RESUME); } -void usbd_event_suspend_handler(void) +void usbd_event_suspend_handler(uint8_t busid) { - usbd_event_handler(USBD_EVENT_SUSPEND); + g_usbd_core[busid].event_handler(USBD_EVENT_SUSPEND); } -void usbd_event_reset_handler(void) +void usbd_event_reset_handler(uint8_t busid) { - usbd_set_address(0); - g_usbd_core.configuration = 0; + usbd_set_address(busid, 0); + g_usbd_core[busid].configuration = 0; #ifdef CONFIG_USBDEV_TEST_MODE - g_usbd_core.test_mode = false; + g_usbd_core[busid].test_mode = false; #endif struct usb_endpoint_descriptor ep0; @@ -987,18 +986,18 @@ void usbd_event_reset_handler(void) ep0.bmAttributes = USB_ENDPOINT_TYPE_CONTROL; ep0.bEndpointAddress = USB_CONTROL_IN_EP0; ep0.bInterval = 0; - usbd_ep_open(&ep0); + usbd_ep_open(busid, &ep0); ep0.bEndpointAddress = USB_CONTROL_OUT_EP0; - usbd_ep_open(&ep0); + usbd_ep_open(busid, &ep0); - usbd_class_event_notify_handler(USBD_EVENT_RESET, NULL); - usbd_event_handler(USBD_EVENT_RESET); + usbd_class_event_notify_handler(busid, USBD_EVENT_RESET, NULL); + g_usbd_core[busid].event_handler(USBD_EVENT_RESET); } -void usbd_event_ep0_setup_complete_handler(uint8_t *psetup) +void usbd_event_ep0_setup_complete_handler(uint8_t busid, uint8_t *psetup) { - struct usb_setup_packet *setup = &g_usbd_core.setup; + struct usb_setup_packet *setup = &g_usbd_core[busid].setup; memcpy(setup, psetup, 8); #ifdef CONFIG_USBDEV_SETUP_LOG_PRINT @@ -1007,73 +1006,73 @@ void usbd_event_ep0_setup_complete_handler(uint8_t *psetup) if (setup->wLength > CONFIG_USBDEV_REQUEST_BUFFER_LEN) { if ((setup->bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_OUT) { USB_LOG_ERR("Request buffer too small\r\n"); - usbd_ep_set_stall(USB_CONTROL_IN_EP0); + usbd_ep_set_stall(busid, USB_CONTROL_IN_EP0); return; } } - g_usbd_core.ep0_data_buf = g_usbd_core.req_data; - g_usbd_core.ep0_data_buf_residue = setup->wLength; - g_usbd_core.ep0_data_buf_len = setup->wLength; - g_usbd_core.zlp_flag = false; + g_usbd_core[busid].ep0_data_buf = g_usbd_core[busid].req_data; + g_usbd_core[busid].ep0_data_buf_residue = setup->wLength; + g_usbd_core[busid].ep0_data_buf_len = setup->wLength; + g_usbd_core[busid].zlp_flag = false; /* handle class request when all the data is received */ if (setup->wLength && ((setup->bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_OUT)) { USB_LOG_DBG("Start reading %d bytes from ep0\r\n", setup->wLength); - usbd_ep_start_read(USB_CONTROL_OUT_EP0, g_usbd_core.ep0_data_buf, setup->wLength); + usbd_ep_start_read(busid, USB_CONTROL_OUT_EP0, g_usbd_core[busid].ep0_data_buf, setup->wLength); return; } /* Ask installed handler to process request */ - if (!usbd_setup_request_handler(setup, &g_usbd_core.ep0_data_buf, &g_usbd_core.ep0_data_buf_len)) { - usbd_ep_set_stall(USB_CONTROL_IN_EP0); + if (!usbd_setup_request_handler(busid, setup, &g_usbd_core[busid].ep0_data_buf, &g_usbd_core[busid].ep0_data_buf_len)) { + usbd_ep_set_stall(busid, USB_CONTROL_IN_EP0); return; } #ifdef CONFIG_USBDEV_TEST_MODE /* send status in test mode, so do not execute downward, just return */ - if (g_usbd_core.test_mode) { - g_usbd_core.test_mode = false; + if (g_usbd_core[busid].test_mode) { + g_usbd_core[busid].test_mode = false; return; } #endif /* Send smallest of requested and offered length */ - g_usbd_core.ep0_data_buf_residue = MIN(g_usbd_core.ep0_data_buf_len, setup->wLength); - if (g_usbd_core.ep0_data_buf_residue > CONFIG_USBDEV_REQUEST_BUFFER_LEN) { + g_usbd_core[busid].ep0_data_buf_residue = MIN(g_usbd_core[busid].ep0_data_buf_len, setup->wLength); + if (g_usbd_core[busid].ep0_data_buf_residue > CONFIG_USBDEV_REQUEST_BUFFER_LEN) { USB_LOG_ERR("Request buffer too small\r\n"); return; } /* Send data or status to host */ - usbd_ep_start_write(USB_CONTROL_IN_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); + usbd_ep_start_write(busid, USB_CONTROL_IN_EP0, g_usbd_core[busid].ep0_data_buf, g_usbd_core[busid].ep0_data_buf_residue); /* * Set ZLP flag when host asks for a bigger length and the data size is * multiplier of USB_CTRL_EP_MPS, to indicate the transfer done after zlp * sent. */ - if ((setup->wLength > g_usbd_core.ep0_data_buf_len) && (!(g_usbd_core.ep0_data_buf_len % USB_CTRL_EP_MPS))) { - g_usbd_core.zlp_flag = true; + if ((setup->wLength > g_usbd_core[busid].ep0_data_buf_len) && (!(g_usbd_core[busid].ep0_data_buf_len % USB_CTRL_EP_MPS))) { + g_usbd_core[busid].zlp_flag = true; USB_LOG_DBG("EP0 Set zlp\r\n"); } } -void usbd_event_ep0_in_complete_handler(uint8_t ep, uint32_t nbytes) +void usbd_event_ep0_in_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes) { - struct usb_setup_packet *setup = &g_usbd_core.setup; + struct usb_setup_packet *setup = &g_usbd_core[busid].setup; - g_usbd_core.ep0_data_buf += nbytes; - g_usbd_core.ep0_data_buf_residue -= nbytes; + g_usbd_core[busid].ep0_data_buf += nbytes; + g_usbd_core[busid].ep0_data_buf_residue -= nbytes; - USB_LOG_DBG("EP0 send %d bytes, %d remained\r\n", nbytes, g_usbd_core.ep0_data_buf_residue); + USB_LOG_DBG("EP0 send %d bytes, %d remained\r\n", nbytes, g_usbd_core[busid].ep0_data_buf_residue); - if (g_usbd_core.ep0_data_buf_residue != 0) { + if (g_usbd_core[busid].ep0_data_buf_residue != 0) { /* Start sending the remain data */ - usbd_ep_start_write(USB_CONTROL_IN_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); + usbd_ep_start_write(busid, USB_CONTROL_IN_EP0, g_usbd_core[busid].ep0_data_buf, g_usbd_core[busid].ep0_data_buf_residue); } else { - if (g_usbd_core.zlp_flag == true) { - g_usbd_core.zlp_flag = false; + if (g_usbd_core[busid].zlp_flag == true) { + g_usbd_core[busid].zlp_flag = false; /* Send zlp to host */ USB_LOG_DBG("EP0 Send zlp\r\n"); - usbd_ep_start_write(USB_CONTROL_IN_EP0, NULL, 0); + usbd_ep_start_write(busid, USB_CONTROL_IN_EP0, NULL, 0); } else { /* Satisfying three conditions will jump here. * 1. send status completely @@ -1082,35 +1081,35 @@ void usbd_event_ep0_in_complete_handler(uint8_t ep, uint32_t nbytes) */ if (setup->wLength && ((setup->bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_IN)) { /* if all data has sent completely, start reading out status */ - usbd_ep_start_read(USB_CONTROL_OUT_EP0, NULL, 0); + usbd_ep_start_read(busid, USB_CONTROL_OUT_EP0, NULL, 0); } } } } -void usbd_event_ep0_out_complete_handler(uint8_t ep, uint32_t nbytes) +void usbd_event_ep0_out_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes) { - struct usb_setup_packet *setup = &g_usbd_core.setup; + struct usb_setup_packet *setup = &g_usbd_core[busid].setup; if (nbytes > 0) { - g_usbd_core.ep0_data_buf += nbytes; - g_usbd_core.ep0_data_buf_residue -= nbytes; + g_usbd_core[busid].ep0_data_buf += nbytes; + g_usbd_core[busid].ep0_data_buf_residue -= nbytes; - USB_LOG_DBG("EP0 recv %d bytes, %d remained\r\n", nbytes, g_usbd_core.ep0_data_buf_residue); + USB_LOG_DBG("EP0 recv %d bytes, %d remained\r\n", nbytes, g_usbd_core[busid].ep0_data_buf_residue); - if (g_usbd_core.ep0_data_buf_residue == 0) { + if (g_usbd_core[busid].ep0_data_buf_residue == 0) { /* Received all, send data to handler */ - g_usbd_core.ep0_data_buf = g_usbd_core.req_data; - if (!usbd_setup_request_handler(setup, &g_usbd_core.ep0_data_buf, &g_usbd_core.ep0_data_buf_len)) { - usbd_ep_set_stall(USB_CONTROL_IN_EP0); + g_usbd_core[busid].ep0_data_buf = g_usbd_core[busid].req_data; + if (!usbd_setup_request_handler(busid, setup, &g_usbd_core[busid].ep0_data_buf, &g_usbd_core[busid].ep0_data_buf_len)) { + usbd_ep_set_stall(busid, USB_CONTROL_IN_EP0); return; } /*Send status to host*/ - usbd_ep_start_write(USB_CONTROL_IN_EP0, NULL, 0); + usbd_ep_start_write(busid, USB_CONTROL_IN_EP0, NULL, 0); } else { /* Start reading the remain data */ - usbd_ep_start_read(USB_CONTROL_OUT_EP0, g_usbd_core.ep0_data_buf, g_usbd_core.ep0_data_buf_residue); + usbd_ep_start_read(busid, USB_CONTROL_OUT_EP0, g_usbd_core[busid].ep0_data_buf, g_usbd_core[busid].ep0_data_buf_residue); } } else { /* Read out status completely, do nothing */ @@ -1118,130 +1117,104 @@ void usbd_event_ep0_out_complete_handler(uint8_t ep, uint32_t nbytes) } } -void usbd_event_ep_in_complete_handler(uint8_t ep, uint32_t nbytes) +void usbd_event_ep_in_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes) { - if (g_usbd_core.tx_msg[ep & 0x7f].cb) { - g_usbd_core.tx_msg[ep & 0x7f].cb(ep, nbytes); + if (g_usbd_core[busid].tx_msg[ep & 0x7f].cb) { + g_usbd_core[busid].tx_msg[ep & 0x7f].cb(busid, ep, nbytes); } } -void usbd_event_ep_out_complete_handler(uint8_t ep, uint32_t nbytes) +void usbd_event_ep_out_complete_handler(uint8_t busid, uint8_t ep, uint32_t nbytes) { - if (g_usbd_core.rx_msg[ep & 0x7f].cb) { - g_usbd_core.rx_msg[ep & 0x7f].cb(ep, nbytes); + if (g_usbd_core[busid].rx_msg[ep & 0x7f].cb) { + g_usbd_core[busid].rx_msg[ep & 0x7f].cb(busid, ep, nbytes); } } #ifdef CONFIG_USBDEV_ADVANCE_DESC -void usbd_desc_register(const struct usb_descriptor *desc) +void usbd_desc_register(uint8_t busid, const struct usb_descriptor *desc) { - memset(&g_usbd_core, 0, sizeof(struct usbd_core_priv)); + memset(&g_usbd_core[busid], 0, sizeof(struct usbd_core_priv)); - g_usbd_core.descriptors = desc; - g_usbd_core.intf_offset = 0; + g_usbd_core[busid].descriptors = desc; + g_usbd_core[busid].intf_offset = 0; - g_usbd_core.tx_msg[0].ep = 0x80; - g_usbd_core.tx_msg[0].cb = usbd_event_ep0_in_complete_handler; - g_usbd_core.rx_msg[0].ep = 0x00; - g_usbd_core.rx_msg[0].cb = usbd_event_ep0_out_complete_handler; + g_usbd_core[busid].tx_msg[0].ep = 0x80; + g_usbd_core[busid].tx_msg[0].cb = usbd_event_ep0_in_complete_handler; + g_usbd_core[busid].rx_msg[0].ep = 0x00; + g_usbd_core[busid].rx_msg[0].cb = usbd_event_ep0_out_complete_handler; } #else -void usbd_desc_register(const uint8_t *desc) +void usbd_desc_register(uint8_t busid, const uint8_t *desc) { - memset(&g_usbd_core, 0, sizeof(struct usbd_core_priv)); + memset(&g_usbd_core[busid], 0, sizeof(struct usbd_core_priv)); - g_usbd_core.descriptors = desc; - g_usbd_core.intf_offset = 0; + g_usbd_core[busid].descriptors = desc; + g_usbd_core[busid].intf_offset = 0; - g_usbd_core.tx_msg[0].ep = 0x80; - g_usbd_core.tx_msg[0].cb = usbd_event_ep0_in_complete_handler; - g_usbd_core.rx_msg[0].ep = 0x00; - g_usbd_core.rx_msg[0].cb = usbd_event_ep0_out_complete_handler; + g_usbd_core[busid].tx_msg[0].ep = 0x80; + g_usbd_core[busid].tx_msg[0].cb = usbd_event_ep0_in_complete_handler; + g_usbd_core[busid].rx_msg[0].ep = 0x00; + g_usbd_core[busid].rx_msg[0].cb = usbd_event_ep0_out_complete_handler; } /* Register MS OS Descriptors version 1 */ -void usbd_msosv1_desc_register(struct usb_msosv1_descriptor *desc) +void usbd_msosv1_desc_register(uint8_t busid, struct usb_msosv1_descriptor *desc) { - g_usbd_core.msosv1_desc = desc; + g_usbd_core[busid].msosv1_desc = desc; } /* Register MS OS Descriptors version 2 */ -void usbd_msosv2_desc_register(struct usb_msosv2_descriptor *desc) +void usbd_msosv2_desc_register(uint8_t busid, struct usb_msosv2_descriptor *desc) { - g_usbd_core.msosv2_desc = desc; + g_usbd_core[busid].msosv2_desc = desc; } -void usbd_bos_desc_register(struct usb_bos_descriptor *desc) +void usbd_bos_desc_register(uint8_t busid, struct usb_bos_descriptor *desc) { - g_usbd_core.bos_desc = desc; + g_usbd_core[busid].bos_desc = desc; } #endif -void usbd_add_interface(struct usbd_interface *intf) +void usbd_add_interface(uint8_t busid, struct usbd_interface *intf) { - intf->intf_num = g_usbd_core.intf_offset; - g_usbd_core.intf[g_usbd_core.intf_offset] = intf; - g_usbd_core.intf_offset++; + intf->intf_num = g_usbd_core[busid].intf_offset; + g_usbd_core[busid].intf[g_usbd_core[busid].intf_offset] = intf; + g_usbd_core[busid].intf_offset++; } -void usbd_add_endpoint(struct usbd_endpoint *ep) +void usbd_add_endpoint(uint8_t busid, struct usbd_endpoint *ep) { if (ep->ep_addr & 0x80) { - g_usbd_core.tx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; - g_usbd_core.tx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; + g_usbd_core[busid].tx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; + g_usbd_core[busid].tx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; } else { - g_usbd_core.rx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; - g_usbd_core.rx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; + g_usbd_core[busid].rx_msg[ep->ep_addr & 0x7f].ep = ep->ep_addr; + g_usbd_core[busid].rx_msg[ep->ep_addr & 0x7f].cb = ep->ep_cb; } } -bool usb_device_is_configured(void) +bool usb_device_is_configured(uint8_t busid) { - return g_usbd_core.configuration; + return g_usbd_core[busid].configuration; } -int usbd_initialize(void) +int usbd_initialize(uint8_t busid, void (*event_handler)(uint8_t event)) { int ret; - ret = usb_dc_init(); - usbd_class_event_notify_handler(USBD_EVENT_INIT, NULL); + g_usbd_core[busid].event_handler = event_handler; + ret = usb_dc_init(busid); + usbd_class_event_notify_handler(busid, USBD_EVENT_INIT, NULL); + g_usbd_core[busid].event_handler(USBD_EVENT_INIT); return ret; } -int usbd_deinitialize(void) +int usbd_deinitialize(uint8_t busid) { - g_usbd_core.intf_offset = 0; - usb_dc_deinit(); - usbd_class_event_notify_handler(USBD_EVENT_DEINIT, NULL); + g_usbd_core[busid].intf_offset = 0; + usb_dc_deinit(busid); + usbd_class_event_notify_handler(busid, USBD_EVENT_DEINIT, NULL); + g_usbd_core[busid].event_handler(USBD_EVENT_DEINIT); return 0; } - -__WEAK void usbd_event_handler(uint8_t event) -{ - switch (event) { - case USBD_EVENT_INIT: - break; - case USBD_EVENT_DEINIT: - break; - case USBD_EVENT_RESET: - break; - case USBD_EVENT_CONNECTED: - break; - case USBD_EVENT_DISCONNECTED: - break; - case USBD_EVENT_RESUME: - break; - case USBD_EVENT_SUSPEND: - break; - case USBD_EVENT_CONFIGURED: - break; - case USBD_EVENT_SET_REMOTE_WAKEUP: - break; - case USBD_EVENT_CLR_REMOTE_WAKEUP: - break; - - default: - break; - } -} diff --git a/core/usbd_core.h b/core/usbd_core.h index ca70fc69..8fafa2db 100644 --- a/core/usbd_core.h +++ b/core/usbd_core.h @@ -43,9 +43,9 @@ enum usbd_event_type { USBD_EVENT_UNKNOWN }; -typedef int (*usbd_request_handler)(struct usb_setup_packet *setup, uint8_t **data, uint32_t *len); -typedef void (*usbd_endpoint_callback)(uint8_t ep, uint32_t nbytes); -typedef void (*usbd_notify_handler)(uint8_t event, void *arg); +typedef int (*usbd_request_handler)(uint8_t busid, struct usb_setup_packet *setup, uint8_t **data, uint32_t *len); +typedef void (*usbd_endpoint_callback)(uint8_t busid, uint8_t ep, uint32_t nbytes); +typedef void (*usbd_notify_handler)(uint8_t busid, uint8_t event, void *arg); struct usbd_endpoint { uint8_t ep_addr; @@ -75,22 +75,20 @@ struct usb_descriptor { }; #ifdef CONFIG_USBDEV_ADVANCE_DESC -void usbd_desc_register(const struct usb_descriptor *desc); +void usbd_desc_register(uint8_t busid, const struct usb_descriptor *desc); #else -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_desc_register(uint8_t busid, const uint8_t *desc); +void usbd_msosv1_desc_register(uint8_t busid, struct usb_msosv1_descriptor *desc); +void usbd_msosv2_desc_register(uint8_t busid, struct usb_msosv2_descriptor *desc); +void usbd_bos_desc_register(uint8_t busid, struct usb_bos_descriptor *desc); #endif -void usbd_add_interface(struct usbd_interface *intf); -void usbd_add_endpoint(struct usbd_endpoint *ep); +void usbd_add_interface(uint8_t busid, struct usbd_interface *intf); +void usbd_add_endpoint(uint8_t busid, struct usbd_endpoint *ep); -bool usb_device_is_configured(void); -int usbd_initialize(void); -int usbd_deinitialize(void); - -void usbd_event_handler(uint8_t event); +bool usb_device_is_configured(uint8_t busid); +int usbd_initialize(uint8_t busid, void (*event_handler)(uint8_t event)); +int usbd_deinitialize(uint8_t busid); #ifdef __cplusplus } diff --git a/demo/audio_v1_mic_multichan_template.c b/demo/audio_v1_mic_multichan_template.c index 8def44c1..00e3a585 100644 --- a/demo/audio_v1_mic_multichan_template.c +++ b/demo/audio_v1_mic_multichan_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_audio.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -148,7 +150,7 @@ const uint8_t audio_v1_descriptor[] = { volatile bool tx_flag = 0; volatile bool ep_tx_busy_flag = false; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -173,19 +175,19 @@ void usbd_event_handler(uint8_t event) } } -void usbd_audio_open(uint8_t intf) +void usbd_audio_open(uint8_t busid, uint8_t intf) { tx_flag = 1; USB_LOG_RAW("OPEN\r\n"); } -void usbd_audio_close(uint8_t intf) +void usbd_audio_close(uint8_t busid, uint8_t intf) { USB_LOG_RAW("CLOSE\r\n"); tx_flag = 0; } -void usbd_audio_iso_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_iso_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); ep_tx_busy_flag = false; @@ -207,12 +209,12 @@ struct audio_entity_info audio_entity_table[] = { void audio_v1_init(void) { - usbd_desc_register(audio_v1_descriptor); - usbd_add_interface(usbd_audio_init_intf(&intf0, 0x0100, audio_entity_table, 1)); - usbd_add_interface(usbd_audio_init_intf(&intf1, 0x0100, audio_entity_table, 1)); - usbd_add_endpoint(&audio_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, audio_v1_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, 0x0100, audio_entity_table, 1)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, 0x0100, audio_entity_table, 1)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[AUDIO_IN_PACKET]; @@ -223,7 +225,7 @@ void audio_test() if (tx_flag) { memset(write_buffer, 'a', AUDIO_IN_PACKET); ep_tx_busy_flag = true; - usbd_ep_start_write(AUDIO_IN_EP, write_buffer, AUDIO_IN_PACKET); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, AUDIO_IN_EP, write_buffer, AUDIO_IN_PACKET); while (ep_tx_busy_flag) { if (tx_flag == false) { break; diff --git a/demo/audio_v1_mic_speaker_multichan_template.c b/demo/audio_v1_mic_speaker_multichan_template.c index 9b802028..c4468060 100644 --- a/demo/audio_v1_mic_speaker_multichan_template.c +++ b/demo/audio_v1_mic_speaker_multichan_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_audio.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -147,7 +149,7 @@ volatile bool tx_flag = 0; volatile bool rx_flag = 0; volatile bool ep_tx_busy_flag = false; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -172,12 +174,12 @@ void usbd_event_handler(uint8_t event) } } -void usbd_audio_open(uint8_t intf) +void usbd_audio_open(uint8_t busid, uint8_t intf) { if (intf == 1) { rx_flag = 1; /* setup first out ep read transfer */ - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); printf("OPEN1\r\n"); } else { tx_flag = 1; @@ -185,7 +187,7 @@ void usbd_audio_open(uint8_t intf) } } -void usbd_audio_close(uint8_t intf) +void usbd_audio_close(uint8_t busid, uint8_t intf) { if (intf == 1) { rx_flag = 1; @@ -196,13 +198,13 @@ void usbd_audio_close(uint8_t intf) } } -void usbd_audio_out_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_out_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); } -void usbd_audio_in_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_in_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); ep_tx_busy_flag = false; @@ -233,14 +235,14 @@ struct audio_entity_info audio_entity_table[] = { void audio_v1_init(void) { - usbd_desc_register(audio_v1_descriptor); - usbd_add_interface(usbd_audio_init_intf(&intf0, 0x0100, audio_entity_table, 2)); - usbd_add_interface(usbd_audio_init_intf(&intf1, 0x0100, audio_entity_table, 2)); - usbd_add_interface(usbd_audio_init_intf(&intf2, 0x0100, audio_entity_table, 2)); - usbd_add_endpoint(&audio_in_ep); - usbd_add_endpoint(&audio_out_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, audio_v1_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, 0x0100, audio_entity_table, 2)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, 0x0100, audio_entity_table, 2)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf2, 0x0100, audio_entity_table, 2)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_in_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_out_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } void audio_v1_test(void) @@ -248,7 +250,7 @@ void audio_v1_test(void) if (tx_flag) { memset(write_buffer, 'a', AUDIO_IN_PACKET); ep_tx_busy_flag = true; - usbd_ep_start_write(AUDIO_IN_EP, write_buffer, AUDIO_IN_PACKET); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, AUDIO_IN_EP, write_buffer, AUDIO_IN_PACKET); while (ep_tx_busy_flag) { if (tx_flag == false) { break; diff --git a/demo/audio_v2_mic_multichan_template.c b/demo/audio_v2_mic_multichan_template.c index 8c83c9eb..5a120316 100644 --- a/demo/audio_v2_mic_multichan_template.c +++ b/demo/audio_v2_mic_multichan_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_audio.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -159,7 +161,7 @@ static const uint8_t mic_default_sampling_freq_table[] = { volatile bool tx_flag = 0; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -184,26 +186,26 @@ void usbd_event_handler(uint8_t event) } } -void usbd_audio_open(uint8_t intf) +void usbd_audio_open(uint8_t busid, uint8_t intf) { tx_flag = 1; USB_LOG_RAW("OPEN\r\n"); } -void usbd_audio_close(uint8_t intf) +void usbd_audio_close(uint8_t busid, uint8_t intf) { USB_LOG_RAW("CLOSE\r\n"); tx_flag = 0; } -void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_table) +void usbd_audio_get_sampling_freq_table(uint8_t busid, uint8_t ep, uint8_t **sampling_freq_table) { if (ep == AUDIO_IN_EP) { *sampling_freq_table = (uint8_t *)mic_default_sampling_freq_table; } } -void usbd_audio_iso_in_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_iso_in_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { } @@ -226,12 +228,12 @@ struct audio_entity_info audio_entity_table[] = { void audio_v2_init(void) { - usbd_desc_register(audio_v2_descriptor); - usbd_add_interface(usbd_audio_init_intf(&intf0, 0x0200, audio_entity_table, 2)); - usbd_add_interface(usbd_audio_init_intf(&intf1, 0x0200, audio_entity_table, 2)); - usbd_add_endpoint(&audio_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, audio_v2_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, 0x0200, audio_entity_table, 2)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, 0x0200, audio_entity_table, 2)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } void audio_v2_test(void) diff --git a/demo/audio_v2_mic_speaker_multichan_template.c b/demo/audio_v2_mic_speaker_multichan_template.c index 3d0eead7..9d73607a 100644 --- a/demo/audio_v2_mic_speaker_multichan_template.c +++ b/demo/audio_v2_mic_speaker_multichan_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_audio.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -229,7 +231,7 @@ USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[AUDIO_IN_PACKET]; volatile bool tx_flag = 0; volatile bool rx_flag = 0; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -254,12 +256,12 @@ void usbd_event_handler(uint8_t event) } } -void usbd_audio_open(uint8_t intf) +void usbd_audio_open(uint8_t busid, uint8_t intf) { if (intf == 1) { rx_flag = 1; /* setup first out ep read transfer */ - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); USB_LOG_RAW("OPEN1\r\n"); } else { tx_flag = 1; @@ -267,7 +269,7 @@ void usbd_audio_open(uint8_t intf) } } -void usbd_audio_close(uint8_t intf) +void usbd_audio_close(uint8_t busid, uint8_t intf) { if (intf == 1) { rx_flag = 1; @@ -278,7 +280,7 @@ void usbd_audio_close(uint8_t intf) } } -void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_table) +void usbd_audio_get_sampling_freq_table(uint8_t busid, uint8_t ep, uint8_t **sampling_freq_table) { if (ep == AUDIO_OUT_EP) { *sampling_freq_table = (uint8_t *)speaker_default_sampling_freq_table; @@ -288,7 +290,7 @@ void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_tabl } } -void usbd_audio_set_sampling_freq(uint8_t ep, uint32_t sampling_freq) +void usbd_audio_set_sampling_freq(uint8_t busid, uint8_t ep, uint32_t sampling_freq) { uint16_t packet_size = 0; if (ep == AUDIO_OUT_EP) { @@ -302,13 +304,13 @@ void usbd_audio_set_sampling_freq(uint8_t ep, uint32_t sampling_freq) } } -void usbd_audio_iso_out_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_iso_out_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); } -void usbd_audio_iso_in_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_iso_in_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { } @@ -343,14 +345,14 @@ struct audio_entity_info audio_entity_table[] = { void audio_v2_init(void) { - usbd_desc_register(audio_v2_descriptor); - usbd_add_interface(usbd_audio_init_intf(&intf0, 0x0200, audio_entity_table, 4)); - usbd_add_interface(usbd_audio_init_intf(&intf1, 0x0200, audio_entity_table, 4)); - usbd_add_interface(usbd_audio_init_intf(&intf2, 0x0200, audio_entity_table, 4)); - usbd_add_endpoint(&audio_in_ep); - usbd_add_endpoint(&audio_out_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, audio_v2_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, 0x0200, audio_entity_table, 4)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, 0x0200, audio_entity_table, 4)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf2, 0x0200, audio_entity_table, 4)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_in_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_out_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } void audio_v2_test(void) diff --git a/demo/audio_v2_speaker_multichan_template.c b/demo/audio_v2_speaker_multichan_template.c index 84301502..4124f7dd 100644 --- a/demo/audio_v2_speaker_multichan_template.c +++ b/demo/audio_v2_speaker_multichan_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_audio.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -173,7 +175,7 @@ USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t read_buffer[AUDIO_OUT_PACKET]; volatile bool rx_flag = 0; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -198,31 +200,31 @@ void usbd_event_handler(uint8_t event) } } -void usbd_audio_open(uint8_t intf) +void usbd_audio_open(uint8_t busid, uint8_t intf) { rx_flag = 1; /* setup first out ep read transfer */ - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); USB_LOG_RAW("OPEN\r\n"); } -void usbd_audio_close(uint8_t intf) +void usbd_audio_close(uint8_t busid, uint8_t intf) { USB_LOG_RAW("CLOSE\r\n"); rx_flag = 0; } -void usbd_audio_get_sampling_freq_table(uint8_t ep, uint8_t **sampling_freq_table) +void usbd_audio_get_sampling_freq_table(uint8_t busid, uint8_t ep, uint8_t **sampling_freq_table) { if (ep == AUDIO_OUT_EP) { *sampling_freq_table = (uint8_t *)default_sampling_freq_table; } } -void usbd_audio_iso_out_callback(uint8_t ep, uint32_t nbytes) +void usbd_audio_iso_out_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); - usbd_ep_start_read(AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, AUDIO_OUT_EP, read_buffer, AUDIO_OUT_PACKET); } static struct usbd_endpoint audio_out_ep = { @@ -244,12 +246,12 @@ struct audio_entity_info audio_entity_table[] = { void audio_v2_init(void) { - usbd_desc_register(audio_v2_descriptor); - usbd_add_interface(usbd_audio_init_intf(&intf0, 0x0200, audio_entity_table, 2)); - usbd_add_interface(usbd_audio_init_intf(&intf1, 0x0200, audio_entity_table, 2)); - usbd_add_endpoint(&audio_out_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, audio_v2_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, 0x0200, audio_entity_table, 2)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_audio_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, 0x0200, audio_entity_table, 2)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &audio_out_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } void audio_v2_test(void) diff --git a/demo/cdc_acm_hid_msc_template.c b/demo/cdc_acm_hid_msc_template.c index 9566d2f1..096f079c 100644 --- a/demo/cdc_acm_hid_msc_template.c +++ b/demo/cdc_acm_hid_msc_template.c @@ -3,6 +3,8 @@ #include "usbd_cdc.h" #include "usbd_hid.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< endpoint address */ #define CDC_IN_EP 0x81 #define CDC_OUT_EP 0x02 @@ -216,7 +218,7 @@ static struct hid_mouse mouse_cfg; static volatile uint8_t hid_state = HID_STATE_IDLE; /* function ------------------------------------------------------------------*/ -static void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes) +static void usbd_hid_int_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { hid_state = HID_STATE_IDLE; } @@ -238,7 +240,7 @@ volatile bool ep_tx_busy_flag = false; #define CDC_MAX_MPS 64 #endif -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -253,7 +255,7 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); break; case USBD_EVENT_SET_REMOTE_WAKEUP: break; @@ -265,20 +267,20 @@ void usbd_event_handler(uint8_t event) } } -void usbd_cdc_acm_bulk_out(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); /* setup next out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); } -void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); if ((nbytes % CDC_MAX_MPS) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(CDC_IN_EP, NULL, 0); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, NULL, 0); } else { ep_tx_busy_flag = false; } @@ -302,17 +304,17 @@ struct usbd_interface intf3; void cdc_acm_hid_msc_descriptor_init(void) { - usbd_desc_register(cdc_acm_hid_msc_descriptor); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, cdc_acm_hid_msc_descriptor); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf0)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf1)); - usbd_add_endpoint(&cdc_out_ep); - usbd_add_endpoint(&cdc_in_ep); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep); - usbd_add_interface(usbd_msc_init_intf(&intf2, MSC_OUT_EP, MSC_IN_EP)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_msc_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf2, MSC_OUT_EP, MSC_IN_EP)); - usbd_add_interface(usbd_hid_init_intf(&intf3, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE)); - usbd_add_endpoint(&hid_in_ep); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_hid_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf3, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &hid_in_ep); /*!< init mouse report data */ mouse_cfg.buttons = 0; @@ -320,7 +322,7 @@ void cdc_acm_hid_msc_descriptor_init(void) mouse_cfg.x = 0; mouse_cfg.y = 0; - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } /** @@ -334,7 +336,7 @@ void hid_mouse_test(void) /*!< move mouse pointer */ mouse_cfg.x += 10; mouse_cfg.y = 0; - int ret = usbd_ep_start_write(HID_INT_EP, (uint8_t *)&mouse_cfg, 4); + int ret = usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, HID_INT_EP, (uint8_t *)&mouse_cfg, 4); if (ret < 0) { return; } @@ -345,7 +347,7 @@ void hid_mouse_test(void) volatile uint8_t dtr_enable = 0; -void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr) +void usbd_cdc_acm_set_dtr(uint8_t busid, uint8_t intf, bool dtr) { if (dtr) { dtr_enable = 1; @@ -359,7 +361,7 @@ void cdc_acm_data_send_with_dtr_test(void) if (dtr_enable) { memset(&write_buffer[10], 'a', 2038); ep_tx_busy_flag = true; - usbd_ep_start_write(CDC_IN_EP, write_buffer, 2048); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, write_buffer, 2048); while (ep_tx_busy_flag) { } } @@ -375,19 +377,19 @@ typedef struct BLOCK_TYPE mass_block[BLOCK_COUNT]; -void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint32_t *block_size) +void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size) { *block_num = 1000; //Pretend having so many buffer,not has actually. *block_size = BLOCK_SIZE; } -int usbd_msc_sector_read(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < 10) memcpy(buffer, mass_block[sector].BlockSpace, length); return 0; } -int usbd_msc_sector_write(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < 10) memcpy(mass_block[sector].BlockSpace, buffer, length); diff --git a/demo/cdc_acm_msc_template.c b/demo/cdc_acm_msc_template.c index 888298b5..44d9283a 100644 --- a/demo/cdc_acm_msc_template.c +++ b/demo/cdc_acm_msc_template.c @@ -2,6 +2,8 @@ #include "usbd_cdc.h" #include "usbd_msc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< endpoint address */ #define CDC_IN_EP 0x81 #define CDC_OUT_EP 0x02 @@ -249,7 +251,7 @@ volatile bool ep_tx_busy_flag = false; #define CDC_MAX_MPS 64 #endif -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -264,7 +266,7 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); break; case USBD_EVENT_SET_REMOTE_WAKEUP: break; @@ -276,20 +278,20 @@ void usbd_event_handler(uint8_t event) } } -void usbd_cdc_acm_bulk_out(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); /* setup next out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); } -void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); if ((nbytes % CDC_MAX_MPS) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(CDC_IN_EP, NULL, 0); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, NULL, 0); } else { ep_tx_busy_flag = false; } @@ -313,22 +315,22 @@ struct usbd_interface intf2; void cdc_acm_msc_init(void) { #ifdef CONFIG_USBDEV_ADVANCE_DESC - usbd_desc_register(&cdc_msc_descriptor); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, &cdc_msc_descriptor); #else - usbd_desc_register(cdc_msc_descriptor); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, cdc_msc_descriptor); #endif - usbd_add_interface(usbd_cdc_acm_init_intf(&intf0)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf1)); - usbd_add_endpoint(&cdc_out_ep); - usbd_add_endpoint(&cdc_in_ep); - usbd_add_interface(usbd_msc_init_intf(&intf2, MSC_OUT_EP, MSC_IN_EP)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_msc_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf2, MSC_OUT_EP, MSC_IN_EP)); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } volatile uint8_t dtr_enable = 0; -void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr) +void usbd_cdc_acm_set_dtr(uint8_t busid, uint8_t intf, bool dtr) { if (dtr) { dtr_enable = 1; @@ -342,7 +344,7 @@ void cdc_acm_data_send_with_dtr_test(void) if (dtr_enable) { memset(&write_buffer[10], 'a', 2038); ep_tx_busy_flag = true; - usbd_ep_start_write(CDC_IN_EP, write_buffer, 2048); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, write_buffer, 2048); while (ep_tx_busy_flag) { } } @@ -358,19 +360,19 @@ typedef struct BLOCK_TYPE mass_block[BLOCK_COUNT]; -void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint32_t *block_size) +void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size) { *block_num = 1000; //Pretend having so many buffer,not has actually. *block_size = BLOCK_SIZE; } -int usbd_msc_sector_read(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < 10) memcpy(buffer, mass_block[sector].BlockSpace, length); return 0; } -int usbd_msc_sector_write(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < 10) memcpy(mass_block[sector].BlockSpace, buffer, length); diff --git a/demo/cdc_acm_multi_template.c b/demo/cdc_acm_multi_template.c index 3b9f083f..5c78fec8 100644 --- a/demo/cdc_acm_multi_template.c +++ b/demo/cdc_acm_multi_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_cdc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< endpoint address */ #define CDC_IN_EP 0x81 #define CDC_OUT_EP 0x01 @@ -125,7 +127,7 @@ volatile bool ep_tx_busy_flag = false; #define CDC_MAX_MPS 64 #endif -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -140,10 +142,10 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); - usbd_ep_start_read(CDC_OUT_EP2, read_buffer, 2048); - usbd_ep_start_read(CDC_OUT_EP3, read_buffer, 2048); - usbd_ep_start_read(CDC_OUT_EP4, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP2, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP3, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP4, read_buffer, 2048); break; case USBD_EVENT_SET_REMOTE_WAKEUP: break; @@ -155,14 +157,14 @@ void usbd_event_handler(uint8_t event) } } -void usbd_cdc_acm_bulk_out(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); /* setup next out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); } -void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); @@ -225,27 +227,27 @@ struct usbd_interface intf7; void cdc_acm_multi_init(void) { - usbd_desc_register(cdc_descriptor); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, cdc_descriptor); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf0)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf1)); - usbd_add_endpoint(&cdc_out_ep1); - usbd_add_endpoint(&cdc_in_ep1); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep1); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep1); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf2)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf3)); - usbd_add_endpoint(&cdc_out_ep2); - usbd_add_endpoint(&cdc_in_ep2); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf2)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf3)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep2); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep2); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf4)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf5)); - usbd_add_endpoint(&cdc_out_ep3); - usbd_add_endpoint(&cdc_in_ep3); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf4)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf5)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep3); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep3); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf6)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf7)); - usbd_add_endpoint(&cdc_out_ep4); - usbd_add_endpoint(&cdc_in_ep4); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf6)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf7)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep4); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep4); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } \ No newline at end of file diff --git a/demo/cdc_acm_template.c b/demo/cdc_acm_template.c index a8933b81..428bdddd 100644 --- a/demo/cdc_acm_template.c +++ b/demo/cdc_acm_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_cdc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< endpoint address */ #define CDC_IN_EP 0x81 #define CDC_OUT_EP 0x02 @@ -110,7 +112,7 @@ volatile bool ep_tx_busy_flag = false; #define CDC_MAX_MPS 64 #endif -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -125,7 +127,7 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); break; case USBD_EVENT_SET_REMOTE_WAKEUP: break; @@ -137,7 +139,7 @@ void usbd_event_handler(uint8_t event) } } -void usbd_cdc_acm_bulk_out(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); // for (int i = 0; i < 100; i++) { @@ -145,16 +147,16 @@ void usbd_cdc_acm_bulk_out(uint8_t ep, uint32_t nbytes) // } // printf("\r\n"); /* setup next out ep read transfer */ - usbd_ep_start_read(CDC_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, CDC_OUT_EP, read_buffer, 2048); } -void usbd_cdc_acm_bulk_in(uint8_t ep, uint32_t nbytes) +void usbd_cdc_acm_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); if ((nbytes % CDC_MAX_MPS) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(CDC_IN_EP, NULL, 0); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, NULL, 0); } else { ep_tx_busy_flag = false; } @@ -181,17 +183,17 @@ void cdc_acm_init(void) memcpy(&write_buffer[0], data, 10); memset(&write_buffer[10], 'a', 2038); - usbd_desc_register(cdc_descriptor); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf0)); - usbd_add_interface(usbd_cdc_acm_init_intf(&intf1)); - usbd_add_endpoint(&cdc_out_ep); - usbd_add_endpoint(&cdc_in_ep); - usbd_initialize(); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, cdc_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_cdc_acm_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_out_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &cdc_in_ep); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } volatile uint8_t dtr_enable = 0; -void usbd_cdc_acm_set_dtr(uint8_t intf, bool dtr) +void usbd_cdc_acm_set_dtr(uint8_t busid, uint8_t intf, bool dtr) { if (dtr) { dtr_enable = 1; @@ -204,7 +206,7 @@ void cdc_acm_data_send_with_dtr_test(void) { if (dtr_enable) { ep_tx_busy_flag = true; - usbd_ep_start_write(CDC_IN_EP, write_buffer, 2048); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, CDC_IN_EP, write_buffer, 2048); while (ep_tx_busy_flag) { } } diff --git a/demo/cdc_ecm_template.c b/demo/cdc_ecm_template.c index 87300078..cd450202 100644 --- a/demo/cdc_ecm_template.c +++ b/demo/cdc_ecm_template.c @@ -230,7 +230,7 @@ void cdc_ecm_input_poll(void) cdc_ecm_if_input(&cdc_ecm_netif); } -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -267,8 +267,8 @@ void cdc_ecm_init(void) { cdc_ecm_lwip_init(); - usbd_desc_register(cdc_ecm_descriptor); - usbd_add_interface(usbd_cdc_ecm_init_intf(&intf0, CDC_INT_EP, CDC_OUT_EP, CDC_IN_EP)); - usbd_add_interface(usbd_cdc_ecm_init_intf(&intf1, CDC_INT_EP, CDC_OUT_EP, CDC_IN_EP)); - usbd_initialize(); + usbd_desc_register(0, cdc_ecm_descriptor); + usbd_add_interface(0, usbd_cdc_ecm_init_intf(0, &intf0, CDC_INT_EP, CDC_OUT_EP, CDC_IN_EP)); + usbd_add_interface(0, usbd_cdc_ecm_init_intf(0, &intf1, CDC_INT_EP, CDC_OUT_EP, CDC_IN_EP)); + usbd_initialize(0, usbd_event_handler); } \ No newline at end of file diff --git a/demo/cdc_rndis_template.c b/demo/cdc_rndis_template.c index c41bca7f..df9beb64 100644 --- a/demo/cdc_rndis_template.c +++ b/demo/cdc_rndis_template.c @@ -263,7 +263,7 @@ void rndis_input_poll(void) } #endif /* RT_USING_LWIP */ -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -301,8 +301,8 @@ void cdc_rndis_init(void) #else rndis_lwip_init(); #endif - usbd_desc_register(cdc_descriptor); - usbd_add_interface(usbd_rndis_init_intf(&intf0, CDC_OUT_EP, CDC_IN_EP, CDC_INT_EP, mac)); - usbd_add_interface(usbd_rndis_init_intf(&intf1, CDC_OUT_EP, CDC_IN_EP, CDC_INT_EP, mac)); - usbd_initialize(); + usbd_desc_register(0, cdc_descriptor); + usbd_add_interface(0, usbd_rndis_init_intf(&intf0, CDC_OUT_EP, CDC_IN_EP, CDC_INT_EP, mac)); + usbd_add_interface(0, usbd_rndis_init_intf(&intf1, CDC_OUT_EP, CDC_IN_EP, CDC_INT_EP, mac)); + usbd_initialize(0, usbd_event_handler); } diff --git a/demo/dfu_with_st_tool_template.c b/demo/dfu_with_st_tool_template.c index fbf70b4c..37d627b9 100644 --- a/demo/dfu_with_st_tool_template.c +++ b/demo/dfu_with_st_tool_template.c @@ -137,7 +137,7 @@ const uint8_t dfu_flash_descriptor[] = { 0x00 }; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -166,7 +166,7 @@ struct usbd_interface intf0; void dfu_flash_init(void) { - usbd_desc_register(dfu_flash_descriptor); - usbd_add_interface(usbd_dfu_init_intf(&intf0)); - usbd_initialize(); + usbd_desc_register(0, dfu_flash_descriptor); + usbd_add_interface(0, usbd_dfu_init_intf(&intf0)); + usbd_initialize(0, usbd_event_handler); } diff --git a/demo/hid_custom_inout_template.c b/demo/hid_custom_inout_template.c index d2a44845..eb25732a 100644 --- a/demo/hid_custom_inout_template.c +++ b/demo/hid_custom_inout_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_hid.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< hidraw in endpoint */ #define HIDRAW_IN_EP 0x81 #define HIDRAW_IN_EP_SIZE 64 @@ -169,7 +171,7 @@ USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t send_buffer[HIDRAW_IN_EP_SIZE]; /*!< hid state ! Data can be sent only when state is idle */ static volatile uint8_t custom_state; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -184,7 +186,7 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(HIDRAW_OUT_EP, read_buffer, HIDRAW_OUT_EP_SIZE); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, HIDRAW_OUT_EP, read_buffer, HIDRAW_OUT_EP_SIZE); break; case USBD_EVENT_SET_REMOTE_WAKEUP: break; @@ -196,18 +198,18 @@ void usbd_event_handler(uint8_t event) } } -static void usbd_hid_custom_in_callback(uint8_t ep, uint32_t nbytes) +static void usbd_hid_custom_in_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); custom_state = HID_STATE_IDLE; } -static void usbd_hid_custom_out_callback(uint8_t ep, uint32_t nbytes) +static void usbd_hid_custom_out_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); - usbd_ep_start_read(HIDRAW_OUT_EP, read_buffer, 64); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, HIDRAW_OUT_EP, read_buffer, 64); read_buffer[0] = 0x02; /* IN: report id */ - usbd_ep_start_write(HIDRAW_IN_EP, read_buffer, nbytes); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, HIDRAW_IN_EP, read_buffer, nbytes); } static struct usbd_endpoint custom_in_ep = { @@ -231,10 +233,10 @@ struct usbd_interface intf0; void hid_custom_init(void) { - usbd_desc_register(hid_descriptor); - usbd_add_interface(usbd_hid_init_intf(&intf0, hid_custom_report_desc, HID_CUSTOM_REPORT_DESC_SIZE)); - usbd_add_endpoint(&custom_in_ep); - usbd_add_endpoint(&custom_out_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, hid_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_hid_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, hid_custom_report_desc, HID_CUSTOM_REPORT_DESC_SIZE)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &custom_in_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &custom_out_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } diff --git a/demo/hid_keyboard_template.c b/demo/hid_keyboard_template.c index 214c5978..c5940aea 100644 --- a/demo/hid_keyboard_template.c +++ b/demo/hid_keyboard_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_hid.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define USBD_VID 0xffff #define USBD_PID 0xffff #define USBD_MAX_POWER 100 @@ -172,7 +174,7 @@ static const uint8_t hid_keyboard_report_desc[HID_KEYBOARD_REPORT_DESC_SIZE] = { 0xc0 // END_COLLECTION }; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -203,7 +205,7 @@ void usbd_event_handler(uint8_t event) /*!< hid state ! Data can be sent only when state is idle */ static volatile uint8_t hid_state = HID_STATE_IDLE; -void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes) +void usbd_hid_int_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { hid_state = HID_STATE_IDLE; } @@ -217,11 +219,11 @@ struct usbd_interface intf0; void hid_keyboard_init(void) { - usbd_desc_register(hid_descriptor); - usbd_add_interface(usbd_hid_init_intf(&intf0, hid_keyboard_report_desc, HID_KEYBOARD_REPORT_DESC_SIZE)); - usbd_add_endpoint(&hid_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, hid_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_hid_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, hid_keyboard_report_desc, HID_KEYBOARD_REPORT_DESC_SIZE)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &hid_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[64]; @@ -231,7 +233,7 @@ void hid_keyboard_test(void) const uint8_t sendbuffer[8] = { 0x00, 0x00, HID_KBD_USAGE_A, 0x00, 0x00, 0x00, 0x00, 0x00 }; memcpy(write_buffer, sendbuffer, 8); - int ret = usbd_ep_start_write(HID_INT_EP, write_buffer, 8); + int ret = usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, HID_INT_EP, write_buffer, 8); if (ret < 0) { return; } diff --git a/demo/hid_mouse_template.c b/demo/hid_mouse_template.c index 38be541c..1aef2ad2 100644 --- a/demo/hid_mouse_template.c +++ b/demo/hid_mouse_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_hid.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + /*!< endpoint address */ #define HID_INT_EP 0x81 #define HID_INT_EP_SIZE 4 @@ -194,7 +196,7 @@ static USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX struct hid_mouse mouse_cfg; /*!< hid state ! Data can be sent only when state is idle */ static volatile uint8_t hid_state = HID_STATE_IDLE; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -220,7 +222,7 @@ void usbd_event_handler(uint8_t event) } /* function ------------------------------------------------------------------*/ -static void usbd_hid_int_callback(uint8_t ep, uint32_t nbytes) +static void usbd_hid_int_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { hid_state = HID_STATE_IDLE; } @@ -235,11 +237,11 @@ struct usbd_interface intf0; void hid_mouse_init(void) { - usbd_desc_register(hid_descriptor); - usbd_add_interface(usbd_hid_init_intf(&intf0, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE)); - usbd_add_endpoint(&hid_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, hid_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_hid_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, hid_mouse_report_desc, HID_MOUSE_REPORT_DESC_SIZE)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &hid_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); /*!< init mouse report data */ mouse_cfg.buttons = 0; @@ -262,7 +264,7 @@ void hid_mouse_test(void) mouse_cfg.x += 40; mouse_cfg.y += 0; - int ret = usbd_ep_start_write(HID_INT_EP, (uint8_t *)&mouse_cfg, 4); + int ret = usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, HID_INT_EP, (uint8_t *)&mouse_cfg, 4); if (ret < 0) { return; } diff --git a/demo/midi_template.c b/demo/midi_template.c index 422e7800..a4271b8f 100644 --- a/demo/midi_template.c +++ b/demo/midi_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usb_midi.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define MIDI_OUT_EP 0x02 #define MIDI_IN_EP 0x81 @@ -146,7 +148,7 @@ const uint8_t midi_descriptor[] = { 0x00 }; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -171,11 +173,11 @@ void usbd_event_handler(uint8_t event) } } -void usbd_midi_bulk_out(uint8_t ep, uint32_t nbytes) +void usbd_midi_bulk_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { } -void usbd_midi_bulk_in(uint8_t ep, uint32_t nbytes) +void usbd_midi_bulk_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { } @@ -194,11 +196,11 @@ struct usbd_endpoint midi_in_ep = { void midi_init(void) { - usbd_desc_register(midi_descriptor); - usbd_add_interface(&intf0); - usbd_add_interface(&intf1); - usbd_add_endpoint(&midi_out_ep); - usbd_add_endpoint(&midi_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, midi_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, &intf0); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, &intf1); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &midi_out_ep); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &midi_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } \ No newline at end of file diff --git a/demo/msc_ram_template.c b/demo/msc_ram_template.c index 1e291e6e..c2b8318a 100644 --- a/demo/msc_ram_template.c +++ b/demo/msc_ram_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_msc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define MSC_IN_EP 0x81 #define MSC_OUT_EP 0x02 @@ -95,7 +97,7 @@ const uint8_t msc_ram_descriptor[] = { 0x00 }; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -130,19 +132,19 @@ typedef struct BLOCK_TYPE mass_block[BLOCK_COUNT]; -void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint32_t *block_size) +void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size) { *block_num = 1000; //Pretend having so many buffer,not has actually. *block_size = BLOCK_SIZE; } -int usbd_msc_sector_read(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < BLOCK_COUNT) memcpy(buffer, mass_block[sector].BlockSpace, length); return 0; } -int usbd_msc_sector_write(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { if (sector < BLOCK_COUNT) memcpy(mass_block[sector].BlockSpace, buffer, length); @@ -153,8 +155,8 @@ struct usbd_interface intf0; void msc_ram_init(void) { - usbd_desc_register(msc_ram_descriptor); - usbd_add_interface(usbd_msc_init_intf(&intf0, MSC_OUT_EP, MSC_IN_EP)); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, msc_ram_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_msc_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, MSC_OUT_EP, MSC_IN_EP)); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } diff --git a/demo/msc_storage_template.c b/demo/msc_storage_template.c index a5dd8df6..f6f86e6f 100644 --- a/demo/msc_storage_template.c +++ b/demo/msc_storage_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_msc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #ifdef __RT_THREAD_H__ #define MSC_IN_EP 0x81 @@ -106,7 +108,7 @@ struct usbd_interface intf0; #define BLOCK_COUNT 0x1024U * 0x1024U static rt_device_t blk_dev = RT_NULL; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -131,19 +133,19 @@ void usbd_event_handler(uint8_t event) } } -void usbd_msc_get_cap(uint8_t lun, uint32_t *block_num, uint32_t *block_size) +void usbd_msc_get_cap(uint8_t busid, uint8_t lun, uint32_t *block_num, uint32_t *block_size) { *block_num = BLOCK_COUNT; *block_size = BLOCK_SIZE; } -int usbd_msc_sector_read(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_read(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { rt_device_read(blk_dev, sector, buffer, length / BLOCK_SIZE); return 0; } -int usbd_msc_sector_write(uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) +int usbd_msc_sector_write(uint8_t busid, uint8_t lun, uint32_t sector, uint8_t *buffer, uint32_t length) { rt_device_write(blk_dev, sector, buffer, length / BLOCK_SIZE); return 0; @@ -159,9 +161,9 @@ void msc_storage_init(void) res = rt_device_open(blk_dev, RT_DEVICE_OFLAG_RDWR); RT_ASSERT(res == RT_EOK); - usbd_desc_register(msc_storage_descriptor); - usbd_add_interface(usbd_msc_init_intf(&intf0, MSC_OUT_EP, MSC_IN_EP)); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, msc_storage_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_msc_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, MSC_OUT_EP, MSC_IN_EP)); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } #endif \ No newline at end of file diff --git a/demo/video_static_mjpeg_template.c b/demo/video_static_mjpeg_template.c index 4079f123..40d0d365 100644 --- a/demo/video_static_mjpeg_template.c +++ b/demo/video_static_mjpeg_template.c @@ -2,6 +2,8 @@ #include "usbd_video.h" #include "pic_data.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define VIDEO_IN_EP 0x81 #ifdef CONFIG_USB_HS @@ -141,7 +143,7 @@ const uint8_t video_descriptor[] = { 0x00 }; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -169,20 +171,20 @@ void usbd_event_handler(uint8_t event) volatile bool tx_flag = 0; volatile bool iso_tx_busy = false; -void usbd_video_open(uint8_t intf) +void usbd_video_open(uint8_t busid, uint8_t intf) { tx_flag = 1; USB_LOG_RAW("OPEN\r\n"); iso_tx_busy = false; } -void usbd_video_close(uint8_t intf) +void usbd_video_close(uint8_t busid, uint8_t intf) { USB_LOG_RAW("CLOSE\r\n"); tx_flag = 0; iso_tx_busy = false; } -void usbd_video_iso_callback(uint8_t ep, uint32_t nbytes) +void usbd_video_iso_callback(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); iso_tx_busy = false; @@ -198,12 +200,12 @@ struct usbd_interface intf1; void video_init() { - usbd_desc_register(video_descriptor); - usbd_add_interface(usbd_video_init_intf(&intf0, INTERVAL, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE)); - usbd_add_interface(usbd_video_init_intf(&intf1, INTERVAL, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE)); - usbd_add_endpoint(&video_in_ep); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, video_descriptor); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_video_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf0, INTERVAL, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE)); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, usbd_video_init_intf(CONFIG_USBDEV_DEMO_BUS, &intf1, INTERVAL, MAX_FRAME_SIZE, MAX_PAYLOAD_SIZE)); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &video_in_ep); - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t packet_buffer[10 * 1024]; @@ -215,10 +217,10 @@ void video_test() memset(packet_buffer, 0, 10 * 1024); while (1) { if (tx_flag) { - packets = usbd_video_mjpeg_payload_fill((uint8_t *)jpeg_data, sizeof(jpeg_data), packet_buffer, &out_len); + packets = usbd_video_mjpeg_payload_fill(CONFIG_USBDEV_DEMO_BUS, (uint8_t *)jpeg_data, sizeof(jpeg_data), packet_buffer, &out_len); #if 0 iso_tx_busy = true; - usbd_ep_start_write(VIDEO_IN_EP, packet_buffer, out_len); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, VIDEO_IN_EP, packet_buffer, out_len); while (iso_tx_busy) { if (tx_flag == 0) { break; @@ -229,7 +231,7 @@ void video_test() for (uint32_t i = 0; i < packets; i++) { if (i == (packets - 1)) { iso_tx_busy = true; - usbd_ep_start_write(VIDEO_IN_EP, &packet_buffer[i * MAX_PAYLOAD_SIZE], out_len - (packets - 1) * MAX_PAYLOAD_SIZE); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, VIDEO_IN_EP, &packet_buffer[i * MAX_PAYLOAD_SIZE], out_len - (packets - 1) * MAX_PAYLOAD_SIZE); while (iso_tx_busy) { if (tx_flag == 0) { break; @@ -237,7 +239,7 @@ void video_test() } } else { iso_tx_busy = true; - usbd_ep_start_write(VIDEO_IN_EP, &packet_buffer[i * MAX_PAYLOAD_SIZE], MAX_PAYLOAD_SIZE); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, VIDEO_IN_EP, &packet_buffer[i * MAX_PAYLOAD_SIZE], MAX_PAYLOAD_SIZE); while (iso_tx_busy) { if (tx_flag == 0) { break; diff --git a/demo/winusb1.0_template.c b/demo/winusb1.0_template.c index 8f912618..42b5e79f 100644 --- a/demo/winusb1.0_template.c +++ b/demo/winusb1.0_template.c @@ -1,6 +1,8 @@ #include "usbd_core.h" #include "usbd_cdc.h" +#define CONFIG_USBDEV_DEMO_BUS 0 + #define WCID_VENDOR_CODE 0x17 #define DOUBLE_WINUSB 0 @@ -334,7 +336,7 @@ USB_NOCACHE_RAM_SECTION USB_MEM_ALIGNX uint8_t write_buffer[2048]; volatile bool ep_tx_busy_flag = false; -void usbd_event_handler(uint8_t event) +static void usbd_event_handler(uint8_t event) { switch (event) { case USBD_EVENT_RESET: @@ -349,9 +351,9 @@ void usbd_event_handler(uint8_t event) break; case USBD_EVENT_CONFIGURED: /* setup first out ep read transfer */ - usbd_ep_start_read(WINUSB_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, WINUSB_OUT_EP, read_buffer, 2048); #if DOUBLE_WINUSB == 1 - usbd_ep_start_read(WINUSB_OUT_EP2, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, WINUSB_OUT_EP2, read_buffer, 2048); #endif break; case USBD_EVENT_SET_REMOTE_WAKEUP: @@ -364,25 +366,25 @@ void usbd_event_handler(uint8_t event) } } -void usbd_winusb_out(uint8_t ep, uint32_t nbytes) +void usbd_winusb_out(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); // for (int i = 0; i < 100; i++) { // printf("%02x ", read_buffer[i]); // } // printf("\r\n"); - usbd_ep_start_write(WINUSB_IN_EP, read_buffer, nbytes); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, WINUSB_IN_EP, read_buffer, nbytes); /* setup next out ep read transfer */ - usbd_ep_start_read(WINUSB_OUT_EP, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, WINUSB_OUT_EP, read_buffer, 2048); } -void usbd_winusb_in(uint8_t ep, uint32_t nbytes) +void usbd_winusb_in(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); if ((nbytes % WINUSB_EP_MPS) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(WINUSB_IN_EP, NULL, 0); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, WINUSB_IN_EP, NULL, 0); } else { ep_tx_busy_flag = false; } @@ -402,25 +404,25 @@ struct usbd_interface intf0; #if DOUBLE_WINUSB == 1 -void usbd_winusb_out2(uint8_t ep, uint32_t nbytes) +void usbd_winusb_out2(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual out len:%d\r\n", nbytes); // for (int i = 0; i < 100; i++) { // printf("%02x ", read_buffer[i]); // } // printf("\r\n"); - usbd_ep_start_write(WINUSB_IN_EP2, read_buffer, nbytes); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, WINUSB_IN_EP2, read_buffer, nbytes); /* setup next out ep read transfer */ - usbd_ep_start_read(WINUSB_OUT_EP2, read_buffer, 2048); + usbd_ep_start_read(CONFIG_USBDEV_DEMO_BUS, WINUSB_OUT_EP2, read_buffer, 2048); } -void usbd_winusb_in2(uint8_t ep, uint32_t nbytes) +void usbd_winusb_in2(uint8_t busid, uint8_t ep, uint32_t nbytes) { USB_LOG_RAW("actual in len:%d\r\n", nbytes); if ((nbytes % WINUSB_EP_MPS) == 0 && nbytes) { /* send zlp */ - usbd_ep_start_write(WINUSB_IN_EP2, NULL, 0); + usbd_ep_start_write(CONFIG_USBDEV_DEMO_BUS, WINUSB_IN_EP2, NULL, 0); } else { ep_tx_busy_flag = false; } @@ -442,15 +444,15 @@ struct usbd_interface intf1; void winusb_init(void) { - usbd_desc_register(winusb_descriptor); - usbd_msosv1_desc_register(&msosv1_desc); - usbd_add_interface(&intf0); - usbd_add_endpoint(&winusb_out_ep1); - usbd_add_endpoint(&winusb_in_ep1); + usbd_desc_register(CONFIG_USBDEV_DEMO_BUS, winusb_descriptor); + usbd_msosv1_desc_register(CONFIG_USBDEV_DEMO_BUS, &msosv1_desc); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, &intf0); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &winusb_out_ep1); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &winusb_in_ep1); #if DOUBLE_WINUSB == 1 - usbd_add_interface(&intf1); - usbd_add_endpoint(&winusb_out_ep2); - usbd_add_endpoint(&winusb_in_ep2); + usbd_add_interface(CONFIG_USBDEV_DEMO_BUS, &intf1); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &winusb_out_ep2); + usbd_add_endpoint(CONFIG_USBDEV_DEMO_BUS, &winusb_in_ep2); #endif - usbd_initialize(); + usbd_initialize(CONFIG_USBDEV_DEMO_BUS, usbd_event_handler); } \ No newline at end of file diff --git a/port/ch32/README.md b/port/ch32/README.md index d351a3cc..a625d04c 100644 --- a/port/ch32/README.md +++ b/port/ch32/README.md @@ -3,10 +3,3 @@ ## Support Chip List - CH32V30x - -## Before Use - -Your should implement `usb_dc_low_level_init` and `usb_dc_low_level_deinit`. -- Enable or disable USB clock and set USB clock for 48M. -- Enable or disable gpio and gpio clk for usb dp and dm. -- Enable or disable usb irq \ No newline at end of file diff --git a/port/ch32/usb_ch58x_dc_usbfs.c b/port/ch32/usb_ch58x_dc_usbfs.c index 32cd8cd2..0011b66c 100644 --- a/port/ch32/usb_ch58x_dc_usbfs.c +++ b/port/ch32/usb_ch58x_dc_usbfs.c @@ -120,249 +120,13 @@ __WEAK void usb_dc_low_level_deinit(void) { } -/** - * @brief Set address - * @pre None - * @param[in] address ：8-bit valid address - * @retval >=0 success otherwise failure - */ -int usbd_set_address(const uint8_t address) -{ - if (address == 0) { - CH58x_USBFS_DEV->USB_DEV_AD = (CH58x_USBFS_DEV->USB_DEV_AD & 0x80) | address; - } - usb_dc_cfg.address = address; - return 0; -} - -uint8_t usbd_get_port_speed(const uint8_t port) -{ - return USB_SPEED_FULL; -} - -/** - * @brief Open endpoint - * @pre None - * @param[in] ep_cfg : Endpoint configuration structure pointer - * @retval >=0 success otherwise failure - */ -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) -{ - /*!< ep id */ - uint8_t epid = USB_EP_GET_IDX(ep->bEndpointAddress); - if (epid > (USB_NUM_BIDIR_ENDPOINTS - 1)) { - /** - * If you use ch58x, you can change the EP_NUMS set to 8 - */ - USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress); - return -1; - } - - /*!< ep max packet length */ - uint8_t mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); - /*!< update ep max packet length */ - if (USB_EP_DIR_IS_IN(ep->bEndpointAddress)) { - /*!< in */ - usb_dc_cfg.ep_in[epid].ep_enable = true; - usb_dc_cfg.ep_in[epid].mps = mps; - usb_dc_cfg.ep_in[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); - } else if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) { - /*!< out */ - usb_dc_cfg.ep_out[epid].ep_enable = true; - usb_dc_cfg.ep_out[epid].mps = mps; - usb_dc_cfg.ep_out[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); - } - return 0; -} - -/** - * @brief Close endpoint - * @pre None - * @param[in] ep ： Endpoint address - * @retval >=0 success otherwise failure - */ -int usbd_ep_close(const uint8_t ep) -{ - /*!< ep id */ - uint8_t epid = USB_EP_GET_IDX(ep); - if (USB_EP_DIR_IS_IN(ep)) { - /*!< in */ - usb_dc_cfg.ep_in[epid].ep_enable = false; - } else if (USB_EP_DIR_IS_OUT(ep)) { - /*!< out */ - usb_dc_cfg.ep_out[epid].ep_enable = false; - } - return 0; -} - -/** - * @brief Setup in ep transfer setting and start transfer. - * - * This function is asynchronous. - * This function is similar to uart with tx dma. - * - * This function is called to write data to the specified endpoint. The - * supplied usbd_endpoint_callback function will be called when data is transmitted - * out. - * - * @param[in] ep Endpoint address corresponding to the one - * listed in the device configuration table - * @param[in] data Pointer to data to write - * @param[in] data_len Length of the data requested to write. This may - * be zero for a zero length status packet. - * @return 0 on success, negative errno code on fail. - */ -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) -{ - uint8_t ep_idx = USB_EP_GET_IDX(ep); - - if (!data && data_len) { - return -1; - } - if (!usb_dc_cfg.ep_in[ep_idx].ep_enable) { - return -2; - } - if ((uint32_t)data & 0x03) { - return -3; - } - - usb_dc_cfg.ep_in[ep_idx].xfer_buf = (uint8_t *)data; - usb_dc_cfg.ep_in[ep_idx].xfer_len = data_len; - usb_dc_cfg.ep_in[ep_idx].actual_xfer_len = 0; - - if (data_len == 0) { - /*!< write 0 len data */ - EPn_SET_TX_LEN(ep_idx, 0); - /*!< enable tx */ - if (usb_dc_cfg.ep_in[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { - EPn_SET_TX_VALID(ep_idx); - } else { - EPn_SET_TX_ISO_VALID(ep_idx); - } - /*!< return */ - return 0; - } else { - /*!< Not zlp */ - data_len = MIN(data_len, usb_dc_cfg.ep_in[ep_idx].mps); - /*!< write buff */ - memcpy(usb_dc_cfg.ep_in[ep_idx].ep_ram_addr, data, data_len); - /*!< write real_wt_nums len data */ - EPn_SET_TX_LEN(ep_idx, data_len); - /*!< enable tx */ - if (usb_dc_cfg.ep_in[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { - EPn_SET_TX_VALID(ep_idx); - } else { - EPn_SET_TX_ISO_VALID(ep_idx); - } - } - return 0; -} - -/** - * @brief Setup out ep transfer setting and start transfer. - * - * This function is asynchronous. - * This function is similar to uart with rx dma. - * - * This function is called to read data to the specified endpoint. The - * supplied usbd_endpoint_callback function will be called when data is received - * in. - * - * @param[in] ep Endpoint address corresponding to the one - * listed in the device configuration table - * @param[in] data Pointer to data to read - * @param[in] data_len Max length of the data requested to read. - * - * @return 0 on success, negative errno code on fail. - */ -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) -{ - uint8_t ep_idx = USB_EP_GET_IDX(ep); - - if (!data && data_len) { - return -1; - } - if (!usb_dc_cfg.ep_out[ep_idx].ep_enable) { - return -2; - } - if ((uint32_t)data & 0x03) { - return -3; - } - - usb_dc_cfg.ep_out[ep_idx].xfer_buf = (uint8_t *)data; - usb_dc_cfg.ep_out[ep_idx].xfer_len = data_len; - usb_dc_cfg.ep_out[ep_idx].actual_xfer_len = 0; - - if (data_len == 0) { - } else { - data_len = MIN(data_len, usb_dc_cfg.ep_out[ep_idx].mps); - } - - if (usb_dc_cfg.ep_out[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { - EPn_SET_RX_VALID(ep_idx); - } else { - EPn_SET_RX_ISO_VALID(ep_idx); - } - return 0; -} - -/** - * @brief Endpoint setting stall - * @pre None - * @param[in] ep ： Endpoint address - * @retval >=0 success otherwise failure - */ -int usbd_ep_set_stall(const uint8_t ep) -{ - /*!< ep id */ - uint8_t epid = USB_EP_GET_IDX(ep); - if (USB_EP_DIR_IS_OUT(ep)) { - EPn_SET_RX_STALL(epid); - } else { - EPn_SET_TX_STALL(epid); - } - return 0; -} - -/** - * @brief Endpoint clear stall - * @pre None - * @param[in] ep ： Endpoint address - * @retval >=0 success otherwise failure - */ -int usbd_ep_clear_stall(const uint8_t ep) -{ - uint8_t epid = USB_EP_GET_IDX(ep); - if (USB_EP_DIR_IS_OUT(ep)) { - EPn_CLR_RX_STALL(epid); - } else { - EPn_CLR_TX_STALL(epid); - } - return 0; -} - -/** - * @brief Check endpoint status - * @pre None - * @param[in] ep ： Endpoint address - * @param[out] stalled ： Outgoing endpoint status - * @retval >=0 success otherwise failure - */ -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) -{ - if (USB_EP_DIR_IS_OUT(ep)) { - } else { - } - return 0; -} - /** * @brief USB initialization * @pre None * @param[in] None * @retval >=0 success otherwise failure */ -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { usb_dc_cfg.ep_in[0].ep_ram_addr = ep0_data_buff; usb_dc_cfg.ep_out[0].ep_ram_addr = ep0_data_buff; @@ -434,6 +198,248 @@ int usb_dc_init(void) return 0; } +int usb_dc_deinit(uint8_t busid) +{ + return 0; +} + +/** + * @brief Set address + * @pre None + * @param[in] address ：8-bit valid address + * @retval >=0 success otherwise failure + */ +int usbd_set_address(uint8_t busid, const uint8_t address) +{ + if (address == 0) { + CH58x_USBFS_DEV->USB_DEV_AD = (CH58x_USBFS_DEV->USB_DEV_AD & 0x80) | address; + } + usb_dc_cfg.address = address; + return 0; +} + +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) +{ + return USB_SPEED_FULL; +} + +/** + * @brief Open endpoint + * @pre None + * @param[in] ep_cfg : Endpoint configuration structure pointer + * @retval >=0 success otherwise failure + */ +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) +{ + /*!< ep id */ + uint8_t epid = USB_EP_GET_IDX(ep->bEndpointAddress); + if (epid > (USB_NUM_BIDIR_ENDPOINTS - 1)) { + /** + * If you use ch58x, you can change the EP_NUMS set to 8 + */ + USB_LOG_ERR("Ep addr %02x overflow\r\n", ep->bEndpointAddress); + return -1; + } + + /*!< ep max packet length */ + uint8_t mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); + /*!< update ep max packet length */ + if (USB_EP_DIR_IS_IN(ep->bEndpointAddress)) { + /*!< in */ + usb_dc_cfg.ep_in[epid].ep_enable = true; + usb_dc_cfg.ep_in[epid].mps = mps; + usb_dc_cfg.ep_in[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); + } else if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) { + /*!< out */ + usb_dc_cfg.ep_out[epid].ep_enable = true; + usb_dc_cfg.ep_out[epid].mps = mps; + usb_dc_cfg.ep_out[epid].eptype = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); + } + return 0; +} + +/** + * @brief Close endpoint + * @pre None + * @param[in] ep ： Endpoint address + * @retval >=0 success otherwise failure + */ +int usbd_ep_close(uint8_t busid, const uint8_t ep) +{ + /*!< ep id */ + uint8_t epid = USB_EP_GET_IDX(ep); + if (USB_EP_DIR_IS_IN(ep)) { + /*!< in */ + usb_dc_cfg.ep_in[epid].ep_enable = false; + } else if (USB_EP_DIR_IS_OUT(ep)) { + /*!< out */ + usb_dc_cfg.ep_out[epid].ep_enable = false; + } + return 0; +} + + +/** + * @brief Endpoint setting stall + * @pre None + * @param[in] ep ： Endpoint address + * @retval >=0 success otherwise failure + */ +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) +{ + /*!< ep id */ + uint8_t epid = USB_EP_GET_IDX(ep); + if (USB_EP_DIR_IS_OUT(ep)) { + EPn_SET_RX_STALL(epid); + } else { + EPn_SET_TX_STALL(epid); + } + return 0; +} + +/** + * @brief Endpoint clear stall + * @pre None + * @param[in] ep ： Endpoint address + * @retval >=0 success otherwise failure + */ +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) +{ + uint8_t epid = USB_EP_GET_IDX(ep); + if (USB_EP_DIR_IS_OUT(ep)) { + EPn_CLR_RX_STALL(epid); + } else { + EPn_CLR_TX_STALL(epid); + } + return 0; +} + +/** + * @brief Check endpoint status + * @pre None + * @param[in] ep ： Endpoint address + * @param[out] stalled ： Outgoing endpoint status + * @retval >=0 success otherwise failure + */ +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) +{ + if (USB_EP_DIR_IS_OUT(ep)) { + } else { + } + return 0; +} + +/** + * @brief Setup in ep transfer setting and start transfer. + * + * This function is asynchronous. + * This function is similar to uart with tx dma. + * + * This function is called to write data to the specified endpoint. The + * supplied usbd_endpoint_callback function will be called when data is transmitted + * out. + * + * @param[in] ep Endpoint address corresponding to the one + * listed in the device configuration table + * @param[in] data Pointer to data to write + * @param[in] data_len Length of the data requested to write. This may + * be zero for a zero length status packet. + * @return 0 on success, negative errno code on fail. + */ +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) +{ + uint8_t ep_idx = USB_EP_GET_IDX(ep); + + if (!data && data_len) { + return -1; + } + if (!usb_dc_cfg.ep_in[ep_idx].ep_enable) { + return -2; + } + if ((uint32_t)data & 0x03) { + return -3; + } + + usb_dc_cfg.ep_in[ep_idx].xfer_buf = (uint8_t *)data; + usb_dc_cfg.ep_in[ep_idx].xfer_len = data_len; + usb_dc_cfg.ep_in[ep_idx].actual_xfer_len = 0; + + if (data_len == 0) { + /*!< write 0 len data */ + EPn_SET_TX_LEN(ep_idx, 0); + /*!< enable tx */ + if (usb_dc_cfg.ep_in[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { + EPn_SET_TX_VALID(ep_idx); + } else { + EPn_SET_TX_ISO_VALID(ep_idx); + } + /*!< return */ + return 0; + } else { + /*!< Not zlp */ + data_len = MIN(data_len, usb_dc_cfg.ep_in[ep_idx].mps); + /*!< write buff */ + memcpy(usb_dc_cfg.ep_in[ep_idx].ep_ram_addr, data, data_len); + /*!< write real_wt_nums len data */ + EPn_SET_TX_LEN(ep_idx, data_len); + /*!< enable tx */ + if (usb_dc_cfg.ep_in[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { + EPn_SET_TX_VALID(ep_idx); + } else { + EPn_SET_TX_ISO_VALID(ep_idx); + } + } + return 0; +} + +/** + * @brief Setup out ep transfer setting and start transfer. + * + * This function is asynchronous. + * This function is similar to uart with rx dma. + * + * This function is called to read data to the specified endpoint. The + * supplied usbd_endpoint_callback function will be called when data is received + * in. + * + * @param[in] ep Endpoint address corresponding to the one + * listed in the device configuration table + * @param[in] data Pointer to data to read + * @param[in] data_len Max length of the data requested to read. + * + * @return 0 on success, negative errno code on fail. + */ +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) +{ + uint8_t ep_idx = USB_EP_GET_IDX(ep); + + if (!data && data_len) { + return -1; + } + if (!usb_dc_cfg.ep_out[ep_idx].ep_enable) { + return -2; + } + if ((uint32_t)data & 0x03) { + return -3; + } + + usb_dc_cfg.ep_out[ep_idx].xfer_buf = (uint8_t *)data; + usb_dc_cfg.ep_out[ep_idx].xfer_len = data_len; + usb_dc_cfg.ep_out[ep_idx].actual_xfer_len = 0; + + if (data_len == 0) { + } else { + data_len = MIN(data_len, usb_dc_cfg.ep_out[ep_idx].mps); + } + + if (usb_dc_cfg.ep_out[ep_idx].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { + EPn_SET_RX_VALID(ep_idx); + } else { + EPn_SET_RX_ISO_VALID(ep_idx); + } + return 0; +} + /** * @brief USB interrupt processing function * @pre None @@ -471,11 +477,11 @@ USBD_IRQHandler(void) if (usb_dc_cfg.ep_in[0].xfer_len > usb_dc_cfg.ep_in[0].mps) { usb_dc_cfg.ep_in[0].xfer_len -= usb_dc_cfg.ep_in[0].mps; usb_dc_cfg.ep_in[0].actual_xfer_len += usb_dc_cfg.ep_in[0].mps; - usbd_event_ep_in_complete_handler(0 | 0x80, usb_dc_cfg.ep_in[0].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, 0 | 0x80, usb_dc_cfg.ep_in[0].actual_xfer_len); } else { usb_dc_cfg.ep_in[0].actual_xfer_len += usb_dc_cfg.ep_in[0].xfer_len; usb_dc_cfg.ep_in[0].xfer_len = 0; - usbd_event_ep_in_complete_handler(0 | 0x80, usb_dc_cfg.ep_in[0].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, 0 | 0x80, usb_dc_cfg.ep_in[0].actual_xfer_len); } break; case 0: @@ -526,7 +532,7 @@ USBD_IRQHandler(void) } else { usb_dc_cfg.ep_in[epid].actual_xfer_len += usb_dc_cfg.ep_in[epid].xfer_len; usb_dc_cfg.ep_in[epid].xfer_len = 0; - usbd_event_ep_in_complete_handler(epid | 0x80, usb_dc_cfg.ep_in[epid].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, epid | 0x80, usb_dc_cfg.ep_in[epid].actual_xfer_len); } } break; @@ -539,7 +545,7 @@ USBD_IRQHandler(void) usb_dc_cfg.ep_out[0].actual_xfer_len += read_count; usb_dc_cfg.ep_out[0].xfer_len -= read_count; - usbd_event_ep_out_complete_handler(0x00, usb_dc_cfg.ep_out[0].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, 0x00, usb_dc_cfg.ep_out[0].actual_xfer_len); if (read_count == 0) { /*!< Out status, start reading setup */ EPn_SET_RX_VALID(0); @@ -556,7 +562,7 @@ USBD_IRQHandler(void) usb_dc_cfg.ep_out[epid].xfer_len -= read_count; if ((read_count < usb_dc_cfg.ep_out[epid].mps) || (usb_dc_cfg.ep_out[epid].xfer_len == 0)) { - usbd_event_ep_out_complete_handler(((epid)&0x7f), usb_dc_cfg.ep_out[epid].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ((epid)&0x7f), usb_dc_cfg.ep_out[epid].actual_xfer_len); } else { if (usb_dc_cfg.ep_out[epid].eptype != USB_ENDPOINT_TYPE_ISOCHRONOUS) { EPn_SET_RX_VALID(epid); @@ -596,13 +602,13 @@ USBD_IRQHandler(void) EPn_SET_TX_VALID(0); } EPn_SET_RX_NAK(0); - usbd_event_ep0_setup_complete_handler((uint8_t *)&(usb_dc_cfg.setup)); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&(usb_dc_cfg.setup)); CH58x_USBFS_DEV->USB_INT_FG = RB_UIF_TRANSFER; } } else if (intflag & RB_UIF_BUS_RST) { /*!< Reset */ CH58x_USBFS_DEV->USB_DEV_AD = 0; - usbd_event_reset_handler(); + usbd_event_reset_handler(0); /*!< Set ep0 rx vaild to start receive setup packet */ EPn_SET_RX_VALID(0); CH58x_USBFS_DEV->USB_INT_FG = RB_UIF_BUS_RST; diff --git a/port/ch32/usb_dc_usbfs.c b/port/ch32/usb_dc_usbfs.c index c26f0ba7..2b69f1fd 100644 --- a/port/ch32/usb_dc_usbfs.c +++ b/port/ch32/usb_dc_usbfs.c @@ -54,7 +54,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { usb_dc_low_level_init(); @@ -82,12 +82,12 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { if (addr == 0) { USBFS_DEVICE->DEV_ADDR = (USBFS_DEVICE->DEV_ADDR & USBFS_UDA_GP_BIT) | 0; @@ -96,12 +96,12 @@ int usbd_set_address(const uint8_t addr) return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { return USB_SPEED_FULL; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -118,11 +118,11 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) } return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -147,7 +147,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -163,12 +163,12 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -215,7 +215,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -265,7 +265,7 @@ void USBD_IRQHandler(void) switch (token) { case USBFS_UIS_TOKEN_SETUP: USB_SET_RX_CTRL(ep_idx, USBFS_UEP_R_RES_NAK); - usbd_event_ep0_setup_complete_handler((uint8_t *)&g_ch32_usbfs_udc.setup); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&g_ch32_usbfs_udc.setup); break; case USBFS_UIS_TOKEN_IN: @@ -280,7 +280,7 @@ void USBD_IRQHandler(void) ep0_tx_data_toggle = true; } - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_ch32_usbfs_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_ch32_usbfs_udc.in_ep[ep_idx].actual_xfer_len); if (g_ch32_usbfs_udc.dev_addr > 0) { USBFS_DEVICE->DEV_ADDR = (USBFS_DEVICE->DEV_ADDR & USBFS_UDA_GP_BIT) | g_ch32_usbfs_udc.dev_addr; @@ -315,7 +315,7 @@ void USBD_IRQHandler(void) } else { g_ch32_usbfs_udc.in_ep[ep_idx].actual_xfer_len += g_ch32_usbfs_udc.in_ep[ep_idx].xfer_len; g_ch32_usbfs_udc.in_ep[ep_idx].xfer_len = 0; - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_ch32_usbfs_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_ch32_usbfs_udc.in_ep[ep_idx].actual_xfer_len); } } break; @@ -328,7 +328,7 @@ void USBD_IRQHandler(void) g_ch32_usbfs_udc.out_ep[ep_idx].actual_xfer_len += read_count; g_ch32_usbfs_udc.out_ep[ep_idx].xfer_len -= read_count; - usbd_event_ep_out_complete_handler(0x00, g_ch32_usbfs_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, 0x00, g_ch32_usbfs_udc.out_ep[ep_idx].actual_xfer_len); if (read_count == 0) { /* Out status, start reading setup */ @@ -351,7 +351,7 @@ void USBD_IRQHandler(void) g_ch32_usbfs_udc.out_ep[ep_idx].xfer_len -= read_count; if ((read_count < g_ch32_usbfs_udc.out_ep[ep_idx].ep_mps) || (g_ch32_usbfs_udc.out_ep[ep_idx].xfer_len == 0)) { - usbd_event_ep_out_complete_handler(ep_idx, g_ch32_usbfs_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_ch32_usbfs_udc.out_ep[ep_idx].actual_xfer_len); } else { USB_SET_RX_CTRL(ep_idx, (USB_GET_RX_CTRL(ep_idx) & ~USBFS_UEP_R_RES_MASK) | USBFS_UEP_R_RES_ACK); } @@ -383,7 +383,7 @@ void USBD_IRQHandler(void) ep0_rx_data_toggle = true; memset(&g_ch32_usbfs_udc, 0, sizeof(struct ch32_usbfs_udc)); - usbd_event_reset_handler(); + usbd_event_reset_handler(0); USB_SET_DMA(ep_idx, (uint32_t)&g_ch32_usbfs_udc.setup); USB_SET_RX_CTRL(ep_idx, USBFS_UEP_R_RES_ACK); diff --git a/port/ch32/usb_dc_usbhs.c b/port/ch32/usb_dc_usbhs.c index faa0f4a7..27653505 100644 --- a/port/ch32/usb_dc_usbhs.c +++ b/port/ch32/usb_dc_usbhs.c @@ -53,7 +53,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { usb_dc_low_level_init(); @@ -82,12 +82,12 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { if (addr == 0) { USBHS_DEVICE->DEV_AD = addr & 0xff; @@ -96,12 +96,12 @@ int usbd_set_address(const uint8_t addr) return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { return USB_SPEED_HIGH; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -122,12 +122,12 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -148,7 +148,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -160,12 +160,12 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint32_t tmp; @@ -211,7 +211,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -268,7 +268,7 @@ void USBD_IRQHandler(void) ep0_tx_data_toggle = true; } - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_ch32_usbhs_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_ch32_usbhs_udc.in_ep[ep_idx].actual_xfer_len); if (g_ch32_usbhs_udc.dev_addr > 0) { USBHS_DEVICE->DEV_AD = g_ch32_usbhs_udc.dev_addr & 0xff; @@ -309,7 +309,7 @@ void USBD_IRQHandler(void) g_ch32_usbhs_udc.in_ep[ep_idx].actual_xfer_len += g_ch32_usbhs_udc.in_ep[ep_idx].xfer_len; g_ch32_usbhs_udc.in_ep[ep_idx].xfer_len = 0; epx_tx_data_toggle[ep_idx - 1] ^= 1; - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_ch32_usbhs_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_ch32_usbhs_udc.in_ep[ep_idx].actual_xfer_len); } } } else if (token == PID_OUT) { @@ -319,7 +319,7 @@ void USBD_IRQHandler(void) g_ch32_usbhs_udc.out_ep[ep_idx].actual_xfer_len += read_count; g_ch32_usbhs_udc.out_ep[ep_idx].xfer_len -= read_count; - usbd_event_ep_out_complete_handler(0x00, g_ch32_usbhs_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, 0x00, g_ch32_usbhs_udc.out_ep[ep_idx].actual_xfer_len); if (read_count == 0) { /* Out status, start reading setup */ @@ -340,7 +340,7 @@ void USBD_IRQHandler(void) g_ch32_usbhs_udc.out_ep[ep_idx].xfer_len -= read_count; if ((read_count < g_ch32_usbhs_udc.out_ep[ep_idx].ep_mps) || (g_ch32_usbhs_udc.out_ep[ep_idx].xfer_len == 0)) { - usbd_event_ep_out_complete_handler(ep_idx, g_ch32_usbhs_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_ch32_usbhs_udc.out_ep[ep_idx].actual_xfer_len); } else { USB_SET_RX_DMA(ep_idx, (uint32_t)g_ch32_usbhs_udc.out_ep[ep_idx].xfer_buf); USB_SET_RX_CTRL(ep_idx, (USB_GET_RX_CTRL(ep_idx) & ~USBHS_EP_R_RES_MASK) | USBHS_EP_R_RES_ACK); @@ -350,7 +350,7 @@ void USBD_IRQHandler(void) } USBHS_DEVICE->INT_FG = USBHS_TRANSFER_FLAG; } else if (intflag & USBHS_SETUP_FLAG) { - usbd_event_ep0_setup_complete_handler((uint8_t *)&g_ch32_usbhs_udc.setup); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&g_ch32_usbhs_udc.setup); USBHS_DEVICE->INT_FG = USBHS_SETUP_FLAG; } else if (intflag & USBHS_DETECT_FLAG) { USBHS_DEVICE->ENDP_CONFIG = USBHS_EP0_T_EN | USBHS_EP0_R_EN; @@ -369,7 +369,7 @@ void USBD_IRQHandler(void) } memset(&g_ch32_usbhs_udc, 0, sizeof(struct ch32_usbhs_udc)); - usbd_event_reset_handler(); + usbd_event_reset_handler(0); USBHS_DEVICE->UEP0_DMA = (uint32_t)&g_ch32_usbhs_udc.setup; USBHS_DEVICE->UEP0_RX_CTRL = USBHS_EP_R_RES_ACK; USBHS_DEVICE->INT_FG = USBHS_DETECT_FLAG; diff --git a/port/dwc2/README.md b/port/dwc2/README.md index b4f59d57..2c084afd 100644 --- a/port/dwc2/README.md +++ b/port/dwc2/README.md @@ -29,10 +29,3 @@ ## Espressif - ESP32S2、ESP32S3 - -## Before Use - -Your should implement `usb_dc_low_level_init` and `usb_dc_low_level_deinit`. -- Enable or disable USB clock and set USB clock for 48M. -- Enable or disable gpio and gpio clk for usb dp and dm. -- Enable or disable usb irq \ No newline at end of file diff --git a/port/dwc2/usb_dc_dwc2.c b/port/dwc2/usb_dc_dwc2.c index 6e489097..c64b4b18 100644 --- a/port/dwc2/usb_dc_dwc2.c +++ b/port/dwc2/usb_dc_dwc2.c @@ -515,7 +515,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { int ret; uint8_t fsphy_type; @@ -676,7 +676,7 @@ int usb_dc_init(void) return ret; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { /* Clear Pending interrupt */ for (uint8_t i = 0U; i < 15U; i++) { @@ -699,14 +699,14 @@ int usb_dc_deinit(void) return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { USB_OTG_DEV->DCFG &= ~(USB_OTG_DCFG_DAD); USB_OTG_DEV->DCFG |= ((uint32_t)addr << 4) & USB_OTG_DCFG_DAD; return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { uint8_t speed; uint32_t DevEnumSpeed = USB_OTG_DEV->DSTS & USB_OTG_DSTS_ENUMSPD; @@ -723,7 +723,7 @@ uint8_t usbd_get_port_speed(const uint8_t port) return speed; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -761,7 +761,7 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); volatile uint32_t count = 0U; @@ -810,7 +810,7 @@ int usbd_ep_close(const uint8_t ep) return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -833,7 +833,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -853,7 +853,7 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { if (USB_EP_DIR_IS_OUT(ep)) { } else { @@ -861,7 +861,7 @@ int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint32_t pktcnt = 0; @@ -934,7 +934,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint32_t pktcnt = 0; @@ -1048,17 +1048,17 @@ void USBD_IRQHandler(void) } else { g_dwc2_udc.out_ep[ep_idx].actual_xfer_len = g_dwc2_udc.out_ep[ep_idx].xfer_len - ((USB_OTG_OUTEP(ep_idx)->DOEPTSIZ) & USB_OTG_DOEPTSIZ_XFRSIZ); g_dwc2_udc.out_ep[ep_idx].xfer_len = 0; - usbd_event_ep_out_complete_handler(0x00, g_dwc2_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, 0x00, g_dwc2_udc.out_ep[ep_idx].actual_xfer_len); } } else { g_dwc2_udc.out_ep[ep_idx].actual_xfer_len = g_dwc2_udc.out_ep[ep_idx].xfer_len - ((USB_OTG_OUTEP(ep_idx)->DOEPTSIZ) & USB_OTG_DOEPTSIZ_XFRSIZ); g_dwc2_udc.out_ep[ep_idx].xfer_len = 0; - usbd_event_ep_out_complete_handler(ep_idx, g_dwc2_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_dwc2_udc.out_ep[ep_idx].actual_xfer_len); } } if ((epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP) { - usbd_event_ep0_setup_complete_handler((uint8_t *)&g_dwc2_udc.setup); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&g_dwc2_udc.setup); } } ep_intr >>= 1U; @@ -1078,7 +1078,7 @@ void USBD_IRQHandler(void) if (ep_idx == 0) { g_dwc2_udc.in_ep[ep_idx].actual_xfer_len = g_dwc2_udc.in_ep[ep_idx].xfer_len - ((USB_OTG_INEP(ep_idx)->DIEPTSIZ) & USB_OTG_DIEPTSIZ_XFRSIZ); g_dwc2_udc.in_ep[ep_idx].xfer_len = 0; - usbd_event_ep_in_complete_handler(0x80, g_dwc2_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, 0x80, g_dwc2_udc.in_ep[ep_idx].actual_xfer_len); if (g_dwc2_udc.setup.wLength && ((g_dwc2_udc.setup.bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_OUT)) { /* In status, start reading setup */ @@ -1090,7 +1090,7 @@ void USBD_IRQHandler(void) } else { g_dwc2_udc.in_ep[ep_idx].actual_xfer_len = g_dwc2_udc.in_ep[ep_idx].xfer_len - ((USB_OTG_INEP(ep_idx)->DIEPTSIZ) & USB_OTG_DIEPTSIZ_XFRSIZ); g_dwc2_udc.in_ep[ep_idx].xfer_len = 0; - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_dwc2_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_dwc2_udc.in_ep[ep_idx].actual_xfer_len); } } if ((epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE) { @@ -1138,7 +1138,7 @@ void USBD_IRQHandler(void) USB_OTG_DEV->DIEPMSK = USB_OTG_DIEPMSK_XFRCM; memset(&g_dwc2_udc, 0, sizeof(struct dwc2_udc)); - usbd_event_reset_handler(); + usbd_event_reset_handler(0); /* Start reading setup */ dwc2_ep0_start_read_setup((uint8_t *)&g_dwc2_udc.setup); } diff --git a/port/ehci/README.md b/port/ehci/README.md index bccb2bc0..48b9a2b6 100644 --- a/port/ehci/README.md +++ b/port/ehci/README.md @@ -24,11 +24,4 @@ ### Intel -Intel 6 Series Chipset and Intel C200 Series Chipset - -## Before Use - -Your should implement `usb_hc_low_level_init`. -- Enable USB PHY、USB clock and set USB clock for 48M. -- Enable usb irq -- Config EHCI BASE and other macros in `cherryusb_config_tempate.h` \ No newline at end of file +- Intel 6 Series Chipset and Intel C200 Series Chipset diff --git a/port/fsdev/README.md b/port/fsdev/README.md index fcf5572a..ecb9c33c 100644 --- a/port/fsdev/README.md +++ b/port/fsdev/README.md @@ -31,11 +31,3 @@ ## CH32 - CH32F10x、CH32V10x - - -## Before Use - -Your should implement `usb_dc_low_level_init` and `usb_dc_low_level_deinit`. -- Enable or disable USB clock and set USB clock for 48M. -- Enable or disable gpio and gpio clk for usb dp and dm. -- Enable or disable usb irq \ No newline at end of file diff --git a/port/fsdev/usb_dc_fsdev.c b/port/fsdev/usb_dc_fsdev.c index 301eeac3..68f4f37e 100644 --- a/port/fsdev/usb_dc_fsdev.c +++ b/port/fsdev/usb_dc_fsdev.c @@ -60,7 +60,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { usb_dc_low_level_init(); @@ -94,7 +94,7 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { /* disable all interrupts and force USB reset */ USB->CNTR = (uint16_t)USB_CNTR_FRES; @@ -109,7 +109,7 @@ int usb_dc_deinit(void) return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { if (addr == 0U) { /* set device address and enable function */ @@ -120,12 +120,12 @@ int usbd_set_address(const uint8_t addr) return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { return USB_SPEED_FULL; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -207,7 +207,7 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -225,7 +225,7 @@ int usbd_ep_close(const uint8_t ep) return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -237,7 +237,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -256,7 +256,7 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { if (USB_EP_DIR_IS_OUT(ep)) { } else { @@ -264,7 +264,7 @@ int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -289,7 +289,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -335,14 +335,14 @@ void USBD_IRQHandler(void) g_fsdev_udc.in_ep[ep_idx].xfer_len -= write_count; g_fsdev_udc.in_ep[ep_idx].actual_xfer_len += write_count; - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_fsdev_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_fsdev_udc.in_ep[ep_idx].actual_xfer_len); if (g_fsdev_udc.setup.wLength == 0) { /* In status, start reading setup */ - usbd_ep_start_read(0x00, NULL, 0); + usbd_ep_start_read(0, 0x00, NULL, 0); } else if (g_fsdev_udc.setup.wLength && ((g_fsdev_udc.setup.bmRequestType & USB_REQUEST_DIR_MASK) == USB_REQUEST_DIR_OUT)) { /* In status, start reading setup */ - usbd_ep_start_read(0x00, NULL, 0); + usbd_ep_start_read(0, 0x00, NULL, 0); } if ((g_fsdev_udc.dev_addr > 0U) && (write_count == 0U)) { @@ -359,7 +359,7 @@ void USBD_IRQHandler(void) read_count = PCD_GET_EP_RX_CNT(USB, ep_idx); fsdev_read_pma(USB, (uint8_t *)&g_fsdev_udc.setup, g_fsdev_udc.out_ep[ep_idx].ep_pma_addr, (uint16_t)read_count); - usbd_event_ep0_setup_complete_handler((uint8_t *)&g_fsdev_udc.setup); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&g_fsdev_udc.setup); } else if ((wEPVal & USB_EP_CTR_RX) != 0U) { PCD_CLEAR_RX_EP_CTR(USB, ep_idx); @@ -372,11 +372,11 @@ void USBD_IRQHandler(void) g_fsdev_udc.out_ep[ep_idx].xfer_len -= read_count; g_fsdev_udc.out_ep[ep_idx].actual_xfer_len += read_count; - usbd_event_ep_out_complete_handler(ep_idx, g_fsdev_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_fsdev_udc.out_ep[ep_idx].actual_xfer_len); if (read_count == 0) { /* Out status, start reading setup */ - usbd_ep_start_read(0x00, NULL, 0); + usbd_ep_start_read(0, 0x00, NULL, 0); } } } @@ -393,7 +393,7 @@ void USBD_IRQHandler(void) if ((read_count < g_fsdev_udc.out_ep[ep_idx].ep_mps) || (g_fsdev_udc.out_ep[ep_idx].xfer_len == 0)) { - usbd_event_ep_out_complete_handler(ep_idx, g_fsdev_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_fsdev_udc.out_ep[ep_idx].actual_xfer_len); } else { PCD_SET_EP_RX_STATUS(USB, ep_idx, USB_EP_RX_VALID); } @@ -408,7 +408,7 @@ void USBD_IRQHandler(void) g_fsdev_udc.in_ep[ep_idx].actual_xfer_len += write_count; if (g_fsdev_udc.in_ep[ep_idx].xfer_len == 0) { - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_fsdev_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_fsdev_udc.in_ep[ep_idx].actual_xfer_len); } else { write_count = MIN(g_fsdev_udc.in_ep[ep_idx].xfer_len, g_fsdev_udc.in_ep[ep_idx].ep_mps); fsdev_write_pma(USB, g_fsdev_udc.in_ep[ep_idx].xfer_buf, g_fsdev_udc.in_ep[ep_idx].ep_pma_addr, (uint16_t)write_count); @@ -422,7 +422,7 @@ void USBD_IRQHandler(void) if (wIstr & USB_ISTR_RESET) { memset(&g_fsdev_udc, 0, sizeof(struct fsdev_udc)); g_fsdev_udc.pma_offset = USB_BTABLE_SIZE; - usbd_event_reset_handler(); + usbd_event_reset_handler(0); /* start reading setup packet */ PCD_SET_EP_RX_STATUS(USB, 0, USB_EP_RX_VALID); USB->ISTR &= (uint16_t)(~USB_ISTR_RESET); diff --git a/port/hpm/usb_dc_hpm.c b/port/hpm/usb_dc_hpm.c index 3919fa0e..ac26f922 100644 --- a/port/hpm/usb_dc_hpm.c +++ b/port/hpm/usb_dc_hpm.c @@ -2,18 +2,10 @@ #include "hpm_usb_device.h" #include "board.h" -#ifndef USBD_IRQHandler -#define USBD_IRQHandler USBD_IRQHandler // use actual usb irq name instead -#endif - #ifndef USB_NUM_BIDIR_ENDPOINTS #define USB_NUM_BIDIR_ENDPOINTS USB_SOC_DCD_MAX_ENDPOINT_COUNT #endif -#if !defined(CONFIG_HPM_USBD_BASE) || !defined(CONFIG_HPM_USBD_IRQn) -#error "hpm dcd must config CONFIG_HPM_USBD_BASE and CONFIG_HPM_USBD_IRQn" -#endif - /* USBSTS, USBINTR */ enum { intr_usb = HPM_BITSMASK(1, 0), @@ -41,66 +33,86 @@ struct hpm_udc { usb_device_handle_t *handle; struct hpm_ep_state in_ep[USB_NUM_BIDIR_ENDPOINTS]; /*!< IN endpoint parameters*/ struct hpm_ep_state out_ep[USB_NUM_BIDIR_ENDPOINTS]; /*!< OUT endpoint parameters */ -} g_hpm_udc; +} g_hpm_udc[CONFIG_USBDEV_MAX_BUS]; -static ATTR_PLACE_AT_NONCACHEABLE_WITH_ALIGNMENT(USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT) dcd_data_t _dcd_data; +static ATTR_PLACE_AT_NONCACHEABLE_WITH_ALIGNMENT(USB_SOC_DCD_DATA_RAM_ADDRESS_ALIGNMENT) dcd_data_t _dcd_data[USB_SOC_MAX_COUNT]; static ATTR_PLACE_AT_NONCACHEABLE usb_device_handle_t usb_device_handle[USB_SOC_MAX_COUNT]; +/*---------------------------------------------------------------------* + * Macro Typedef Declaration + *---------------------------------------------------------------------*/ +typedef struct { + USB_Type* regs; /* register base*/ + const uint32_t irqnum; /* IRQ number */ + const uint8_t ep_count; /* Max bi-directional Endpoints */ +} dcd_controller_t; + +/*---------------------------------------------------------------------* + * Variable Definitions + *---------------------------------------------------------------------*/ +static const dcd_controller_t _dcd_controller[] = +{ + { .regs = (USB_Type*) HPM_USB0_BASE, .irqnum = IRQn_USB0, .ep_count = USB_SOC_DCD_MAX_ENDPOINT_COUNT }, +#ifdef HPM_USB1_BASE + { .regs = (USB_Type*) HPM_USB1_BASE, .irqnum = IRQn_USB1, .ep_count = USB_SOC_DCD_MAX_ENDPOINT_COUNT } +#endif +}; + /* Index to bit position in register */ static inline uint8_t ep_idx2bit(uint8_t ep_idx) { return ep_idx / 2 + ((ep_idx % 2) ? 16 : 0); } -__WEAK void usb_dc_low_level_init(void) +__WEAK void usb_dc_low_level_init(uint8_t busid) { } -__WEAK void usb_dc_low_level_deinit(void) +__WEAK void usb_dc_low_level_deinit(uint8_t busid) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { - usb_dc_low_level_init(); + usb_dc_low_level_init(busid); - memset(&g_hpm_udc, 0, sizeof(struct hpm_udc)); - g_hpm_udc.handle = &usb_device_handle[0]; - g_hpm_udc.handle->regs = (USB_Type *)CONFIG_HPM_USBD_BASE; - g_hpm_udc.handle->dcd_data = &_dcd_data; + memset(&g_hpm_udc[busid], 0, sizeof(struct hpm_udc)); + g_hpm_udc[busid].handle = &usb_device_handle[busid]; + g_hpm_udc[busid].handle->regs = _dcd_controller[busid].regs; + g_hpm_udc[busid].handle->dcd_data = &_dcd_data[busid]; uint32_t int_mask; int_mask = (USB_USBINTR_UE_MASK | USB_USBINTR_UEE_MASK | USB_USBINTR_PCE_MASK | USB_USBINTR_URE_MASK); - usb_device_init(g_hpm_udc.handle, int_mask); + usb_device_init(g_hpm_udc[busid].handle, int_mask); - intc_m_enable_irq(CONFIG_HPM_USBD_IRQn); + intc_m_enable_irq(_dcd_controller[busid].irqnum); return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { - intc_m_disable_irq(CONFIG_HPM_USBD_IRQn); + intc_m_disable_irq(_dcd_controller[busid].irqnum); - usb_device_deinit(g_hpm_udc.handle); + usb_device_deinit(g_hpm_udc[busid].handle); return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; usb_dcd_set_address(handle->regs, addr); return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { (void)port; uint8_t speed; - speed = usb_get_port_speed(g_hpm_udc.handle->regs); + speed = usb_get_port_speed(g_hpm_udc[busid].handle->regs); if (speed == 0x00) { return USB_SPEED_FULL; @@ -115,21 +127,21 @@ uint8_t usbd_get_port_speed(const uint8_t port) return 0; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { usb_endpoint_config_t tmp_ep_cfg; - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); if (USB_EP_DIR_IS_OUT(ep->bEndpointAddress)) { - g_hpm_udc.out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); - g_hpm_udc.out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); - g_hpm_udc.out_ep[ep_idx].ep_enable = true; + g_hpm_udc[busid].out_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); + g_hpm_udc[busid].out_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); + g_hpm_udc[busid].out_ep[ep_idx].ep_enable = true; } else { - g_hpm_udc.in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); - g_hpm_udc.in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); - g_hpm_udc.in_ep[ep_idx].ep_enable = true; + g_hpm_udc[busid].in_ep[ep_idx].ep_mps = USB_GET_MAXPACKETSIZE(ep->wMaxPacketSize); + g_hpm_udc[busid].in_ep[ep_idx].ep_type = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); + g_hpm_udc[busid].in_ep[ep_idx].ep_enable = true; } tmp_ep_cfg.xfer = USB_GET_ENDPOINT_TYPE(ep->bmAttributes); @@ -140,84 +152,84 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; usb_device_edpt_close(handle, ep); return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; usb_device_edpt_stall(handle, ep); return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; usb_device_edpt_clear_stall(handle, ep); return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; *stalled = usb_device_edpt_check_stall(handle, ep); return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; if (!data && data_len) { return -1; } - if (!g_hpm_udc.in_ep[ep_idx].ep_enable) { + if (!g_hpm_udc[busid].in_ep[ep_idx].ep_enable) { return -2; } - g_hpm_udc.in_ep[ep_idx].xfer_buf = (uint8_t *)data; - g_hpm_udc.in_ep[ep_idx].xfer_len = data_len; - g_hpm_udc.in_ep[ep_idx].actual_xfer_len = 0; + g_hpm_udc[busid].in_ep[ep_idx].xfer_buf = (uint8_t *)data; + g_hpm_udc[busid].in_ep[ep_idx].xfer_len = data_len; + g_hpm_udc[busid].in_ep[ep_idx].actual_xfer_len = 0; usb_device_edpt_xfer(handle, ep, (uint8_t *)data, data_len); return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; if (!data && data_len) { return -1; } - if (!g_hpm_udc.out_ep[ep_idx].ep_enable) { + if (!g_hpm_udc[busid].out_ep[ep_idx].ep_enable) { return -2; } - g_hpm_udc.out_ep[ep_idx].xfer_buf = (uint8_t *)data; - g_hpm_udc.out_ep[ep_idx].xfer_len = data_len; - g_hpm_udc.out_ep[ep_idx].actual_xfer_len = 0; + g_hpm_udc[busid].out_ep[ep_idx].xfer_buf = (uint8_t *)data; + g_hpm_udc[busid].out_ep[ep_idx].xfer_len = data_len; + g_hpm_udc[busid].out_ep[ep_idx].actual_xfer_len = 0; usb_device_edpt_xfer(handle, ep, data, data_len); return 0; } -void USBD_IRQHandler(void) +void USBD_IRQHandler(uint8_t busid) { uint32_t int_status; - usb_device_handle_t *handle = g_hpm_udc.handle; + usb_device_handle_t *handle = g_hpm_udc[busid].handle; uint32_t transfer_len = 0; /* Acknowledge handled interrupt */ @@ -231,9 +243,9 @@ void USBD_IRQHandler(void) } if (int_status & intr_reset) { - memset(g_hpm_udc.in_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS); - memset(g_hpm_udc.out_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS); - usbd_event_reset_handler(); + memset(g_hpm_udc[busid].in_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS); + memset(g_hpm_udc[busid].out_ep, 0, sizeof(struct hpm_ep_state) * USB_NUM_BIDIR_ENDPOINTS); + usbd_event_reset_handler(busid); usb_device_bus_reset(handle, 64); } @@ -263,7 +275,7 @@ void USBD_IRQHandler(void) /*------------- Set up Received -------------*/ usb_device_clear_setup_status(handle, edpt_setup_status); dcd_qhd_t *qhd0 = usb_device_qhd_get(handle, 0); - usbd_event_ep0_setup_complete_handler((uint8_t *)&qhd0->setup_request); + usbd_event_ep0_setup_complete_handler(busid, (uint8_t *)&qhd0->setup_request); } if (edpt_complete) { @@ -288,9 +300,9 @@ void USBD_IRQHandler(void) uint8_t const ep_addr = (ep_idx / 2) | ((ep_idx & 0x01) ? 0x80 : 0); if (ep_addr & 0x80) { - usbd_event_ep_in_complete_handler(ep_addr, transfer_len); + usbd_event_ep_in_complete_handler(busid, ep_addr, transfer_len); } else { - usbd_event_ep_out_complete_handler(ep_addr, transfer_len); + usbd_event_ep_out_complete_handler(busid, ep_addr, transfer_len); } } } @@ -298,8 +310,16 @@ void USBD_IRQHandler(void) } } -void isr_usbd(void) +void isr_usbd0(void) { - USBD_IRQHandler(); + USBD_IRQHandler(0); } -SDK_DECLARE_EXT_ISR_M(CONFIG_HPM_USBD_IRQn, isr_usbd) +SDK_DECLARE_EXT_ISR_M(IRQn_USB0, isr_usbd0) + +#ifdef HPM_USB1_BASE +void isr_usbd1(void) +{ + USBD_IRQHandler(1); +} +SDK_DECLARE_EXT_ISR_M(IRQn_USB1, isr_usbd1) +#endif \ No newline at end of file diff --git a/port/musb/README.md b/port/musb/README.md index 0e764aed..d65b70a1 100644 --- a/port/musb/README.md +++ b/port/musb/README.md @@ -16,11 +16,4 @@ ### AllwinnerTech -- F1Cxxx - -## Before Use - -Your should implement `usb_dc_low_level_init` and `usb_dc_low_level_deinit`. -- Enable or disable USB clock and set USB clock for 48M. -- Enable or disable gpio and gpio clk for usb dp and dm. -- Enable or disable usb irq \ No newline at end of file +- F1Cxxx, F2Cxxx diff --git a/port/musb/usb_dc_musb.c b/port/musb/usb_dc_musb.c index f57dd333..256f387b 100644 --- a/port/musb/usb_dc_musb.c +++ b/port/musb/usb_dc_musb.c @@ -221,7 +221,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { usb_dc_low_level_init(); @@ -245,12 +245,12 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { if (addr == 0) { HWREGB(USB_BASE + MUSB_FADDR_OFFSET) = 0; @@ -260,7 +260,7 @@ int usbd_set_address(const uint8_t addr) return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { uint8_t speed = USB_SPEED_UNKNOWN; @@ -280,7 +280,7 @@ uint8_t usbd_force_full_speed(const uint8_t port) return (HWREGB(USB_BASE + MUSB_POWER_OFFSET) & USB_POWER_HSENAB); } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint16_t used = 0; uint16_t fifo_size = 0; @@ -410,12 +410,12 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint8_t old_ep_idx; @@ -443,7 +443,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint8_t old_ep_idx; @@ -475,7 +475,7 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { return 0; } @@ -604,7 +604,7 @@ int usbd_write_packet(uint8_t ep_addr, uint8_t *buffer, uint16_t len) return cnt; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint8_t old_ep_idx; @@ -663,7 +663,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint8_t old_ep_idx; @@ -734,7 +734,7 @@ static void handle_ep0(void) HWREGB(USB_BASE + MUSB_IND_TXCSRL_OFFSET) = (USB_CSRL0_RXRDYC | USB_CSRL0_DATAEND); } - usbd_event_ep0_setup_complete_handler((uint8_t *)&g_musb_udc.setup); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)&g_musb_udc.setup); } break; @@ -747,7 +747,7 @@ static void handle_ep0(void) g_musb_udc.in_ep[0].xfer_len = 0; } - usbd_event_ep_in_complete_handler(0x80, g_musb_udc.in_ep[0].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, 0x80, g_musb_udc.in_ep[0].actual_xfer_len); break; case USB_EP0_STATE_OUT_DATA: @@ -759,7 +759,7 @@ static void handle_ep0(void) g_musb_udc.out_ep[0].actual_xfer_len += read_count; if (read_count < g_musb_udc.out_ep[0].ep_mps) { - usbd_event_ep_out_complete_handler(0x00, g_musb_udc.out_ep[0].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, 0x00, g_musb_udc.out_ep[0].actual_xfer_len); HWREGB(USB_BASE + MUSB_IND_TXCSRL_OFFSET) = (USB_CSRL0_RXRDYC | USB_CSRL0_DATAEND); usb_ep0_state = USB_EP0_STATE_IN_STATUS; } else { @@ -770,7 +770,7 @@ static void handle_ep0(void) case USB_EP0_STATE_IN_STATUS: case USB_EP0_STATE_IN_ZLP: usb_ep0_state = USB_EP0_STATE_SETUP; - usbd_event_ep_in_complete_handler(0x80, 0); + usbd_event_ep_in_complete_handler(0, 0x80, 0); break; } } @@ -849,7 +849,7 @@ void USBD_IRQHandler(void) if (g_musb_udc.in_ep[ep_idx].xfer_len == 0) { HWREGH(USB_BASE + MUSB_TXIE_OFFSET) &= ~(1 << ep_idx); - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_musb_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_musb_udc.in_ep[ep_idx].actual_xfer_len); } else { write_count = MIN(g_musb_udc.in_ep[ep_idx].xfer_len, g_musb_udc.in_ep[ep_idx].ep_mps); @@ -880,7 +880,7 @@ void USBD_IRQHandler(void) if ((read_count < g_musb_udc.out_ep[ep_idx].ep_mps) || (g_musb_udc.out_ep[ep_idx].xfer_len == 0)) { HWREGH(USB_BASE + MUSB_RXIE_OFFSET) &= ~(1 << ep_idx); - usbd_event_ep_out_complete_handler(ep_idx, g_musb_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_musb_udc.out_ep[ep_idx].actual_xfer_len); } else { } } diff --git a/port/nuvoton/README.md b/port/nuvoton/README.md index 1198c574..a91c8fae 100644 --- a/port/nuvoton/README.md +++ b/port/nuvoton/README.md @@ -5,10 +5,3 @@ - M032 Series - M480 Series -## Before Use - -Configure USBD_EPNUM. -Your should implement `usb_dc_low_level_init` and `usb_dc_low_level_deinit`. -- Enable or disable USB clock and set USB clock for 48M. -- Enable or disable gpio and gpio clk for usb dp and dm. -- Enable or disable usb irq diff --git a/port/nuvoton/usb_dc_usbfs.c b/port/nuvoton/usb_dc_usbfs.c index f283a727..d33d4d5a 100644 --- a/port/nuvoton/usb_dc_usbfs.c +++ b/port/nuvoton/usb_dc_usbfs.c @@ -97,7 +97,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { memset(&g_nuvoton_udc, 0, sizeof(g_nuvoton_udc)); @@ -149,7 +149,7 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { USBD->ATTR = 0x00000040; /* Force SE0 */ @@ -158,7 +158,7 @@ int usb_dc_deinit(void) return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { uint8_t usbd_addr = USBD_GET_ADDR(); if ((usbd_addr == 0) && (usbd_addr != addr)) { @@ -169,12 +169,12 @@ int usbd_set_address(const uint8_t addr) return 0; } -uint8_t usbd_get_port_speed(const uint8_t port) +uint8_t usbd_get_port_speed(uint8_t busid, const uint8_t port) { return USB_SPEED_FULL; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -209,31 +209,31 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { USBD->EP[USBD_EPNUM_FROM_EPADDR(ep)].CFG &= ~USBD_CFG_STATE_Msk; // disable endpoint return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { USBD_SET_EP_STALL(USBD_EPNUM_FROM_EPADDR(ep)); return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { USBD_CLR_EP_STALL(USBD_EPNUM_FROM_EPADDR(ep)); return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { *stalled = USBD_GET_EP_STALL(USBD_EPNUM_FROM_EPADDR(ep)) > 0 ? 1 : 0; return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -264,7 +264,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); @@ -304,11 +304,11 @@ void USBD_IRQHandler(void) if (USBD_IS_ATTACHED()) { /* USB Plug In */ USBD_ENABLE_USB(); - usbd_event_connect_handler(); + usbd_event_connect_handler(0); } else { /* USB Un-plug */ USBD_DISABLE_USB(); - usbd_event_disconnect_handler(); + usbd_event_disconnect_handler(0); } } @@ -330,18 +330,18 @@ void USBD_IRQHandler(void) USBD_SET_ADDR(0ul); g_nuvoton_udc.dev_addr = 0; - usbd_event_reset_handler(); + usbd_event_reset_handler(0); } if (bus_state & USBD_STATE_SUSPEND) { /* Enable USB but disable PHY */ USBD_DISABLE_PHY(); - usbd_event_suspend_handler(); + usbd_event_suspend_handler(0); } if (bus_state & USBD_STATE_RESUME) { /* Enable USB and enable PHY */ USBD_ENABLE_USB(); - usbd_event_resume_handler(); + usbd_event_resume_handler(0); } } @@ -363,7 +363,7 @@ void USBD_IRQHandler(void) USBD_STOP_TRANSACTION(EP1); usbd_out_toggle[0] = 0; - usbd_event_ep0_setup_complete_handler((uint8_t *)(USBD_BUF_BASE)); + usbd_event_ep0_setup_complete_handler(0, (uint8_t *)(USBD_BUF_BASE)); } if (int_flag & USBD_INTSTS_EP0) { @@ -416,7 +416,7 @@ void USBD_IRQHandler(void) if ((recv_count < g_nuvoton_udc.out_ep[ep_idx].ep_mps) || (g_nuvoton_udc.out_ep[ep_idx].xfer_len == 0)) { - usbd_event_ep_out_complete_handler(ep_idx, g_nuvoton_udc.out_ep[ep_idx].actual_xfer_len); + usbd_event_ep_out_complete_handler(0, ep_idx, g_nuvoton_udc.out_ep[ep_idx].actual_xfer_len); } else { if (g_nuvoton_udc.out_ep[ep_idx].xfer_len < g_nuvoton_udc.out_ep[ep_idx].ep_mps) { g_nuvoton_udc.out_ep[ep_idx].mps_xfer_len = g_nuvoton_udc.out_ep[ep_idx].xfer_len; @@ -445,7 +445,7 @@ void USBD_IRQHandler(void) g_nuvoton_udc.in_ep[ep_idx].actual_xfer_len += g_nuvoton_udc.in_ep[ep_idx].xfer_len; g_nuvoton_udc.in_ep[ep_idx].xfer_len = 0; - usbd_event_ep_in_complete_handler(ep_idx | 0x80, g_nuvoton_udc.in_ep[ep_idx].actual_xfer_len); + usbd_event_ep_in_complete_handler(0, ep_idx | 0x80, g_nuvoton_udc.in_ep[ep_idx].actual_xfer_len); } } } diff --git a/port/pusb2/usb_dc_pusb2.c b/port/pusb2/usb_dc_pusb2.c index 24a90adc..843df9cf 100644 --- a/port/pusb2/usb_dc_pusb2.c +++ b/port/pusb2/usb_dc_pusb2.c @@ -81,7 +81,7 @@ static void pusb2_dc_connect_handler(FPUsb2DcController *instance) USB_LOG_DBG("%s \n", __func__); - usbd_event_reset_handler(); + usbd_event_reset_handler(0); /* update speed and max packet size when connect */ g_pusb2_udc.speed = dc_dev->speed; @@ -116,7 +116,7 @@ static uint32_t pusb2_dc_receive_steup_handler(FPUsb2DcController *instance, FUs setup->wLength, setup->wValue); - usbd_event_ep0_setup_complete_handler((u8 *)setup); + usbd_event_ep0_setup_complete_handler(0, (u8 *)setup); return 0; } @@ -205,7 +205,7 @@ static void pusb2_dc_prepare_ctrl_config(FPUsb2Config *config) return; } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { memset(&g_pusb2_udc, 0, sizeof(struct pusb2_udc)); @@ -222,7 +222,7 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { usb_dc_low_level_deinit(); @@ -230,7 +230,7 @@ int usb_dc_deinit(void) return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { g_pusb2_udc.dev_addr = addr; return 0; @@ -251,7 +251,7 @@ static struct usb_endpoint_descriptor *usbd_get_ep0_desc(const struct usb_endpoi return &ep0_desc; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); struct pusb2_dc_ep_state *ep_state; @@ -283,7 +283,7 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); struct pusb2_dc_ep_state *ep_state; @@ -304,7 +304,7 @@ int usbd_ep_close(const uint8_t ep) return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); struct pusb2_dc_ep_state *ep_state; @@ -325,7 +325,7 @@ int usbd_ep_set_stall(const uint8_t ep) return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep); struct pusb2_dc_ep_state *ep_state; @@ -346,7 +346,7 @@ int usbd_ep_clear_stall(const uint8_t ep) return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { uint8_t ep_idx = USB_EP_GET_IDX(ep); struct pusb2_dc_ep_state *ep_state; @@ -406,9 +406,9 @@ void pusb2_dc_callback_complete(FPUsb2DcEp *priv_ep, FPUsb2DcReq *priv_request) request = priv_request->context; if (USB_EP_DIR_IS_OUT(priv_ep->address)) { - usbd_event_ep_out_complete_handler(priv_ep->address, priv_request->actual); + usbd_event_ep_out_complete_handler(0, priv_ep->address, priv_request->actual); } else { - usbd_event_ep_in_complete_handler(priv_ep->address, priv_request->actual); + usbd_event_ep_in_complete_handler(0, priv_ep->address, priv_request->actual); } request->status = priv_request->status; @@ -458,12 +458,12 @@ int pusb2_dc_ep_read_write(const uint8_t ep, uintptr data, uint32_t data_len) return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { return pusb2_dc_ep_read_write(ep, (uintptr)data, data_len); } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { return pusb2_dc_ep_read_write(ep, (uintptr)data, data_len); } diff --git a/port/template/usb_dc.c b/port/template/usb_dc.c index 3216b28b..0aeea0c9 100644 --- a/port/template/usb_dc.c +++ b/port/template/usb_dc.c @@ -33,7 +33,7 @@ __WEAK void usb_dc_low_level_deinit(void) { } -int usb_dc_init(void) +int usb_dc_init(uint8_t busid) { memset(&g_xxx_udc, 0, sizeof(struct xxx_udc)); @@ -41,17 +41,17 @@ int usb_dc_init(void) return 0; } -int usb_dc_deinit(void) +int usb_dc_deinit(uint8_t busid) { return 0; } -int usbd_set_address(const uint8_t addr) +int usbd_set_address(uint8_t busid, const uint8_t addr) { return 0; } -int usbd_ep_open(const struct usb_endpoint_descriptor *ep) +int usbd_ep_open(uint8_t busid, const struct usb_endpoint_descriptor *ep) { uint8_t ep_idx = USB_EP_GET_IDX(ep->bEndpointAddress); @@ -65,27 +65,27 @@ int usbd_ep_open(const struct usb_endpoint_descriptor *ep) return 0; } -int usbd_ep_close(const uint8_t ep) +int usbd_ep_close(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_set_stall(const uint8_t ep) +int usbd_ep_set_stall(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_clear_stall(const uint8_t ep) +int usbd_ep_clear_stall(uint8_t busid, const uint8_t ep) { return 0; } -int usbd_ep_is_stalled(const uint8_t ep, uint8_t *stalled) +int usbd_ep_is_stalled(uint8_t busid, const uint8_t ep, uint8_t *stalled) { return 0; } -int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len) +int usbd_ep_start_write(uint8_t busid, const uint8_t ep, const uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep); uint32_t tmp; @@ -101,7 +101,7 @@ int usbd_ep_start_write(const uint8_t ep, const uint8_t *data, uint32_t data_len return 0; } -int usbd_ep_start_read(const uint8_t ep, uint8_t *data, uint32_t data_len) +int usbd_ep_start_read(uint8_t busid, const uint8_t ep, uint8_t *data, uint32_t data_len) { uint8_t ep_idx = USB_EP_GET_IDX(ep);