logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

usb_main.c (20352B)

    

  1. // Copyright 2023 Stefan Kerkmann
  2. // Copyright 2020-2021 Ryan (@fauxpark)
  3. // Copyright 2020 Nick Brassel (@tzarc)
  4. // Copyright 2020 a-chol
  5. // Copyright 2020 xyzz
  6. // Copyright 2020 Joel Challis (@zvecr)
  7. // Copyright 2020 George (@goshdarnharris)
  8. // Copyright 2018 James Laird-Wah
  9. // Copyright 2018 Drashna Jaelre (@drashna)
  10. // Copyright 2016 Fredizzimo
  11. // Copyright 2016 Giovanni Di Sirio
  12. // SPDX-License-Identifier: GPL-3.0-or-later OR Apache-2.0
  14. #include <ch.h>
  15. #include <hal.h>
  16. #include <string.h>
  18. #include "usb_main.h"
  19. #include "usb_report_handling.h"
  21. #include "host.h"
  22. #include "suspend.h"
  23. #include "timer.h"
  24. #ifdef SLEEP_LED_ENABLE
  25. #    include "sleep_led.h"
  26. #    include "led.h"
  27. #endif
  28. #include "wait.h"
  29. #include "usb_endpoints.h"
  30. #include "usb_device_state.h"
  31. #include "usb_descriptor.h"
  32. #include "usb_driver.h"
  33. #include "usb_types.h"
  35. #ifdef RAW_ENABLE
  36. #    include "raw_hid.h"
  37. #endif
  39. #ifdef NKRO_ENABLE
  40. #    include "keycode_config.h"
  42. extern keymap_config_t keymap_config;
  43. #endif
  45. /* ---------------------------------------------------------
  46.  *       Global interface variables and declarations
  47.  * ---------------------------------------------------------
  48.  */
  50. #ifndef usb_lld_connect_bus
  51. #    define usb_lld_connect_bus(usbp)
  52. #endif
  54. #ifndef usb_lld_disconnect_bus
  55. #    define usb_lld_disconnect_bus(usbp)
  56. #endif
  58. extern usb_endpoint_in_t  usb_endpoints_in[USB_ENDPOINT_IN_COUNT];
  59. extern usb_endpoint_out_t usb_endpoints_out[USB_ENDPOINT_OUT_COUNT];
  61. static bool __attribute__((__unused__)) send_report_buffered(usb_endpoint_in_lut_t endpoint, void *report, size_t size);
  62. static void __attribute__((__unused__)) flush_report_buffered(usb_endpoint_in_lut_t endpoint, bool padded);
  63. static bool __attribute__((__unused__)) receive_report(usb_endpoint_out_lut_t endpoint, void *report, size_t size);
  65. /* ---------------------------------------------------------
  66.  *            Descriptors and USB driver objects
  67.  * ---------------------------------------------------------
  68.  */
  70. /* USB Low Level driver specific endpoint fields */
  71. #if !defined(usb_lld_endpoint_fields)
  72. #    define usb_lld_endpoint_fields   \
  73.         2,        /* IN multiplier */ \
  74.             NULL, /* SETUP buffer (not a SETUP endpoint) */
  75. #endif
  77. /*
  78.  * Handles the GET_DESCRIPTOR callback
  79.  *
  80.  * Returns the proper descriptor
  81.  */
  82. static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype, uint8_t dindex, uint16_t wIndex) {
  83.     usb_control_request_t *setup = (usb_control_request_t *)usbp->setup;
  85.     static USBDescriptor descriptor;
  86.     descriptor.ud_string = NULL;
  87.     descriptor.ud_size   = get_usb_descriptor(setup->wValue.word, setup->wIndex, setup->wLength, (const void **const) & descriptor.ud_string);
  89.     if (descriptor.ud_string == NULL) {
  90.         return NULL;
  91.     }
  93.     return &descriptor;
  94. }
  96. /* ---------------------------------------------------------
  97.  *                  USB driver functions
  98.  * ---------------------------------------------------------
  99.  */
  101. #define USB_EVENT_QUEUE_SIZE 16
  102. usbevent_t event_queue[USB_EVENT_QUEUE_SIZE];
  103. uint8_t    event_queue_head;
  104. uint8_t    event_queue_tail;
  106. void usb_event_queue_init(void) {
  107.     // Initialise the event queue
  108.     memset(&event_queue, 0, sizeof(event_queue));
  109.     event_queue_head = 0;
  110.     event_queue_tail = 0;
  111. }
  113. static inline bool usb_event_queue_enqueue(usbevent_t event) {
  114.     uint8_t next = (event_queue_head + 1) % USB_EVENT_QUEUE_SIZE;
  115.     if (next == event_queue_tail) {
  116.         return false;
  117.     }
  118.     event_queue[event_queue_head] = event;
  119.     event_queue_head              = next;
  120.     return true;
  121. }
  123. static inline bool usb_event_queue_dequeue(usbevent_t *event) {
  124.     if (event_queue_head == event_queue_tail) {
  125.         return false;
  126.     }
  127.     *event           = event_queue[event_queue_tail];
  128.     event_queue_tail = (event_queue_tail + 1) % USB_EVENT_QUEUE_SIZE;
  129.     return true;
  130. }
  132. static inline void usb_event_suspend_handler(void) {
  133.     usb_device_state_set_suspend(USB_DRIVER.configuration != 0, USB_DRIVER.configuration);
  134. #ifdef SLEEP_LED_ENABLE
  135.     sleep_led_enable();
  136. #endif /* SLEEP_LED_ENABLE */
  137. }
  139. static inline void usb_event_wakeup_handler(void) {
  140.     suspend_wakeup_init();
  141.     usb_device_state_set_resume(USB_DRIVER.configuration != 0, USB_DRIVER.configuration);
  142. #ifdef SLEEP_LED_ENABLE
  143.     sleep_led_disable();
  144.     // NOTE: converters may not accept this
  145.     led_set(host_keyboard_leds());
  146. #endif /* SLEEP_LED_ENABLE */
  147. }
  149. bool last_suspend_state = false;
  151. void usb_event_queue_task(void) {
  152.     usbevent_t event;
  153.     while (usb_event_queue_dequeue(&event)) {
  154.         switch (event) {
  155.             case USB_EVENT_SUSPEND:
  156.                 last_suspend_state = true;
  157.                 usb_event_suspend_handler();
  158.                 break;
  159.             case USB_EVENT_WAKEUP:
  160.                 last_suspend_state = false;
  161.                 usb_event_wakeup_handler();
  162.                 break;
  163.             case USB_EVENT_CONFIGURED:
  164.                 usb_device_state_set_configuration(USB_DRIVER.configuration != 0, USB_DRIVER.configuration);
  165.                 break;
  166.             case USB_EVENT_UNCONFIGURED:
  167.                 usb_device_state_set_configuration(false, 0);
  168.                 break;
  169.             case USB_EVENT_RESET:
  170.                 usb_device_state_set_reset();
  171.                 usb_device_state_set_protocol(USB_PROTOCOL_REPORT);
  172.                 break;
  173.             default:
  174.                 // Nothing to do, we don't handle it.
  175.                 break;
  176.         }
  177.     }
  178. }
  180. /* Handles the USB driver global events. */
  181. static void usb_event_cb(USBDriver *usbp, usbevent_t event) {
  182.     switch (event) {
  183.         case USB_EVENT_ADDRESS:
  184.             return;
  186.         case USB_EVENT_CONFIGURED:
  187.             osalSysLockFromISR();
  188.             for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  189.                 usb_endpoint_in_configure_cb(&usb_endpoints_in[i]);
  190.             }
  191.             for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  192.                 usb_endpoint_out_configure_cb(&usb_endpoints_out[i]);
  193.             }
  194.             osalSysUnlockFromISR();
  195.             if (last_suspend_state) {
  196.                 usb_event_queue_enqueue(USB_EVENT_WAKEUP);
  197.             }
  198.             usb_event_queue_enqueue(USB_EVENT_CONFIGURED);
  199.             return;
  200.         case USB_EVENT_SUSPEND:
  201.             /* Falls into.*/
  202.         case USB_EVENT_UNCONFIGURED:
  203.             /* Falls into.*/
  204.         case USB_EVENT_RESET:
  205.             usb_event_queue_enqueue(event);
  206.             chSysLockFromISR();
  207.             for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  208.                 usb_endpoint_in_suspend_cb(&usb_endpoints_in[i]);
  209.             }
  210.             for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  211.                 usb_endpoint_out_suspend_cb(&usb_endpoints_out[i]);
  212.             }
  213.             chSysUnlockFromISR();
  214.             return;
  216.         case USB_EVENT_WAKEUP:
  217.             chSysLockFromISR();
  218.             for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  219.                 usb_endpoint_in_wakeup_cb(&usb_endpoints_in[i]);
  220.             }
  221.             for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  222.                 usb_endpoint_out_wakeup_cb(&usb_endpoints_out[i]);
  223.             }
  224.             chSysUnlockFromISR();
  225.             usb_event_queue_enqueue(USB_EVENT_WAKEUP);
  226.             return;
  228.         case USB_EVENT_STALLED:
  229.             return;
  230.     }
  231. }
  233. /*
  234.  * Appendix G: HID Request Support Requirements
  235.  *
  236.  * The following table enumerates the requests that need to be supported by various types of HID class devices.
  237.  * Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
  238.  * ------------------------------------------------------------------------------------------
  239.  * Boot Mouse      Required    Optional    Optional    Optional    Required    Required
  240.  * Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
  241.  * Boot Keyboard   Required    Optional    Required    Required    Required    Required
  242.  * Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
  243.  * Other Device    Required    Optional    Optional    Optional    Optional    Optional
  244.  */
  246. static uint8_t _Alignas(4) set_report_buf[2];
  248. static void set_led_transfer_cb(USBDriver *usbp) {
  249.     usb_control_request_t *setup = (usb_control_request_t *)usbp->setup;
  251.     if (setup->wLength == 2) {
  252.         uint8_t report_id = set_report_buf[0];
  253.         if ((report_id == REPORT_ID_KEYBOARD) || (report_id == REPORT_ID_NKRO)) {
  254.             usb_device_state_set_leds(set_report_buf[1]);
  255.         }
  256.     } else {
  257.         usb_device_state_set_leds(set_report_buf[0]);
  258.     }
  259. }
  261. static bool usb_requests_hook_cb(USBDriver *usbp) {
  262.     usb_control_request_t *setup = (usb_control_request_t *)usbp->setup;
  264.     /* Handle HID class specific requests */
  265.     if ((setup->bmRequestType & (USB_RTYPE_TYPE_MASK | USB_RTYPE_RECIPIENT_MASK)) == (USB_RTYPE_TYPE_CLASS | USB_RTYPE_RECIPIENT_INTERFACE)) {
  266.         switch (setup->bmRequestType & USB_RTYPE_DIR_MASK) {
  267.             case USB_RTYPE_DIR_DEV2HOST:
  268.                 switch (setup->bRequest) {
  269.                     case HID_REQ_GetReport:
  270.                         return usb_get_report_cb(usbp);
  271.                     case HID_REQ_GetProtocol:
  272.                         if (setup->wIndex == KEYBOARD_INTERFACE) {
  273.                             static uint8_t keyboard_protocol;
  274.                             keyboard_protocol = usb_device_state_get_protocol();
  275.                             usbSetupTransfer(usbp, &keyboard_protocol, sizeof(keyboard_protocol), NULL);
  276.                             return true;
  277.                         }
  278.                         break;
  280.                     case HID_REQ_GetIdle:
  281.                         return usb_get_idle_cb(usbp);
  282.                 }
  284.             case USB_RTYPE_DIR_HOST2DEV:
  285.                 switch (setup->bRequest) {
  286.                     case HID_REQ_SetReport:
  287.                         switch (setup->wIndex) {
  288.                             case KEYBOARD_INTERFACE:
  289. #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
  290.                             case SHARED_INTERFACE:
  291. #endif
  292.                                 usbSetupTransfer(usbp, set_report_buf, sizeof(set_report_buf), set_led_transfer_cb);
  293.                                 return true;
  294.                         }
  295.                         break;
  296.                     case HID_REQ_SetProtocol:
  297.                         if (setup->wIndex == KEYBOARD_INTERFACE) {
  298.                             usb_device_state_set_protocol(setup->wValue.lbyte);
  299.                         }
  300.                         usbSetupTransfer(usbp, NULL, 0, NULL);
  301.                         return true;
  302.                     case HID_REQ_SetIdle:
  303.                         usb_device_state_set_idle_rate(setup->wValue.hbyte);
  304.                         return usb_set_idle_cb(usbp);
  305.                 }
  306.                 break;
  307.         }
  308.     }
  310.     /* Handle the Get_Descriptor Request for HID class, which is not handled by
  311.      * the ChibiOS USB driver */
  312.     if (((setup->bmRequestType & (USB_RTYPE_DIR_MASK | USB_RTYPE_RECIPIENT_MASK)) == (USB_RTYPE_DIR_DEV2HOST | USB_RTYPE_RECIPIENT_INTERFACE)) && (setup->bRequest == USB_REQ_GET_DESCRIPTOR)) {
  313.         const USBDescriptor *descriptor = usbp->config->get_descriptor_cb(usbp, setup->wValue.lbyte, setup->wValue.hbyte, setup->wIndex);
  314.         if (descriptor == NULL) {
  315.             return false;
  316.         }
  317.         usbSetupTransfer(usbp, (uint8_t *)descriptor->ud_string, descriptor->ud_size, NULL);
  318.         return true;
  319.     }
  321.     for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  322.         if (usb_endpoints_in[i].usb_requests_cb != NULL) {
  323.             if (usb_endpoints_in[i].usb_requests_cb(usbp)) {
  324.                 return true;
  325.             }
  326.         }
  327.     }
  329.     return false;
  330. }
  332. static const USBConfig usbcfg = {
  333.     usb_event_cb,          /* USB events callback */
  334.     usb_get_descriptor_cb, /* Device GET_DESCRIPTOR request callback */
  335.     usb_requests_hook_cb,  /* Requests hook callback */
  336. };
  338. void init_usb_driver(USBDriver *usbp) {
  339.     for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  340.         usb_endpoint_in_init(&usb_endpoints_in[i]);
  341.         usb_endpoint_in_start(&usb_endpoints_in[i]);
  342.     }
  344.     for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  345.         usb_endpoint_out_init(&usb_endpoints_out[i]);
  346.         usb_endpoint_out_start(&usb_endpoints_out[i]);
  347.     }
  349.     /*
  350.      * Activates the USB driver and then the USB bus pull-up on D+.
  351.      * Note, a delay is inserted in order to not have to disconnect the cable
  352.      * after a reset.
  353.      */
  354.     usbDisconnectBus(usbp);
  355.     usbStop(usbp);
  356.     wait_ms(50);
  357.     usbStart(usbp, &usbcfg);
  358.     usbConnectBus(usbp);
  359. }
  361. __attribute__((weak)) void restart_usb_driver(USBDriver *usbp) {
  362.     usbDisconnectBus(usbp);
  363.     usbStop(usbp);
  365.     for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  366.         usb_endpoint_in_stop(&usb_endpoints_in[i]);
  367.     }
  369.     for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  370.         usb_endpoint_out_stop(&usb_endpoints_out[i]);
  371.     }
  373.     wait_ms(50);
  375.     for (int i = 0; i < USB_ENDPOINT_IN_COUNT; i++) {
  376.         usb_endpoint_in_init(&usb_endpoints_in[i]);
  377.         usb_endpoint_in_start(&usb_endpoints_in[i]);
  378.     }
  380.     for (int i = 0; i < USB_ENDPOINT_OUT_COUNT; i++) {
  381.         usb_endpoint_out_init(&usb_endpoints_out[i]);
  382.         usb_endpoint_out_start(&usb_endpoints_out[i]);
  383.     }
  385.     usbStart(usbp, &usbcfg);
  386.     usbConnectBus(usbp);
  387. }
  389. /* ---------------------------------------------------------
  390.  *                  Keyboard functions
  391.  * ---------------------------------------------------------
  392.  */
  394. /**
  395.  * @brief Send a report to the host, the report is enqueued into an output
  396.  * queue and send once the USB endpoint becomes empty.
  397.  *
  398.  * @param endpoint USB IN endpoint to send the report from
  399.  * @param report pointer to the report
  400.  * @param size size of the report
  401.  * @return true Success
  402.  * @return false Failure
  403.  */
  404. bool send_report(usb_endpoint_in_lut_t endpoint, void *report, size_t size) {
  405.     return usb_endpoint_in_send(&usb_endpoints_in[endpoint], (uint8_t *)report, size, TIME_MS2I(100), false);
  406. }
  408. /**
  409.  * @brief Send a report to the host, but delay the sending until the size of
  410.  * endpoint report is reached or the incompletely filled buffer is flushed with
  411.  * a call to `flush_report_buffered`. This is useful if the report is being
  412.  * updated frequently. The complete report is then enqueued into an output
  413.  * queue and send once the USB endpoint becomes empty.
  414.  *
  415.  * @param endpoint USB IN endpoint to send the report from
  416.  * @param report pointer to the report
  417.  * @param size size of the report
  418.  * @return true Success
  419.  * @return false Failure
  420.  */
  421. static bool send_report_buffered(usb_endpoint_in_lut_t endpoint, void *report, size_t size) {
  422.     return usb_endpoint_in_send(&usb_endpoints_in[endpoint], (uint8_t *)report, size, TIME_MS2I(100), true);
  423. }
  425. /** @brief Flush all buffered reports which were enqueued with a call to
  426.  * `send_report_buffered` that haven't been send. If necessary the buffered
  427.  * report can be padded with zeros up to the endpoints maximum size.
  428.  *
  429.  * @param endpoint USB IN endpoint to flush the reports from
  430.  * @param padded Pad the buffered report with zeros up to the endpoints maximum size
  431.  */
  432. static void flush_report_buffered(usb_endpoint_in_lut_t endpoint, bool padded) {
  433.     usb_endpoint_in_flush(&usb_endpoints_in[endpoint], padded);
  434. }
  436. /**
  437.  * @brief Receive a report from the host.
  438.  *
  439.  * @param endpoint USB OUT endpoint to receive the report from
  440.  * @param report pointer to the report
  441.  * @param size size of the report
  442.  * @return true Success
  443.  * @return false Failure
  444.  */
  445. static bool receive_report(usb_endpoint_out_lut_t endpoint, void *report, size_t size) {
  446.     return usb_endpoint_out_receive(&usb_endpoints_out[endpoint], (uint8_t *)report, size, TIME_IMMEDIATE);
  447. }
  449. void send_keyboard(report_keyboard_t *report) {
  450.     /* If we're in Boot Protocol, don't send any report ID or other funky fields */
  451.     if (usb_device_state_get_protocol() == USB_PROTOCOL_BOOT) {
  452.         send_report(USB_ENDPOINT_IN_KEYBOARD, &report->mods, 8);
  453.     } else {
  454.         send_report(USB_ENDPOINT_IN_KEYBOARD, report, KEYBOARD_REPORT_SIZE);
  455.     }
  456. }
  458. void send_nkro(report_nkro_t *report) {
  459. #ifdef NKRO_ENABLE
  460.     send_report(USB_ENDPOINT_IN_SHARED, report, sizeof(report_nkro_t));
  461. #endif
  462. }
  464. /* ---------------------------------------------------------
  465.  *                     Mouse functions
  466.  * ---------------------------------------------------------
  467.  */
  469. void send_mouse(report_mouse_t *report) {
  470. #ifdef MOUSE_ENABLE
  471.     send_report(USB_ENDPOINT_IN_MOUSE, report, sizeof(report_mouse_t));
  472. #endif
  473. }
  475. /* ---------------------------------------------------------
  476.  *                   Extrakey functions
  477.  * ---------------------------------------------------------
  478.  */
  480. void send_extra(report_extra_t *report) {
  481. #ifdef EXTRAKEY_ENABLE
  482.     send_report(USB_ENDPOINT_IN_SHARED, report, sizeof(report_extra_t));
  483. #endif
  484. }
  486. void send_programmable_button(report_programmable_button_t *report) {
  487. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  488.     send_report(USB_ENDPOINT_IN_SHARED, report, sizeof(report_programmable_button_t));
  489. #endif
  490. }
  492. void send_joystick(report_joystick_t *report) {
  493. #ifdef JOYSTICK_ENABLE
  494.     send_report(USB_ENDPOINT_IN_JOYSTICK, report, sizeof(report_joystick_t));
  495. #endif
  496. }
  498. void send_digitizer(report_digitizer_t *report) {
  499. #ifdef DIGITIZER_ENABLE
  500.     send_report(USB_ENDPOINT_IN_DIGITIZER, report, sizeof(report_digitizer_t));
  501. #endif
  502. }
  504. /* ---------------------------------------------------------
  505.  *                   Console functions
  506.  * ---------------------------------------------------------
  507.  */
  509. #ifdef CONSOLE_ENABLE
  511. int8_t sendchar(uint8_t c) {
  512.     return (int8_t)send_report_buffered(USB_ENDPOINT_IN_CONSOLE, &c, sizeof(uint8_t));
  513. }
  515. void console_task(void) {
  516.     flush_report_buffered(USB_ENDPOINT_IN_CONSOLE, true);
  517. }
  519. #endif /* CONSOLE_ENABLE */
  521. #ifdef RAW_ENABLE
  522. void send_raw_hid(uint8_t *data, uint8_t length) {
  523.     if (length != RAW_EPSIZE) {
  524.         return;
  525.     }
  526.     send_report(USB_ENDPOINT_IN_RAW, data, length);
  527. }
  529. void raw_hid_task(void) {
  530.     uint8_t buffer[RAW_EPSIZE];
  531.     while (receive_report(USB_ENDPOINT_OUT_RAW, buffer, sizeof(buffer))) {
  532.         raw_hid_receive(buffer, sizeof(buffer));
  533.     }
  534. }
  536. #endif
  538. #ifdef MIDI_ENABLE
  540. void send_midi_packet(MIDI_EventPacket_t *event) {
  541.     send_report(USB_ENDPOINT_IN_MIDI, (uint8_t *)event, sizeof(MIDI_EventPacket_t));
  542. }
  544. bool recv_midi_packet(MIDI_EventPacket_t *const event) {
  545.     return receive_report(USB_ENDPOINT_OUT_MIDI, (uint8_t *)event, sizeof(MIDI_EventPacket_t));
  546. }
  548. #endif
  550. #ifdef VIRTSER_ENABLE
  552. #    include "hal_usb_cdc.h"
  553. /**
  554.  * @brief CDC serial driver configuration structure. Set to 9600 baud, 1 stop bit, no parity, 8 data bits.
  555.  */
  556. static cdc_linecoding_t linecoding = {{0x00, 0x96, 0x00, 0x00}, LC_STOP_1, LC_PARITY_NONE, 8};
  558. bool virtser_usb_request_cb(USBDriver *usbp) {
  559.     if ((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) { /* bmRequestType */
  560.         if (usbp->setup[4] == CCI_INTERFACE) {                            /* wIndex (LSB) */
  561.             switch (usbp->setup[1]) {                                     /* bRequest */
  562.                 case CDC_GET_LINE_CODING:
  563.                     usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
  564.                     return true;
  565.                 case CDC_SET_LINE_CODING:
  566.                     usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding), NULL);
  567.                     return true;
  568.                 case CDC_SET_CONTROL_LINE_STATE:
  569.                     /* Nothing to do, there are no control lines.*/
  570.                     usbSetupTransfer(usbp, NULL, 0, NULL);
  571.                     return true;
  572.                 default:
  573.                     return false;
  574.             }
  575.         }
  576.     }
  578.     return false;
  579. }
  581. void virtser_init(void) {}
  583. void virtser_send(const uint8_t byte) {
  584.     send_report_buffered(USB_ENDPOINT_IN_CDC_DATA, (void *)&byte, sizeof(byte));
  585. }
  587. __attribute__((weak)) void virtser_recv(uint8_t c) {
  588.     // Ignore by default
  589. }
  591. void virtser_task(void) {
  592.     uint8_t buffer[CDC_EPSIZE];
  593.     while (receive_report(USB_ENDPOINT_OUT_CDC_DATA, buffer, sizeof(buffer))) {
  594.         for (int i = 0; i < sizeof(buffer); i++) {
  595.             virtser_recv(buffer[i]);
  596.         }
  597.     }
  599.     flush_report_buffered(USB_ENDPOINT_IN_CDC_DATA, false);
  600. }
  602. #endif