Squashed 'third_party/pico-sdk/lib/tinyusb/' content from commit 868948f67c
Change-Id: I5d33c2566dd597be9d4b1c30d4b3723c5ef4a265
git-subtree-dir: third_party/pico-sdk/lib/tinyusb
git-subtree-split: 868948f67c90fa7c2553cdcd604b52862cf55720
Signed-off-by: Austin Schuh <austin.linux@gmail.com>
diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
new file mode 100644
index 0000000..588b612
--- /dev/null
+++ b/src/class/hid/hid_device.c
@@ -0,0 +1,417 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#include "tusb_option.h"
+
+#if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_HID)
+
+//--------------------------------------------------------------------+
+// INCLUDE
+//--------------------------------------------------------------------+
+#include "device/usbd.h"
+#include "device/usbd_pvt.h"
+
+#include "hid_device.h"
+
+//--------------------------------------------------------------------+
+// MACRO CONSTANT TYPEDEF
+//--------------------------------------------------------------------+
+typedef struct
+{
+ uint8_t itf_num;
+ uint8_t ep_in;
+ uint8_t ep_out; // optional Out endpoint
+ uint8_t itf_protocol; // Boot mouse or keyboard
+
+ uint8_t protocol_mode; // Boot (0) or Report protocol (1)
+ uint8_t idle_rate; // up to application to handle idle rate
+ uint16_t report_desc_len;
+
+ CFG_TUSB_MEM_ALIGN uint8_t epin_buf[CFG_TUD_HID_EP_BUFSIZE];
+ CFG_TUSB_MEM_ALIGN uint8_t epout_buf[CFG_TUD_HID_EP_BUFSIZE];
+
+ // TODO save hid descriptor since host can specifically request this after enumeration
+ // Note: HID descriptor may be not available from application after enumeration
+ tusb_hid_descriptor_hid_t const * hid_descriptor;
+} hidd_interface_t;
+
+CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[CFG_TUD_HID];
+
+/*------------- Helpers -------------*/
+static inline uint8_t get_index_by_itfnum(uint8_t itf_num)
+{
+ for (uint8_t i=0; i < CFG_TUD_HID; i++ )
+ {
+ if ( itf_num == _hidd_itf[i].itf_num ) return i;
+ }
+
+ return 0xFF;
+}
+
+//--------------------------------------------------------------------+
+// APPLICATION API
+//--------------------------------------------------------------------+
+bool tud_hid_n_ready(uint8_t instance)
+{
+ uint8_t const ep_in = _hidd_itf[instance].ep_in;
+ return tud_ready() && (ep_in != 0) && !usbd_edpt_busy(TUD_OPT_RHPORT, ep_in);
+}
+
+bool tud_hid_n_report(uint8_t instance, uint8_t report_id, void const* report, uint8_t len)
+{
+ uint8_t const rhport = 0;
+ hidd_interface_t * p_hid = &_hidd_itf[instance];
+
+ // claim endpoint
+ TU_VERIFY( usbd_edpt_claim(rhport, p_hid->ep_in) );
+
+ // prepare data
+ if (report_id)
+ {
+ len = tu_min8(len, CFG_TUD_HID_EP_BUFSIZE-1);
+
+ p_hid->epin_buf[0] = report_id;
+ memcpy(p_hid->epin_buf+1, report, len);
+ len++;
+ }else
+ {
+ // If report id = 0, skip ID field
+ len = tu_min8(len, CFG_TUD_HID_EP_BUFSIZE);
+ memcpy(p_hid->epin_buf, report, len);
+ }
+
+ return usbd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->epin_buf, len);
+}
+
+uint8_t tud_hid_n_interface_protocol(uint8_t instance)
+{
+ return _hidd_itf[instance].itf_protocol;
+}
+
+uint8_t tud_hid_n_get_protocol(uint8_t instance)
+{
+ return _hidd_itf[instance].protocol_mode;
+}
+
+bool tud_hid_n_keyboard_report(uint8_t instance, uint8_t report_id, uint8_t modifier, uint8_t keycode[6])
+{
+ hid_keyboard_report_t report;
+
+ report.modifier = modifier;
+ report.reserved = 0;
+
+ if ( keycode )
+ {
+ memcpy(report.keycode, keycode, 6);
+ }else
+ {
+ tu_memclr(report.keycode, 6);
+ }
+
+ return tud_hid_n_report(instance, report_id, &report, sizeof(report));
+}
+
+bool tud_hid_n_mouse_report(uint8_t instance, uint8_t report_id,
+ uint8_t buttons, int8_t x, int8_t y, int8_t vertical, int8_t horizontal)
+{
+ hid_mouse_report_t report =
+ {
+ .buttons = buttons,
+ .x = x,
+ .y = y,
+ .wheel = vertical,
+ .pan = horizontal
+ };
+
+ return tud_hid_n_report(instance, report_id, &report, sizeof(report));
+}
+
+bool tud_hid_n_gamepad_report(uint8_t instance, uint8_t report_id,
+ int8_t x, int8_t y, int8_t z, int8_t rz, int8_t rx, int8_t ry, uint8_t hat, uint32_t buttons)
+{
+ hid_gamepad_report_t report =
+ {
+ .x = x,
+ .y = y,
+ .z = z,
+ .rz = rz,
+ .rx = rx,
+ .ry = ry,
+ .hat = hat,
+ .buttons = buttons,
+ };
+
+ return tud_hid_n_report(instance, report_id, &report, sizeof(report));
+}
+
+//--------------------------------------------------------------------+
+// USBD-CLASS API
+//--------------------------------------------------------------------+
+void hidd_init(void)
+{
+ hidd_reset(TUD_OPT_RHPORT);
+}
+
+void hidd_reset(uint8_t rhport)
+{
+ (void) rhport;
+ tu_memclr(_hidd_itf, sizeof(_hidd_itf));
+}
+
+uint16_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t max_len)
+{
+ TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass, 0);
+
+ // len = interface + hid + n*endpoints
+ uint16_t const drv_len = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t);
+ TU_ASSERT(max_len >= drv_len, 0);
+
+ // Find available interface
+ hidd_interface_t * p_hid = NULL;
+ uint8_t hid_id;
+ for(hid_id=0; hid_id<CFG_TUD_HID; hid_id++)
+ {
+ if ( _hidd_itf[hid_id].ep_in == 0 )
+ {
+ p_hid = &_hidd_itf[hid_id];
+ break;
+ }
+ }
+ TU_ASSERT(p_hid, 0);
+
+ uint8_t const *p_desc = (uint8_t const *) desc_itf;
+
+ //------------- HID descriptor -------------//
+ p_desc = tu_desc_next(p_desc);
+ TU_ASSERT(HID_DESC_TYPE_HID == tu_desc_type(p_desc), 0);
+ p_hid->hid_descriptor = (tusb_hid_descriptor_hid_t const *) p_desc;
+
+ //------------- Endpoint Descriptor -------------//
+ p_desc = tu_desc_next(p_desc);
+ TU_ASSERT(usbd_open_edpt_pair(rhport, p_desc, desc_itf->bNumEndpoints, TUSB_XFER_INTERRUPT, &p_hid->ep_out, &p_hid->ep_in), 0);
+
+ if ( desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT ) p_hid->itf_protocol = desc_itf->bInterfaceProtocol;
+
+ p_hid->protocol_mode = HID_PROTOCOL_REPORT; // Per Specs: default is report mode
+ p_hid->itf_num = desc_itf->bInterfaceNumber;
+
+ // Use offsetof to avoid pointer to the odd/misaligned address
+ p_hid->report_desc_len = tu_unaligned_read16((uint8_t const*) p_hid->hid_descriptor + offsetof(tusb_hid_descriptor_hid_t, wReportLength));
+
+ // Prepare for output endpoint
+ if (p_hid->ep_out)
+ {
+ if ( !usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf)) )
+ {
+ TU_LOG_FAILED();
+ TU_BREAKPOINT();
+ }
+ }
+
+ return drv_len;
+}
+
+// Invoked when a control transfer occurred on an interface of this class
+// Driver response accordingly to the request and the transfer stage (setup/data/ack)
+// return false to stall control endpoint (e.g unsupported request)
+bool hidd_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
+{
+ TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);
+
+ uint8_t const hid_itf = get_index_by_itfnum((uint8_t) request->wIndex);
+ TU_VERIFY(hid_itf < CFG_TUD_HID);
+
+ hidd_interface_t* p_hid = &_hidd_itf[hid_itf];
+
+ if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD)
+ {
+ //------------- STD Request -------------//
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ uint8_t const desc_type = tu_u16_high(request->wValue);
+ //uint8_t const desc_index = tu_u16_low (request->wValue);
+
+ if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID)
+ {
+ TU_VERIFY(p_hid->hid_descriptor);
+ TU_VERIFY(tud_control_xfer(rhport, request, (void*)(uintptr_t) p_hid->hid_descriptor, p_hid->hid_descriptor->bLength));
+ }
+ else if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)
+ {
+ uint8_t const * desc_report = tud_hid_descriptor_report_cb(hid_itf);
+ tud_control_xfer(rhport, request, (void*)(uintptr_t) desc_report, p_hid->report_desc_len);
+ }
+ else
+ {
+ return false; // stall unsupported request
+ }
+ }
+ }
+ else if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)
+ {
+ //------------- Class Specific Request -------------//
+ switch( request->bRequest )
+ {
+ case HID_REQ_CONTROL_GET_REPORT:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ uint8_t const report_type = tu_u16_high(request->wValue);
+ uint8_t const report_id = tu_u16_low(request->wValue);
+
+ uint8_t* report_buf = p_hid->epin_buf;
+ uint16_t req_len = tu_min16(request->wLength, CFG_TUD_HID_EP_BUFSIZE);
+
+ uint16_t xferlen = 0;
+
+ // If host request a specific Report ID, add ID to as 1 byte of response
+ if ( (report_id != HID_REPORT_TYPE_INVALID) && (req_len > 1) )
+ {
+ *report_buf++ = report_id;
+ req_len--;
+
+ xferlen++;
+ }
+
+ xferlen += tud_hid_get_report_cb(hid_itf, report_id, (hid_report_type_t) report_type, report_buf, req_len);
+ TU_ASSERT( xferlen > 0 );
+
+ tud_control_xfer(rhport, request, p_hid->epin_buf, xferlen);
+ }
+ break;
+
+ case HID_REQ_CONTROL_SET_REPORT:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ TU_VERIFY(request->wLength <= sizeof(p_hid->epout_buf));
+ tud_control_xfer(rhport, request, p_hid->epout_buf, request->wLength);
+ }
+ else if ( stage == CONTROL_STAGE_ACK )
+ {
+ uint8_t const report_type = tu_u16_high(request->wValue);
+ uint8_t const report_id = tu_u16_low(request->wValue);
+
+ uint8_t const* report_buf = p_hid->epout_buf;
+ uint16_t report_len = tu_min16(request->wLength, CFG_TUD_HID_EP_BUFSIZE);
+
+ // If host request a specific Report ID, extract report ID in buffer before invoking callback
+ if ( (report_id != HID_REPORT_TYPE_INVALID) && (report_len > 1) && (report_id == report_buf[0]) )
+ {
+ report_buf++;
+ report_len--;
+ }
+
+ tud_hid_set_report_cb(hid_itf, report_id, (hid_report_type_t) report_type, report_buf, report_len);
+ }
+ break;
+
+ case HID_REQ_CONTROL_SET_IDLE:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ p_hid->idle_rate = tu_u16_high(request->wValue);
+ if ( tud_hid_set_idle_cb )
+ {
+ // stall request if callback return false
+ TU_VERIFY( tud_hid_set_idle_cb( hid_itf, p_hid->idle_rate) );
+ }
+
+ tud_control_status(rhport, request);
+ }
+ break;
+
+ case HID_REQ_CONTROL_GET_IDLE:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ // TODO idle rate of report
+ tud_control_xfer(rhport, request, &p_hid->idle_rate, 1);
+ }
+ break;
+
+ case HID_REQ_CONTROL_GET_PROTOCOL:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ tud_control_xfer(rhport, request, &p_hid->protocol_mode, 1);
+ }
+ break;
+
+ case HID_REQ_CONTROL_SET_PROTOCOL:
+ if ( stage == CONTROL_STAGE_SETUP )
+ {
+ tud_control_status(rhport, request);
+ }
+ else if ( stage == CONTROL_STAGE_ACK )
+ {
+ p_hid->protocol_mode = (uint8_t) request->wValue;
+ if (tud_hid_set_protocol_cb)
+ {
+ tud_hid_set_protocol_cb(hid_itf, p_hid->protocol_mode);
+ }
+ }
+ break;
+
+ default: return false; // stall unsupported request
+ }
+ }else
+ {
+ return false; // stall unsupported request
+ }
+
+ return true;
+}
+
+bool hidd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
+{
+ (void) result;
+
+ uint8_t instance = 0;
+ hidd_interface_t * p_hid = _hidd_itf;
+
+ // Identify which interface to use
+ for (instance = 0; instance < CFG_TUD_HID; instance++)
+ {
+ p_hid = &_hidd_itf[instance];
+ if ( (ep_addr == p_hid->ep_out) || (ep_addr == p_hid->ep_in) ) break;
+ }
+ TU_ASSERT(instance < CFG_TUD_HID);
+
+ // Sent report successfully
+ if (ep_addr == p_hid->ep_in)
+ {
+ if (tud_hid_report_complete_cb)
+ {
+ tud_hid_report_complete_cb(instance, p_hid->epin_buf, (uint8_t) xferred_bytes);
+ }
+ }
+ // Received report
+ else if (ep_addr == p_hid->ep_out)
+ {
+ tud_hid_set_report_cb(instance, 0, HID_REPORT_TYPE_INVALID, p_hid->epout_buf, xferred_bytes);
+ TU_ASSERT(usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf)));
+ }
+
+ return true;
+}
+
+#endif