summaryrefslogtreecommitdiff
path: root/src/device
diff options
context:
space:
mode:
Diffstat (limited to 'src/device')
-rw-r--r--src/device/dcd.h16
-rw-r--r--src/device/usbd.c203
-rw-r--r--src/device/usbd.h1
-rw-r--r--src/device/usbd_auto_desc.c63
-rw-r--r--src/device/usbd_control.c7
-rw-r--r--src/device/usbd_pvt.h6
6 files changed, 166 insertions, 130 deletions
diff --git a/src/device/dcd.h b/src/device/dcd.h
index db84df839..abd85a70b 100644
--- a/src/device/dcd.h
+++ b/src/device/dcd.h
@@ -90,14 +90,18 @@ typedef struct ATTR_ALIGNED(4)
TU_VERIFY_STATIC(sizeof(dcd_event_t) <= 12, "size is not correct");
/*------------------------------------------------------------------*/
-/* Device API (Weak is optional)
+/* Device API
*------------------------------------------------------------------*/
-bool dcd_init (uint8_t rhport);
-void dcd_set_address (uint8_t rhport, uint8_t dev_addr);
-void dcd_set_config (uint8_t rhport, uint8_t config_num);
+bool dcd_init (uint8_t rhport);
-void dcd_connect (uint8_t rhport) ATTR_WEAK;
-void dcd_disconnect (uint8_t rhport) ATTR_WEAK;
+void dcd_int_enable (uint8_t rhport);
+void dcd_int_disable(uint8_t rhport);
+
+void dcd_set_address(uint8_t rhport, uint8_t dev_addr);
+void dcd_set_config (uint8_t rhport, uint8_t config_num);
+
+// Get current frame number
+uint32_t dcd_get_frame_number(uint8_t rhport);
/*------------------------------------------------------------------*/
/* Event Function
diff --git a/src/device/usbd.c b/src/device/usbd.c
index 8c7e588e0..9c08a7932 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -36,8 +36,6 @@
*/
/**************************************************************************/
-// This top level class manages the bus state and delegates events to class-specific drivers.
-
#include "tusb_option.h"
#if TUSB_OPT_DEVICE_ENABLED
@@ -52,15 +50,6 @@
#define CFG_TUD_TASK_QUEUE_SZ 16
#endif
-#ifndef CFG_TUD_TASK_STACK_SZ
-#define CFG_TUD_TASK_STACK_SZ 150
-#endif
-
-#ifndef CFG_TUD_TASK_PRIO
-#define CFG_TUD_TASK_PRIO 0
-#endif
-
-
//--------------------------------------------------------------------+
// Device Data
//--------------------------------------------------------------------+
@@ -68,7 +57,7 @@ typedef struct {
uint8_t config_num;
uint8_t itf2drv[16]; // map interface number to driver (0xff is invalid)
- uint8_t ep2drv[2][8]; // map endpoint to driver ( 0xff is invalid )
+ uint8_t ep2drv[8][2]; // map endpoint to driver ( 0xff is invalid )
}usbd_device_t;
@@ -88,13 +77,13 @@ tud_desc_set_t const* usbd_desc_set = &tud_desc_set;
typedef struct {
uint8_t class_code;
- void (* init ) (void);
- tusb_error_t (* open ) (uint8_t rhport, tusb_desc_interface_t const * desc_intf, uint16_t* p_length);
- bool (* control_request ) (uint8_t rhport, tusb_control_request_t const * request);
+ void (* init ) (void);
+ bool (* open ) (uint8_t rhport, tusb_desc_interface_t const * desc_intf, uint16_t* p_length);
+ bool (* control_request ) (uint8_t rhport, tusb_control_request_t const * request);
bool (* control_request_complete ) (uint8_t rhport, tusb_control_request_t const * request);
- tusb_error_t (* xfer_cb ) (uint8_t rhport, uint8_t ep_addr, xfer_result_t, uint32_t);
- void (* sof ) (uint8_t rhport);
- void (* reset ) (uint8_t);
+ bool (* xfer_cb ) (uint8_t rhport, uint8_t ep_addr, xfer_result_t, uint32_t);
+ void (* sof ) (uint8_t rhport);
+ void (* reset ) (uint8_t);
} usbd_class_driver_t;
static usbd_class_driver_t const usbd_class_drivers[] =
@@ -139,6 +128,19 @@ static usbd_class_driver_t const usbd_class_drivers[] =
},
#endif
+ #if CFG_TUD_MIDI
+ {
+ .class_code = TUSB_CLASS_AUDIO,
+ .init = midid_init,
+ .open = midid_open,
+ .control_request = midid_control_request,
+ .control_request_complete = midid_control_request_complete,
+ .xfer_cb = midid_xfer_cb,
+ .sof = NULL,
+ .reset = midid_reset
+ },
+ #endif
+
#if CFG_TUD_CUSTOM_CLASS
{
.class_code = TUSB_CLASS_VENDOR_SPECIFIC,
@@ -153,24 +155,23 @@ static usbd_class_driver_t const usbd_class_drivers[] =
#endif
};
-enum { USBD_CLASS_DRIVER_COUNT = sizeof(usbd_class_drivers) / sizeof(usbd_class_driver_t) };
-
+enum { USBD_CLASS_DRIVER_COUNT = TU_ARRAY_SZIE(usbd_class_drivers) };
//--------------------------------------------------------------------+
// DCD Event
//--------------------------------------------------------------------+
-OSAL_TASK_DEF(_usbd_task_def, "usbd", usbd_task, CFG_TUD_TASK_PRIO, CFG_TUD_TASK_STACK_SZ);
-/*------------- event queue -------------*/
-OSAL_QUEUE_DEF(_usbd_qdef, CFG_TUD_TASK_QUEUE_SZ, dcd_event_t);
+// Event queue
+// OPT_MODE_DEVICE is used by OS NONE for mutex (disable usb isr)
+OSAL_QUEUE_DEF(OPT_MODE_DEVICE, _usbd_qdef, CFG_TUD_TASK_QUEUE_SZ, dcd_event_t);
static osal_queue_t _usbd_q;
//--------------------------------------------------------------------+
// Prototypes
//--------------------------------------------------------------------+
-static void mark_interface_endpoint(uint8_t const* p_desc, uint16_t desc_len, uint8_t driver_id);
+static void mark_interface_endpoint(uint8_t ep2drv[8][2], uint8_t const* p_desc, uint16_t desc_len, uint8_t driver_id);
static bool process_control_request(uint8_t rhport, tusb_control_request_t const * p_request);
-static bool process_set_config(uint8_t rhport, uint8_t config_number);
+static bool process_set_config(uint8_t rhport);
static void const* get_descriptor(tusb_control_request_t const * p_request, uint16_t* desc_len);
void usbd_control_reset (uint8_t rhport);
@@ -188,26 +189,20 @@ bool tud_mounted(void)
//--------------------------------------------------------------------+
// USBD Task
//--------------------------------------------------------------------+
-tusb_error_t usbd_init (void)
+bool usbd_init (void)
{
- #if (CFG_TUSB_RHPORT0_MODE & OPT_MODE_DEVICE)
- dcd_init(0);
- #endif
-
- #if (CFG_TUSB_RHPORT1_MODE & OPT_MODE_DEVICE)
- dcd_init(1);
- #endif
-
- //------------- Task init -------------//
+ // Init device queue & task
_usbd_q = osal_queue_create(&_usbd_qdef);
- TU_VERIFY(_usbd_q, TUSB_ERROR_OSAL_QUEUE_FAILED);
-
- osal_task_create(&_usbd_task_def);
+ TU_ASSERT(_usbd_q != NULL);
- //------------- class init -------------//
+ // Init class drivers
for (uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++) usbd_class_drivers[i].init();
- return TUSB_ERROR_NONE;
+ // Init device controller driver
+ TU_ASSERT(dcd_init(TUD_OPT_RHPORT));
+ dcd_int_enable(TUD_OPT_RHPORT);
+
+ return true;
}
static void usbd_reset(uint8_t rhport)
@@ -224,8 +219,26 @@ static void usbd_reset(uint8_t rhport)
}
}
-// Main device task implementation
-static void usbd_task_body(void)
+/* USB Device Driver task
+ * This top level thread manages all device controller event and delegates events to class-specific drivers.
+ * This should be called periodically within the mainloop or rtos thread.
+ *
+ @code
+ int main(void)
+ {
+ application_init();
+ tusb_init();
+
+ while(1) // the mainloop
+ {
+ application_code();
+
+ tud_task(); // tinyusb device task
+ }
+ }
+ @endcode
+ */
+void tud_task (void)
{
// Loop until there is no more events in the queue
while (1)
@@ -249,14 +262,14 @@ static void usbd_task_body(void)
// Invoke the class callback associated with the endpoint address
uint8_t const ep_addr = event.xfer_complete.ep_addr;
- if ( 0 == edpt_number(ep_addr) )
+ if ( 0 == tu_edpt_number(ep_addr) )
{
// control transfer DATA stage callback
usbd_control_xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
}
else
{
- uint8_t const drv_id = _usbd_dev.ep2drv[edpt_dir(ep_addr)][edpt_number(ep_addr)];
+ uint8_t const drv_id = _usbd_dev.ep2drv[tu_edpt_number(ep_addr)][tu_edpt_dir(ep_addr)];
TU_ASSERT(drv_id < USBD_CLASS_DRIVER_COUNT,);
usbd_class_drivers[drv_id].xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
@@ -265,17 +278,18 @@ static void usbd_task_body(void)
break;
case DCD_EVENT_BUS_RESET:
- // note: if task is too slow, we could clear the event of the new attached
usbd_reset(event.rhport);
+ // TODO remove since if task is too slow, we could clear the event of the new attached
osal_queue_reset(_usbd_q);
break;
case DCD_EVENT_UNPLUGGED:
- // note: if task is too slow, we could clear the event of the new attached
usbd_reset(event.rhport);
+ // TODO remove since if task is too slow, we could clear the event of the new attached
osal_queue_reset(_usbd_q);
- tud_umount_cb(); // invoke callback
+ // invoke callback
+ if (tud_umount_cb) tud_umount_cb();
break;
case DCD_EVENT_SOF:
@@ -299,25 +313,6 @@ static void usbd_task_body(void)
}
}
-/* USB device task
- * Thread that handles all device events. With an real RTOS, the task must be a forever loop and never return.
- * For codign convenience with no RTOS, we use wrapped sub-function for processing to easily return at any time.
- */
-void usbd_task( void* param)
-{
- (void) param;
-
-#if CFG_TUSB_OS != OPT_OS_NONE
- while (1) {
-#endif
-
- usbd_task_body();
-
-#if CFG_TUSB_OS != OPT_OS_NONE
- }
-#endif
-}
-
//--------------------------------------------------------------------+
// Control Request Parser & Handling
//--------------------------------------------------------------------+
@@ -356,7 +351,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
dcd_set_config(rhport, config);
_usbd_dev.config_num = config;
- TU_ASSERT( TUSB_ERROR_NONE == process_set_config(rhport, config) );
+ TU_ASSERT( TUSB_ERROR_NONE == process_set_config(rhport) );
}
break;
@@ -378,7 +373,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
uint8_t const itf = tu_u16_low(p_request->wIndex);
uint8_t const drvid = _usbd_dev.itf2drv[ itf ];
- TU_VERIFY (drvid < USBD_CLASS_DRIVER_COUNT );
+ TU_VERIFY(drvid < USBD_CLASS_DRIVER_COUNT);
usbd_control_set_complete_callback(usbd_class_drivers[drvid].control_request_complete );
@@ -427,7 +422,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
// Process Set Configure Request
// This function parse configuration descriptor & open drivers accordingly
-static bool process_set_config(uint8_t rhport, uint8_t config_number)
+static bool process_set_config(uint8_t rhport)
{
uint8_t const * desc_cfg = (uint8_t const *) usbd_desc_set->config;
TU_ASSERT(desc_cfg != NULL);
@@ -438,12 +433,12 @@ static bool process_set_config(uint8_t rhport, uint8_t config_number)
while( p_desc < desc_cfg + cfg_len )
{
// Each interface always starts with Interface or Association descriptor
- if ( TUSB_DESC_INTERFACE_ASSOCIATION == descriptor_type(p_desc) )
+ if ( TUSB_DESC_INTERFACE_ASSOCIATION == tu_desc_type(p_desc) )
{
- p_desc = descriptor_next(p_desc); // ignore Interface Association
+ p_desc = tu_desc_next(p_desc); // ignore Interface Association
}else
{
- TU_ASSERT( TUSB_DESC_INTERFACE == descriptor_type(p_desc) );
+ TU_ASSERT( TUSB_DESC_INTERFACE == tu_desc_type(p_desc) );
tusb_desc_interface_t* desc_itf = (tusb_desc_interface_t*) p_desc;
@@ -453,44 +448,44 @@ static bool process_set_config(uint8_t rhport, uint8_t config_number)
{
if ( usbd_class_drivers[drv_id].class_code == desc_itf->bInterfaceClass ) break;
}
- TU_ASSERT( drv_id < USBD_CLASS_DRIVER_COUNT ); // unsupported class
+ TU_ASSERT( drv_id < USBD_CLASS_DRIVER_COUNT );
// Interface number must not be used already TODO alternate interface
TU_ASSERT( 0xff == _usbd_dev.itf2drv[desc_itf->bInterfaceNumber] );
_usbd_dev.itf2drv[desc_itf->bInterfaceNumber] = drv_id;
- uint16_t len=0;
- TU_ASSERT_ERR( usbd_class_drivers[drv_id].open( rhport, desc_itf, &len ), false );
- TU_ASSERT( len >= sizeof(tusb_desc_interface_t) );
+ uint16_t itf_len=0;
+ TU_ASSERT( usbd_class_drivers[drv_id].open( rhport, desc_itf, &itf_len ) );
+ TU_ASSERT( itf_len >= sizeof(tusb_desc_interface_t) );
- mark_interface_endpoint(p_desc, len, drv_id);
+ mark_interface_endpoint(_usbd_dev.ep2drv, p_desc, itf_len, drv_id);
- p_desc += len; // next interface
+ p_desc += itf_len; // next interface
}
}
// invoke callback
- tud_mount_cb();
+ if (tud_mount_cb) tud_mount_cb();
return TUSB_ERROR_NONE;
}
// Helper marking endpoint of interface belongs to class driver
-static void mark_interface_endpoint(uint8_t const* p_desc, uint16_t desc_len, uint8_t driver_id)
+static void mark_interface_endpoint(uint8_t ep2drv[8][2], uint8_t const* p_desc, uint16_t desc_len, uint8_t driver_id)
{
uint16_t len = 0;
while( len < desc_len )
{
- if ( TUSB_DESC_ENDPOINT == descriptor_type(p_desc) )
+ if ( TUSB_DESC_ENDPOINT == tu_desc_type(p_desc) )
{
uint8_t const ep_addr = ((tusb_desc_endpoint_t const*) p_desc)->bEndpointAddress;
- _usbd_dev.ep2drv[ edpt_dir(ep_addr) ][ edpt_number(ep_addr) ] = driver_id;
+ ep2drv[tu_edpt_number(ep_addr)][tu_edpt_dir(ep_addr)] = driver_id;
}
- len += descriptor_len(p_desc);
- p_desc = descriptor_next(p_desc);
+ len += tu_desc_len(p_desc);
+ p_desc = tu_desc_next(p_desc);
}
}
@@ -578,12 +573,17 @@ void dcd_event_handler(dcd_event_t const * event, bool in_isr)
case DCD_EVENT_XFER_COMPLETE:
// skip zero-length control status complete event, should dcd notifies us.
- if ( 0 == edpt_number(event->xfer_complete.ep_addr) && event->xfer_complete.len == 0) break;
+ if ( 0 == tu_edpt_number(event->xfer_complete.ep_addr) && event->xfer_complete.len == 0) break;
osal_queue_send(_usbd_q, event, in_isr);
TU_ASSERT(event->xfer_complete.result == XFER_RESULT_SUCCESS,);
break;
+ // Not an DCD event, just a convenient way to defer ISR function should we need
+ case USBD_EVT_FUNC_CALL:
+ osal_queue_send(_usbd_q, event, in_isr);
+ break;
+
default: break;
}
}
@@ -591,23 +591,23 @@ void dcd_event_handler(dcd_event_t const * event, bool in_isr)
// helper to send bus signal event
void dcd_event_bus_signal (uint8_t rhport, dcd_eventid_t eid, bool in_isr)
{
- dcd_event_t event = { .rhport = 0, .event_id = eid, };
+ dcd_event_t event = { .rhport = rhport, .event_id = eid, };
dcd_event_handler(&event, in_isr);
}
// helper to send setup received
void dcd_event_setup_received(uint8_t rhport, uint8_t const * setup, bool in_isr)
{
- dcd_event_t event = { .rhport = 0, .event_id = DCD_EVENT_SETUP_RECEIVED };
+ dcd_event_t event = { .rhport = rhport, .event_id = DCD_EVENT_SETUP_RECEIVED };
memcpy(&event.setup_received, setup, 8);
- dcd_event_handler(&event, true);
+ dcd_event_handler(&event, in_isr);
}
// helper to send transfer complete event
void dcd_event_xfer_complete (uint8_t rhport, uint8_t ep_addr, uint32_t xferred_bytes, uint8_t result, bool in_isr)
{
- dcd_event_t event = { .rhport = 0, .event_id = DCD_EVENT_XFER_COMPLETE };
+ dcd_event_t event = { .rhport = rhport, .event_id = DCD_EVENT_XFER_COMPLETE };
event.xfer_complete.ep_addr = ep_addr;
event.xfer_complete.len = xferred_bytes;
@@ -619,30 +619,33 @@ void dcd_event_xfer_complete (uint8_t rhport, uint8_t ep_addr, uint32_t xferred_
//--------------------------------------------------------------------+
// Helper
//--------------------------------------------------------------------+
-tusb_error_t usbd_open_edpt_pair(uint8_t rhport, tusb_desc_endpoint_t const* p_desc_ep, uint8_t xfer_type, uint8_t* ep_out, uint8_t* ep_in)
+
+// Helper to parse an pair of endpoint descriptors (IN & OUT)
+bool usbd_open_edpt_pair(uint8_t rhport, tusb_desc_endpoint_t const* ep_desc, uint8_t xfer_type, uint8_t* ep_out, uint8_t* ep_in)
{
for(int i=0; i<2; i++)
{
- TU_ASSERT(TUSB_DESC_ENDPOINT == p_desc_ep->bDescriptorType &&
- xfer_type == p_desc_ep->bmAttributes.xfer, TUSB_ERROR_DESCRIPTOR_CORRUPTED);
+ TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType &&
+ xfer_type == ep_desc->bmAttributes.xfer );
- TU_ASSERT( dcd_edpt_open(rhport, p_desc_ep), TUSB_ERROR_DCD_OPEN_PIPE_FAILED );
+ TU_ASSERT(dcd_edpt_open(rhport, ep_desc));
- if ( edpt_dir(p_desc_ep->bEndpointAddress) == TUSB_DIR_IN )
+ if ( tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN )
{
- (*ep_in) = p_desc_ep->bEndpointAddress;
+ (*ep_in) = ep_desc->bEndpointAddress;
}else
{
- (*ep_out) = p_desc_ep->bEndpointAddress;
+ (*ep_out) = ep_desc->bEndpointAddress;
}
- p_desc_ep = (tusb_desc_endpoint_t const *) descriptor_next( (uint8_t const*) p_desc_ep );
+ ep_desc = (tusb_desc_endpoint_t const *) tu_desc_next(ep_desc);
}
- return TUSB_ERROR_NONE;
+ return true;
}
-void usbd_defer_func(osal_task_func_t func, void* param, bool in_isr )
+// Helper to defer an isr function
+void usbd_defer_func(osal_task_func_t func, void* param, bool in_isr)
{
dcd_event_t event =
{
@@ -653,7 +656,7 @@ void usbd_defer_func(osal_task_func_t func, void* param, bool in_isr )
event.func_call.func = func;
event.func_call.param = param;
- osal_queue_send(_usbd_q, &event, in_isr);
+ dcd_event_handler(&event, in_isr);
}
#endif
diff --git a/src/device/usbd.h b/src/device/usbd.h
index f9e0d8f4d..f9e7368ce 100644
--- a/src/device/usbd.h
+++ b/src/device/usbd.h
@@ -81,6 +81,7 @@ extern tud_desc_set_t tud_desc_set;
// APPLICATION API
//--------------------------------------------------------------------+
bool tud_mounted(void);
+void tud_task (void);
//--------------------------------------------------------------------+
// APPLICATION CALLBACK (WEAK is optional)
diff --git a/src/device/usbd_auto_desc.c b/src/device/usbd_auto_desc.c
index 2d54a934d..028d1b433 100644
--- a/src/device/usbd_auto_desc.c
+++ b/src/device/usbd_auto_desc.c
@@ -101,18 +101,19 @@ enum
ITF_NUM_TOTAL
};
-enum {
- ITF_STR_LANGUAGE = 0 ,
- ITF_STR_MANUFACTURER ,
- ITF_STR_PRODUCT ,
- ITF_STR_SERIAL ,
+enum
+{
+ ITF_STR_LANGUAGE = 0 ,
+ ITF_STR_MANUFACTURER ,
+ ITF_STR_PRODUCT ,
+ ITF_STR_SERIAL ,
#if CFG_TUD_CDC
- ITF_STR_CDC ,
+ ITF_STR_CDC ,
#endif
#if CFG_TUD_MSC
- ITF_STR_MSC ,
+ ITF_STR_MSC ,
#endif
#if CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT
@@ -133,23 +134,51 @@ enum {
#define _EP_OUT(x) (x)
// CDC
-#define EP_CDC_NOTIF _EP_IN ( ITF_NUM_CDC+1 )
+#ifdef CFG_TUD_DESC_CDC_EPNUM_NOTIF
+ #define EP_CDC_NOTIF _EP_IN (CFG_TUD_DESC_CDC_EPNUM_NOTIF)
+#else
+ #define EP_CDC_NOTIF _EP_IN ( ITF_NUM_CDC+1 )
+#endif
#define EP_CDC_NOTIF_SIZE 8
-#define EP_CDC_OUT _EP_OUT( ITF_NUM_CDC+2 )
-#define EP_CDC_IN _EP_IN ( ITF_NUM_CDC+2 )
+#ifdef CFG_TUD_DESC_CDC_EPNUM
+ #define EP_CDC_OUT _EP_OUT( CFG_TUD_DESC_CDC_EPNUM )
+ #define EP_CDC_IN _EP_IN ( CFG_TUD_DESC_CDC_EPNUM )
+#else
+ #define EP_CDC_OUT _EP_OUT( ITF_NUM_CDC+2 )
+ #define EP_CDC_IN _EP_IN ( ITF_NUM_CDC+2 )
+#endif
// Mass Storage
-#define EP_MSC_OUT _EP_OUT( ITF_NUM_MSC+1 )
-#define EP_MSC_IN _EP_IN ( ITF_NUM_MSC+1 )
+#ifdef CFG_TUD_DESC_MSC_EPNUM
+ #define EP_MSC_OUT _EP_OUT( CFG_TUD_DESC_MSC_EPNUM )
+ #define EP_MSC_IN _EP_IN ( CFG_TUD_DESC_MSC_EPNUM )
+#else
+ #define EP_MSC_OUT _EP_OUT( ITF_NUM_MSC+1 )
+ #define EP_MSC_IN _EP_IN ( ITF_NUM_MSC+1 )
+#endif
+
+#if TUD_OPT_HIGH_SPEED
+#define EP_MSC_SIZE 512
+#else
+#define EP_MSC_SIZE 64
+#endif
// HID Keyboard with boot protocol
-#define EP_HID_KBD_BOOT _EP_IN ( ITF_NUM_HID_BOOT_KBD+1 )
+#ifdef CFG_TUD_DESC_HID_KEYBOARD_EPNUM
+ #define EP_HID_KBD_BOOT _EP_IN ( CFG_TUD_DESC_HID_KEYBOARD_EPNUM )
+#else
+ #define EP_HID_KBD_BOOT _EP_IN ( ITF_NUM_HID_BOOT_KBD+1 )
+#endif
#define EP_HID_KBD_BOOT_SZ 8
// HID Mouse with boot protocol
-#define EP_HID_MSE_BOOT _EP_IN ( ITF_NUM_HID_BOOT_MSE+1 )
+#ifdef CFG_TUD_DESC_HID_MOUSE_EPNUM
+ #define EP_HID_MSE_BOOT _EP_IN ( CFG_TUD_DESC_HID_MOUSE_EPNUM )
+#else
+ #define EP_HID_MSE_BOOT _EP_IN ( ITF_NUM_HID_BOOT_MSE+1 )
+#endif
#define EP_HID_MSE_BOOT_SZ 8
// HID composite = keyboard + mouse + gamepad + etc ...
@@ -466,7 +495,7 @@ desc_auto_cfg_t const _desc_auto_config_struct =
.bDescriptorType = TUSB_DESC_ENDPOINT,
.bEndpointAddress = EP_MSC_OUT,
.bmAttributes = { .xfer = TUSB_XFER_BULK },
- .wMaxPacketSize = { .size = CFG_TUD_MSC_EPSIZE},
+ .wMaxPacketSize = { .size = EP_MSC_SIZE},
.bInterval = 1
},
@@ -476,7 +505,7 @@ desc_auto_cfg_t const _desc_auto_config_struct =
.bDescriptorType = TUSB_DESC_ENDPOINT,
.bEndpointAddress = EP_MSC_IN,
.bmAttributes = { .xfer = TUSB_XFER_BULK },
- .wMaxPacketSize = { .size = CFG_TUD_MSC_EPSIZE},
+ .wMaxPacketSize = { .size = EP_MSC_SIZE},
.bInterval = 1
}
},
@@ -563,7 +592,6 @@ desc_auto_cfg_t const _desc_auto_config_struct =
#endif // boot mouse
#if AUTO_DESC_HID_GENERIC
-
//------------- HID Generic Multiple report -------------//
.hid_generic =
{
@@ -601,7 +629,6 @@ desc_auto_cfg_t const _desc_auto_config_struct =
.bInterval = 0x0A
}
}
-
#endif // hid generic
};
diff --git a/src/device/usbd_control.c b/src/device/usbd_control.c
index 31d74edf0..ae7e894b7 100644
--- a/src/device/usbd_control.c
+++ b/src/device/usbd_control.c
@@ -68,6 +68,7 @@ CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN uint8_t _usbd_ctrl_buf[CFG_TUD_ENDOINT0_
void usbd_control_reset (uint8_t rhport)
{
+ (void) rhport;
tu_varclr(&_control_state);
}
@@ -82,7 +83,6 @@ bool usbd_control_status(uint8_t rhport, tusb_control_request_t const * request)
return dcd_edpt_xfer(rhport, request->bmRequestType_bit.direction ? EDPT_CTRL_OUT : EDPT_CTRL_IN, NULL, 0);
}
-
// Each transaction is up to endpoint0's max packet size
static bool start_control_data_xact(uint8_t rhport)
{
@@ -126,8 +126,11 @@ bool usbd_control_xfer(uint8_t rhport, tusb_control_request_t const * request, v
}
// callback when a transaction complete on DATA stage of control endpoint
-bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
{
+ (void) result;
+ (void) ep_addr;
+
if ( _control_state.request.bmRequestType_bit.direction == TUSB_DIR_OUT )
{
memcpy(_control_state.buffer, _usbd_ctrl_buf, xferred_bytes);
diff --git a/src/device/usbd_pvt.h b/src/device/usbd_pvt.h
index 30f010887..06951673f 100644
--- a/src/device/usbd_pvt.h
+++ b/src/device/usbd_pvt.h
@@ -51,9 +51,7 @@ extern tud_desc_set_t const* usbd_desc_set;
//--------------------------------------------------------------------+
// INTERNAL API for stack management
//--------------------------------------------------------------------+
-tusb_error_t usbd_init (void);
-void usbd_task (void* param);
-
+bool usbd_init (void);
// Carry out Data and Status stage of control transfer
// - If len = 0, it is equivalent to sending status only
@@ -70,7 +68,7 @@ void usbd_control_stall(uint8_t rhport);
/* Helper
*------------------------------------------------------------------*/
// helper to parse an pair of In and Out endpoint descriptors. They must be consecutive
-tusb_error_t usbd_open_edpt_pair(uint8_t rhport, tusb_desc_endpoint_t const* p_desc_ep, uint8_t xfer_type, uint8_t* ep_out, uint8_t* ep_in);
+bool usbd_open_edpt_pair(uint8_t rhport, tusb_desc_endpoint_t const* p_desc_ep, uint8_t xfer_type, uint8_t* ep_out, uint8_t* ep_in);
void usbd_defer_func( osal_task_func_t func, void* param, bool in_isr );
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-20 05:42:34 +0000