Merge branch 'develop' into port-samg55
This commit is contained in:
hathach
commit
302746d02c
|
|
@ -0,0 +1,54 @@
|
|||
# TinyUSB contributors (sorted alphabetically)
|
||||
|
||||
* **[Adafruit Team](https://github.com/adafruit)**
|
||||
* Main supporter and sponsor for hardware boards and kits
|
||||
* Discussion and suggestion for feature and improvement
|
||||
* Design the project logo
|
||||
|
||||
* **[arturo182](https://github.com/arturo182)**
|
||||
* Board support for MiMX RT1010 evaluation kit
|
||||
|
||||
* **[Ha Thach](https://github.com/hathach)**
|
||||
* Author and maintainer
|
||||
* Most features develpopment
|
||||
|
||||
* **[Jeff Epler](https://github.com/jepler)**
|
||||
* Improvement to MIDI device driver
|
||||
|
||||
* **[Kamil Tomaszewski](https://github.com/kamtom480)**
|
||||
* Sony CXD56 device driver port for spresnese board
|
||||
|
||||
* **[Nathan Conrad](https://github.com/pigrew)**
|
||||
* STM32 fsdev Fullspeed device driver port for STM32 L0, F0, F1, F3 etc ...
|
||||
* USBTMC class driver support with example
|
||||
* Various improvement e.g Zero-length packet, Lint setup
|
||||
* Board support for STM32F070RB Nucleo, STM32F303 Discovery
|
||||
|
||||
* **[Scott Shawcroft](https://github.com/tannewt)**
|
||||
* SAMD21 and SAMD51 device driver port
|
||||
* MIDI device class driver support
|
||||
* Improvement to USBD control transfer, MSC, CDC class driver
|
||||
* Board support for Metro M0 & M4 express
|
||||
* Write the execellent porting.md documentation
|
||||
* Introduce inital Makefile
|
||||
|
||||
* **[Sean Cross](https://github.com/xobs)**
|
||||
* ValentyUSB eptri device driver port
|
||||
* Board support for fomu
|
||||
|
||||
* **[Sylvain "tnt" Munaut](https://github.com/smunaut)**
|
||||
* DFU runtime support with example
|
||||
|
||||
* **[Timon Skerutsch](https://github.com/PTS93)**
|
||||
* hid_test.js script and extensive test for bi-directional raw HID
|
||||
|
||||
* **[Tod E. Kurt](https://github.com/todbot)**
|
||||
* hid_test.js script and extensive test for bi-directional raw HID
|
||||
|
||||
* **[William D. Jones](https://github.com/cr1901)**
|
||||
* Synopsys DesignWare device driver port for STM32 L4, F2, F4, F7, H7 etc ...
|
||||
* MSP430 device driver port (WIP)
|
||||
* Board support for STM32F407 Discovery, STM32H743 Nucleo, pyboard v1.1
|
||||
|
||||
|
||||
**[Full contributors list](https://github.com/hathach/tinyusb/contributors).**
|
||||
|
|
@ -21,6 +21,11 @@ TinyUSB is an open-source cross-platform USB Host/Device stack for embedded syst
|
|||
└── tools # Files used internally
|
||||
```
|
||||
|
||||
## Contributors
|
||||
|
||||
Special thanks for all the people who had spent their precious time and effort to helped this project so far. Check out
|
||||
[CONTRIBUTORS.md](CONTRIBUTORS.md) file for the list of all contributors and their awesome work for the stack.
|
||||
|
||||
## Supported MCUs
|
||||
|
||||
The stack supports the following MCUs
|
||||
|
|
@ -32,7 +37,7 @@ The stack supports the following MCUs
|
|||
- iMX RT Series: RT1011, RT1015, RT1021, RT1052, RT1062, RT1064
|
||||
- **Sony:** CXD56
|
||||
- **ST:** STM32 series: L0, F0, F1, F2, F3, F4, F7, H7 (device only)
|
||||
- **[valentyusb](https://github.com/im-tomu/valentyusb)** eptri
|
||||
- **[ValentyUSB](https://github.com/im-tomu/valentyusb)** eptri
|
||||
|
||||
[Here is the list of supported Boards](docs/boards.md) that can be used with provided examples.
|
||||
|
||||
|
|
|
|||
|
|
@ -311,8 +311,8 @@ bool cdcd_control_complete(uint8_t rhport, tusb_control_request_t const * reques
|
|||
// return false to stall control endpoint (e.g unsupported request)
|
||||
bool cdcd_control_request(uint8_t rhport, tusb_control_request_t const * request)
|
||||
{
|
||||
//------------- Class Specific Request -------------//
|
||||
TU_ASSERT(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
// Handle class request only
|
||||
TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
|
||||
// TODO Support multiple interfaces
|
||||
uint8_t const itf = 0;
|
||||
|
|
|
|||
|
|
@ -79,21 +79,17 @@ bool dfu_rtd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16
|
|||
bool dfu_rtd_control_complete(uint8_t rhport, tusb_control_request_t const * request)
|
||||
{
|
||||
(void) rhport;
|
||||
(void) request;
|
||||
|
||||
//------------- Class Specific Request -------------//
|
||||
TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
|
||||
|
||||
// nothing to do
|
||||
return true;
|
||||
}
|
||||
|
||||
bool dfu_rtd_control_request(uint8_t rhport, tusb_control_request_t const * request)
|
||||
{
|
||||
(void) rhport;
|
||||
|
||||
//------------- Class Specific Request -------------//
|
||||
TU_ASSERT(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
TU_ASSERT(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
|
||||
// Handle class request only
|
||||
TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
|
||||
|
||||
switch ( request->bRequest )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -191,89 +191,87 @@ bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t
|
|||
|
||||
// Handle class control request
|
||||
// return false to stall control endpoint (e.g unsupported request)
|
||||
bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
|
||||
bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * request)
|
||||
{
|
||||
if (p_request->bmRequestType_bit.recipient != TUSB_REQ_RCPT_INTERFACE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex );
|
||||
TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
|
||||
|
||||
hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) request->wIndex );
|
||||
TU_ASSERT(p_hid);
|
||||
|
||||
if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD)
|
||||
if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD)
|
||||
{
|
||||
//------------- STD Request -------------//
|
||||
uint8_t const desc_type = tu_u16_high(p_request->wValue);
|
||||
uint8_t const desc_index = tu_u16_low (p_request->wValue);
|
||||
uint8_t const desc_type = tu_u16_high(request->wValue);
|
||||
uint8_t const desc_index = tu_u16_low (request->wValue);
|
||||
(void) desc_index;
|
||||
|
||||
if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID)
|
||||
if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID)
|
||||
{
|
||||
TU_VERIFY(p_hid->hid_descriptor != NULL);
|
||||
TU_VERIFY(tud_control_xfer(rhport, p_request, (void*) p_hid->hid_descriptor, p_hid->hid_descriptor->bLength));
|
||||
TU_VERIFY(tud_control_xfer(rhport, request, (void*) p_hid->hid_descriptor, p_hid->hid_descriptor->bLength));
|
||||
}
|
||||
else if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)
|
||||
else if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)
|
||||
{
|
||||
uint8_t const * desc_report = tud_hid_descriptor_report_cb();
|
||||
tud_control_xfer(rhport, p_request, (void*) desc_report, p_hid->report_desc_len);
|
||||
tud_control_xfer(rhport, request, (void*) desc_report, p_hid->report_desc_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false; // stall unsupported request
|
||||
}
|
||||
}
|
||||
else if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)
|
||||
else if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)
|
||||
{
|
||||
//------------- Class Specific Request -------------//
|
||||
switch( p_request->bRequest )
|
||||
switch( request->bRequest )
|
||||
{
|
||||
case HID_REQ_CONTROL_GET_REPORT:
|
||||
{
|
||||
// wValue = Report Type | Report ID
|
||||
uint8_t const report_type = tu_u16_high(p_request->wValue);
|
||||
uint8_t const report_id = tu_u16_low(p_request->wValue);
|
||||
uint8_t const report_type = tu_u16_high(request->wValue);
|
||||
uint8_t const report_id = tu_u16_low(request->wValue);
|
||||
|
||||
uint16_t xferlen = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epin_buf, p_request->wLength);
|
||||
uint16_t xferlen = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epin_buf, request->wLength);
|
||||
TU_ASSERT( xferlen > 0 );
|
||||
|
||||
tud_control_xfer(rhport, p_request, p_hid->epin_buf, xferlen);
|
||||
tud_control_xfer(rhport, request, p_hid->epin_buf, xferlen);
|
||||
}
|
||||
break;
|
||||
|
||||
case HID_REQ_CONTROL_SET_REPORT:
|
||||
TU_VERIFY(p_request->wLength <= sizeof(p_hid->epout_buf));
|
||||
tud_control_xfer(rhport, p_request, p_hid->epout_buf, p_request->wLength);
|
||||
TU_VERIFY(request->wLength <= sizeof(p_hid->epout_buf));
|
||||
tud_control_xfer(rhport, request, p_hid->epout_buf, request->wLength);
|
||||
break;
|
||||
|
||||
case HID_REQ_CONTROL_SET_IDLE:
|
||||
p_hid->idle_rate = tu_u16_high(p_request->wValue);
|
||||
p_hid->idle_rate = tu_u16_high(request->wValue);
|
||||
if ( tud_hid_set_idle_cb )
|
||||
{
|
||||
// stall request if callback return false
|
||||
if ( !tud_hid_set_idle_cb(p_hid->idle_rate) ) return false;
|
||||
}
|
||||
|
||||
tud_control_status(rhport, p_request);
|
||||
tud_control_status(rhport, request);
|
||||
break;
|
||||
|
||||
case HID_REQ_CONTROL_GET_IDLE:
|
||||
// TODO idle rate of report
|
||||
tud_control_xfer(rhport, p_request, &p_hid->idle_rate, 1);
|
||||
tud_control_xfer(rhport, request, &p_hid->idle_rate, 1);
|
||||
break;
|
||||
|
||||
case HID_REQ_CONTROL_GET_PROTOCOL:
|
||||
{
|
||||
uint8_t protocol = (uint8_t)(1-p_hid->boot_mode); // 0 is Boot, 1 is Report protocol
|
||||
tud_control_xfer(rhport, p_request, &protocol, 1);
|
||||
tud_control_xfer(rhport, request, &protocol, 1);
|
||||
}
|
||||
break;
|
||||
|
||||
case HID_REQ_CONTROL_SET_PROTOCOL:
|
||||
p_hid->boot_mode = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol
|
||||
p_hid->boot_mode = 1 - request->wValue; // 0 is Boot, 1 is Report protocol
|
||||
|
||||
if (tud_hid_boot_mode_cb) tud_hid_boot_mode_cb(p_hid->boot_mode);
|
||||
|
||||
tud_control_status(rhport, p_request);
|
||||
tud_control_status(rhport, request);
|
||||
break;
|
||||
|
||||
default: return false; // stall unsupported request
|
||||
|
|
|
|||
|
|
@ -322,10 +322,9 @@ bool midid_control_complete(uint8_t rhport, tusb_control_request_t const * p_req
|
|||
bool midid_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
|
||||
{
|
||||
(void) rhport;
|
||||
(void) p_request;
|
||||
|
||||
//------------- Class Specific Request -------------//
|
||||
if (p_request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) return false;
|
||||
|
||||
// driver doesn't support any request yet
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -149,7 +149,8 @@ bool mscd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t
|
|||
// return false to stall control endpoint (e.g unsupported request)
|
||||
bool mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
|
||||
{
|
||||
TU_ASSERT(p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
// Handle class request only
|
||||
TU_VERIFY(p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
|
||||
|
||||
switch ( p_request->bRequest )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ typedef struct {
|
|||
void (* sof ) (uint8_t rhport);
|
||||
} usbd_class_driver_t;
|
||||
|
||||
static usbd_class_driver_t const usbd_class_drivers[] =
|
||||
static usbd_class_driver_t const _usbd_driver[] =
|
||||
{
|
||||
#if CFG_TUD_CDC
|
||||
{
|
||||
|
|
@ -183,7 +183,7 @@ static usbd_class_driver_t const usbd_class_drivers[] =
|
|||
#endif
|
||||
};
|
||||
|
||||
enum { USBD_CLASS_DRIVER_COUNT = TU_ARRAY_SIZE(usbd_class_drivers) };
|
||||
enum { USBD_CLASS_DRIVER_COUNT = TU_ARRAY_SIZE(_usbd_driver) };
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// DCD Event
|
||||
|
|
@ -304,7 +304,7 @@ bool tud_init (void)
|
|||
for (uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++)
|
||||
{
|
||||
TU_LOG2("%s init\r\n", _usbd_driver_str[i]);
|
||||
usbd_class_drivers[i].init();
|
||||
_usbd_driver[i].init();
|
||||
}
|
||||
|
||||
// Init device controller driver
|
||||
|
|
@ -325,7 +325,7 @@ static void usbd_reset(uint8_t rhport)
|
|||
|
||||
for (uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++)
|
||||
{
|
||||
if ( usbd_class_drivers[i].reset ) usbd_class_drivers[i].reset( rhport );
|
||||
if ( _usbd_driver[i].reset ) _usbd_driver[i].reset( rhport );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -414,7 +414,7 @@ void tud_task (void)
|
|||
TU_ASSERT(drv_id < USBD_CLASS_DRIVER_COUNT,);
|
||||
|
||||
TU_LOG2(" %s xfer callback\r\n", _usbd_driver_str[drv_id]);
|
||||
usbd_class_drivers[drv_id].xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
|
||||
_usbd_driver[drv_id].xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -430,9 +430,9 @@ void tud_task (void)
|
|||
case DCD_EVENT_SOF:
|
||||
for ( uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++ )
|
||||
{
|
||||
if ( usbd_class_drivers[i].sof )
|
||||
if ( _usbd_driver[i].sof )
|
||||
{
|
||||
usbd_class_drivers[i].sof(event.rhport);
|
||||
_usbd_driver[i].sof(event.rhport);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -452,6 +452,16 @@ void tud_task (void)
|
|||
// Control Request Parser & Handling
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
// Helper to invoke class driver control request handler
|
||||
static bool invoke_class_control(uint8_t rhport, uint8_t drvid, tusb_control_request_t const * request)
|
||||
{
|
||||
TU_ASSERT(_usbd_driver[drvid].control_request);
|
||||
|
||||
usbd_control_set_complete_callback(_usbd_driver[drvid].control_complete);
|
||||
TU_LOG2(" %s control request\r\n", _usbd_driver_str[drvid]);
|
||||
return _usbd_driver[drvid].control_request(rhport, request);
|
||||
}
|
||||
|
||||
// This handles the actual request and its response.
|
||||
// return false will cause its caller to stall control endpoint
|
||||
static bool process_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
|
||||
|
|
@ -586,21 +596,13 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
|
|||
default:
|
||||
// forward to class driver: "STD request to Interface"
|
||||
// GET HID REPORT DESCRIPTOR falls into this case
|
||||
// stall control endpoint if driver return false
|
||||
usbd_control_set_complete_callback(usbd_class_drivers[drvid].control_complete);
|
||||
TU_LOG2(" %s control request\r\n", _usbd_driver_str[drvid]);
|
||||
TU_VERIFY(usbd_class_drivers[drvid].control_request != NULL &&
|
||||
usbd_class_drivers[drvid].control_request(rhport, p_request));
|
||||
TU_VERIFY(invoke_class_control(rhport, drvid, p_request));
|
||||
break;
|
||||
}
|
||||
}else
|
||||
{
|
||||
// forward to class driver: "non-STD request to Interface"
|
||||
// stall control endpoint if driver return false
|
||||
usbd_control_set_complete_callback(usbd_class_drivers[drvid].control_complete);
|
||||
TU_LOG2(" %s control request\r\n", _usbd_driver_str[drvid]);
|
||||
TU_VERIFY(usbd_class_drivers[drvid].control_request != NULL &&
|
||||
usbd_class_drivers[drvid].control_request(rhport, p_request));
|
||||
TU_VERIFY(invoke_class_control(rhport, drvid, p_request));
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -614,18 +616,12 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
|
|||
|
||||
TU_ASSERT(ep_num < TU_ARRAY_SIZE(_usbd_dev.ep2drv) );
|
||||
|
||||
uint8_t const drv_id = _usbd_dev.ep2drv[ep_num][ep_dir];
|
||||
TU_ASSERT(drv_id < USBD_CLASS_DRIVER_COUNT);
|
||||
uint8_t const drvid = _usbd_dev.ep2drv[ep_num][ep_dir];
|
||||
TU_ASSERT(drvid < USBD_CLASS_DRIVER_COUNT);
|
||||
|
||||
bool ret = false;
|
||||
|
||||
if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type )
|
||||
{
|
||||
// complete callback is also capable of stalling/acking the request
|
||||
usbd_control_set_complete_callback(usbd_class_drivers[drv_id].control_complete);
|
||||
}
|
||||
|
||||
// Then handle if it is standard request
|
||||
// Handle STD request to endpoint
|
||||
if ( TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type )
|
||||
{
|
||||
// force return true for standard request
|
||||
|
|
@ -660,18 +656,21 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
|
|||
default: TU_BREAKPOINT(); return false;
|
||||
}
|
||||
}
|
||||
// Some classes such as TMC needs to clear/re-init its buffer when receiving CLEAR_FEATURE request
|
||||
// We will forward all request targeted endpoint to its class driver
|
||||
// For class-type requests: must (call tud_control_status(); return true) or (return false)
|
||||
// For std-type requests: non-std request codes are already discarded.
|
||||
// must not call tud_control_status(), and return value will have no effect
|
||||
// class driver is invoked last, so that EP already has EP stall cleared (in event of clear feature EP halt)
|
||||
TU_LOG2(" %s control request\r\n", _usbd_driver_str[drv_id]);
|
||||
if ( usbd_class_drivers[drv_id].control_request &&
|
||||
usbd_class_drivers[drv_id].control_request(rhport, p_request))
|
||||
|
||||
// Some classes such as USBTMC needs to clear/re-init its buffer when receiving CLEAR_FEATURE request
|
||||
// We will forward all request targeted endpoint to class drivers after
|
||||
// - For class-type requests: driver is fully responsible to reply to host
|
||||
// - For std-type requests : driver init/re-init internal variable/buffer only, and
|
||||
// must not call tud_control_status(), driver's return value will have no effect.
|
||||
// EP state has already affected (stalled/cleared)
|
||||
if ( invoke_class_control(rhport, drvid, p_request) ) ret = true;
|
||||
|
||||
if ( TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type )
|
||||
{
|
||||
ret = true;
|
||||
// Set complete callback = NULL since it can also stall the request.
|
||||
usbd_control_set_complete_callback(NULL);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
break;
|
||||
|
|
@ -714,7 +713,7 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num)
|
|||
uint8_t drv_id;
|
||||
for (drv_id = 0; drv_id < USBD_CLASS_DRIVER_COUNT; drv_id++)
|
||||
{
|
||||
if ( usbd_class_drivers[drv_id].class_code == desc_itf->bInterfaceClass ) break;
|
||||
if ( _usbd_driver[drv_id].class_code == desc_itf->bInterfaceClass ) break;
|
||||
}
|
||||
TU_ASSERT( drv_id < USBD_CLASS_DRIVER_COUNT );
|
||||
|
||||
|
|
@ -724,7 +723,7 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num)
|
|||
|
||||
uint16_t itf_len=0;
|
||||
TU_LOG2(" %s open\r\n", _usbd_driver_str[drv_id]);
|
||||
TU_ASSERT( usbd_class_drivers[drv_id].open(rhport, desc_itf, &itf_len) );
|
||||
TU_ASSERT( _usbd_driver[drv_id].open(rhport, desc_itf, &itf_len) );
|
||||
TU_ASSERT( itf_len >= sizeof(tusb_desc_interface_t) );
|
||||
|
||||
mark_interface_endpoint(_usbd_dev.ep2drv, p_desc, itf_len, drv_id);
|
||||
|
|
|
|||
|
|
@ -130,7 +130,9 @@ void usbd_control_set_complete_callback( bool (*fp) (uint8_t, tusb_control_reque
|
|||
_ctrl_xfer.complete_cb = fp;
|
||||
}
|
||||
|
||||
// callback when a transaction complete on DATA stage of control endpoint
|
||||
// callback when a transaction complete on
|
||||
// - DATA stage of control endpoint or
|
||||
// - Status stage
|
||||
bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
|
||||
{
|
||||
(void) result;
|
||||
|
|
|
|||
Loading…
Reference in New Issue