logo

qmk_firmware

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

lufa.c (25641B)

    

  1. /*
  2.  * Copyright 2012 Jun Wako <wakojun@gmail.com>
  3.  * This file is based on:
  4.  *     LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse
  5.  *     LUFA-120219/Demos/Device/Lowlevel/GenericHID
  6.  */
  8. /*
  9.              LUFA Library
  10.      Copyright (C) Dean Camera, 2012.
  12.   dean [at] fourwalledcubicle [dot] com
  13.            www.lufa-lib.org
  14. */
  16. /*
  17.   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  18.   Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
  20.   Permission to use, copy, modify, distribute, and sell this
  21.   software and its documentation for any purpose is hereby granted
  22.   without fee, provided that the above copyright notice appear in
  23.   all copies and that both that the copyright notice and this
  24.   permission notice and warranty disclaimer appear in supporting
  25.   documentation, and that the name of the author not be used in
  26.   advertising or publicity pertaining to distribution of the
  27.   software without specific, written prior permission.
  29.   The author disclaim all warranties with regard to this
  30.   software, including all implied warranties of merchantability
  31.   and fitness.  In no event shall the author be liable for any
  32.   special, indirect or consequential damages or any damages
  33.   whatsoever resulting from loss of use, data or profits, whether
  34.   in an action of contract, negligence or other tortious action,
  35.   arising out of or in connection with the use or performance of
  36.   this software.
  37. */
  39. #include "report.h"
  40. #include "host.h"
  41. #include "host_driver.h"
  42. #include "keyboard.h"
  43. #include "action.h"
  44. #include "led.h"
  45. #include "sendchar.h"
  46. #include "debug.h"
  47. #ifdef SLEEP_LED_ENABLE
  48. #    include "sleep_led.h"
  49. #endif
  50. #include "suspend.h"
  51. #include "wait.h"
  53. #include "usb_descriptor.h"
  54. #include "lufa.h"
  55. #include "usb_device_state.h"
  56. #include <util/atomic.h>
  58. #ifdef VIRTSER_ENABLE
  59. #    include "virtser.h"
  60. #endif
  62. #ifdef MIDI_ENABLE
  63. #    include "qmk_midi.h"
  64. #endif
  66. #ifdef RAW_ENABLE
  67. #    include "raw_hid.h"
  68. #endif
  70. #ifdef WAIT_FOR_USB
  71. // TODO: Remove backwards compatibility with old define
  72. #    define USB_WAIT_FOR_ENUMERATION
  73. #endif
  75. static report_keyboard_t keyboard_report_sent;
  77. /* Host driver */
  78. static void send_keyboard(report_keyboard_t *report);
  79. static void send_nkro(report_nkro_t *report);
  80. static void send_mouse(report_mouse_t *report);
  81. static void send_extra(report_extra_t *report);
  82. #ifdef RAW_ENABLE
  83. static void send_raw_hid(uint8_t *data, uint8_t length);
  84. #endif
  86. host_driver_t lufa_driver = {
  87.     .keyboard_leds = usb_device_state_get_leds,
  88.     .send_keyboard = send_keyboard,
  89.     .send_nkro     = send_nkro,
  90.     .send_mouse    = send_mouse,
  91.     .send_extra    = send_extra,
  92. #ifdef RAW_ENABLE
  93.     .send_raw_hid = send_raw_hid,
  94. #endif
  95. };
  97. void send_report(uint8_t endpoint, void *report, size_t size) {
  98.     uint8_t timeout = 255;
  100.     if (USB_DeviceState != DEVICE_STATE_Configured) return;
  102.     Endpoint_SelectEndpoint(endpoint);
  104.     /* Check if write ready for a polling interval around 10ms */
  105.     while (timeout-- && !Endpoint_IsReadWriteAllowed()) {
  106.         _delay_us(40);
  107.     }
  108.     if (!Endpoint_IsReadWriteAllowed()) return;
  110.     Endpoint_Write_Stream_LE(report, size, NULL);
  111.     Endpoint_ClearIN();
  112. }
  114. #ifdef VIRTSER_ENABLE
  115. // clang-format off
  117. USB_ClassInfo_CDC_Device_t cdc_device = {
  118.     .Config = {
  119.         .ControlInterfaceNumber = CCI_INTERFACE,
  120.         .DataINEndpoint = {
  121.             .Address            = (CDC_IN_EPNUM | ENDPOINT_DIR_IN),
  122.             .Size               = CDC_EPSIZE,
  123.             .Banks              = 1
  124.         },
  125.         .DataOUTEndpoint = {
  126.             .Address            = (CDC_OUT_EPNUM | ENDPOINT_DIR_OUT),
  127.             .Size               = CDC_EPSIZE,
  128.             .Banks              = 1
  129.         },
  130.         .NotificationEndpoint = {
  131.             .Address            = (CDC_NOTIFICATION_EPNUM | ENDPOINT_DIR_IN),
  132.             .Size               = CDC_NOTIFICATION_EPSIZE,
  133.             .Banks              = 1
  134.         }
  135.     }
  136. };
  138. // clang-format on
  139. #endif
  141. #ifdef RAW_ENABLE
  143. /** \brief Raw HID Send
  144.  *
  145.  * FIXME: Needs doc
  146.  */
  147. static void send_raw_hid(uint8_t *data, uint8_t length) {
  148.     if (length != RAW_EPSIZE) return;
  149.     send_report(RAW_IN_EPNUM, data, RAW_EPSIZE);
  150. }
  152. /** \brief Raw HID Task
  153.  *
  154.  * FIXME: Needs doc
  155.  */
  156. void raw_hid_task(void) {
  157.     // Create a temporary buffer to hold the read in data from the host
  158.     uint8_t data[RAW_EPSIZE];
  159.     bool    data_read = false;
  161.     // Device must be connected and configured for the task to run
  162.     if (USB_DeviceState != DEVICE_STATE_Configured) return;
  164.     Endpoint_SelectEndpoint(RAW_OUT_EPNUM);
  166.     // Check to see if a packet has been sent from the host
  167.     if (Endpoint_IsOUTReceived()) {
  168.         // Check to see if the packet contains data
  169.         if (Endpoint_IsReadWriteAllowed()) {
  170.             /* Read data */
  171.             Endpoint_Read_Stream_LE(data, sizeof(data), NULL);
  172.             data_read = true;
  173.         }
  175.         // Finalize the stream transfer to receive the last packet
  176.         Endpoint_ClearOUT();
  178.         if (data_read) {
  179.             raw_hid_receive(data, sizeof(data));
  180.         }
  181.     }
  182. }
  183. #endif
  185. /*******************************************************************************
  186.  * Console
  187.  ******************************************************************************/
  188. #ifdef CONSOLE_ENABLE
  189. /** \brief Console Tasks
  190.  *
  191.  * FIXME: Needs doc
  192.  */
  193. static void console_flush_task(void) {
  194.     /* Device must be connected and configured for the task to run */
  195.     if (USB_DeviceState != DEVICE_STATE_Configured) return;
  197.     uint8_t ep = Endpoint_GetCurrentEndpoint();
  199.     /* IN packet */
  200.     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
  201.     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
  202.         Endpoint_SelectEndpoint(ep);
  203.         return;
  204.     }
  206.     // fill empty bank
  207.     while (Endpoint_IsReadWriteAllowed())
  208.         Endpoint_Write_8(0);
  210.     // flush sendchar packet
  211.     if (Endpoint_IsINReady()) {
  212.         Endpoint_ClearIN();
  213.     }
  215.     Endpoint_SelectEndpoint(ep);
  216. }
  218. void console_task(void) {
  219.     // do nothing
  220. }
  221. #endif
  223. /*******************************************************************************
  224.  * USB Events
  225.  ******************************************************************************/
  226. /*
  227.  * Event Order of Plug in:
  228.  * 0) EVENT_USB_Device_Connect
  229.  * 1) EVENT_USB_Device_Suspend
  230.  * 2) EVENT_USB_Device_Reset
  231.  * 3) EVENT_USB_Device_Wake
  232.  */
  233. /** \brief Event USB Device Connect
  234.  *
  235.  * FIXME: Needs doc
  236.  */
  237. void EVENT_USB_Device_Connect(void) {
  238.     print("[C]");
  239.     /* For battery powered device */
  240.     if (!USB_IsInitialized) {
  241.         USB_Disable();
  242.         USB_Init();
  243.         USB_Device_EnableSOFEvents();
  244.     }
  245. }
  247. /** \brief Event USB Device Connect
  248.  *
  249.  * FIXME: Needs doc
  250.  */
  251. void EVENT_USB_Device_Disconnect(void) {
  252.     print("[D]");
  253.     /* For battery powered device */
  254.     USB_IsInitialized = false;
  255.     /* TODO: This doesn't work. After several plug in/outs can not be enumerated.
  256.         if (USB_IsInitialized) {
  257.             USB_Disable();  // Disable all interrupts
  258.         USB_Controller_Enable();
  259.             USB_INT_Enable(USB_INT_VBUSTI);
  260.         }
  261.     */
  262. }
  264. /** \brief Event USB Device Connect
  265.  *
  266.  * FIXME: Needs doc
  267.  */
  268. void EVENT_USB_Device_Reset(void) {
  269.     print("[R]");
  270.     usb_device_state_set_reset();
  271.     usb_device_state_set_protocol(USB_PROTOCOL_REPORT);
  272. }
  274. /** \brief Event USB Device Connect
  275.  *
  276.  * FIXME: Needs doc
  277.  */
  278. void EVENT_USB_Device_Suspend(void) {
  279.     print("[S]");
  280.     usb_device_state_set_suspend(USB_Device_ConfigurationNumber != 0, USB_Device_ConfigurationNumber);
  282. #ifdef SLEEP_LED_ENABLE
  283.     sleep_led_enable();
  284. #endif
  285. }
  287. /** \brief Event USB Device Connect
  288.  *
  289.  * FIXME: Needs doc
  290.  */
  291. void EVENT_USB_Device_WakeUp(void) {
  292.     print("[W]");
  293. #if defined(NO_USB_STARTUP_CHECK)
  294.     suspend_wakeup_init();
  295. #endif
  297.     usb_device_state_set_resume(USB_DeviceState == DEVICE_STATE_Configured, USB_Device_ConfigurationNumber);
  299. #ifdef SLEEP_LED_ENABLE
  300.     sleep_led_disable();
  301.     // NOTE: converters may not accept this
  302.     led_set(host_keyboard_leds());
  303. #endif
  304. }
  306. #ifdef CONSOLE_ENABLE
  307. static bool console_flush = false;
  308. #    define CONSOLE_FLUSH_SET(b)                \
  309.         do {                                    \
  310.             ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { \
  311.                 console_flush = b;              \
  312.             }                                   \
  313.         } while (0)
  315. /** \brief Event USB Device Start Of Frame
  316.  *
  317.  * FIXME: Needs doc
  318.  * called every 1ms
  319.  */
  320. void EVENT_USB_Device_StartOfFrame(void) {
  321.     static uint8_t count;
  322.     if (++count % 50) return;
  323.     count = 0;
  325.     if (!console_flush) return;
  326.     console_flush_task();
  327.     console_flush = false;
  328. }
  330. #endif
  332. /** \brief Event handler for the USB_ConfigurationChanged event.
  333.  *
  334.  * This is fired when the host sets the current configuration of the USB device after enumeration.
  335.  *
  336.  * ATMega32u2 supports dual bank(ping-pong mode) only on endpoint 3 and 4,
  337.  * it is safe to use single bank for all endpoints.
  338.  */
  339. void EVENT_USB_Device_ConfigurationChanged(void) {
  340.     bool ConfigSuccess = true;
  342. #ifndef KEYBOARD_SHARED_EP
  343.     /* Setup keyboard report endpoint */
  344.     ConfigSuccess &= Endpoint_ConfigureEndpoint((KEYBOARD_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
  345. #endif
  347. #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
  348.     /* Setup mouse report endpoint */
  349.     ConfigSuccess &= Endpoint_ConfigureEndpoint((MOUSE_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, MOUSE_EPSIZE, 1);
  350. #endif
  352. #ifdef SHARED_EP_ENABLE
  353.     /* Setup shared report endpoint */
  354.     ConfigSuccess &= Endpoint_ConfigureEndpoint((SHARED_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, SHARED_EPSIZE, 1);
  355. #endif
  357. #ifdef RAW_ENABLE
  358.     /* Setup raw HID endpoints */
  359.     ConfigSuccess &= Endpoint_ConfigureEndpoint((RAW_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, RAW_EPSIZE, 1);
  360.     ConfigSuccess &= Endpoint_ConfigureEndpoint((RAW_OUT_EPNUM | ENDPOINT_DIR_OUT), EP_TYPE_INTERRUPT, RAW_EPSIZE, 1);
  361. #endif
  363. #ifdef CONSOLE_ENABLE
  364.     /* Setup console endpoint */
  365.     ConfigSuccess &= Endpoint_ConfigureEndpoint((CONSOLE_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, CONSOLE_EPSIZE, 1);
  366. #endif
  368. #ifdef MIDI_ENABLE
  369.     /* Setup MIDI stream endpoints */
  370.     ConfigSuccess &= Endpoint_ConfigureEndpoint((MIDI_STREAM_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_BULK, MIDI_STREAM_EPSIZE, 1);
  371.     ConfigSuccess &= Endpoint_ConfigureEndpoint((MIDI_STREAM_OUT_EPNUM | ENDPOINT_DIR_OUT), EP_TYPE_BULK, MIDI_STREAM_EPSIZE, 1);
  372. #endif
  374. #ifdef VIRTSER_ENABLE
  375.     /* Setup virtual serial endpoints */
  376.     ConfigSuccess &= Endpoint_ConfigureEndpoint((CDC_NOTIFICATION_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, 1);
  377.     ConfigSuccess &= Endpoint_ConfigureEndpoint((CDC_OUT_EPNUM | ENDPOINT_DIR_OUT), EP_TYPE_BULK, CDC_EPSIZE, 1);
  378.     ConfigSuccess &= Endpoint_ConfigureEndpoint((CDC_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_BULK, CDC_EPSIZE, 1);
  379. #endif
  381. #if defined(JOYSTICK_ENABLE) && !defined(JOYSTICK_SHARED_EP)
  382.     /* Setup joystick endpoint */
  383.     ConfigSuccess &= Endpoint_ConfigureEndpoint((JOYSTICK_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, JOYSTICK_EPSIZE, 1);
  384. #endif
  386. #if defined(DIGITIZER_ENABLE) && !defined(DIGITIZER_SHARED_EP)
  387.     /* Setup digitizer endpoint */
  388.     ConfigSuccess &= Endpoint_ConfigureEndpoint((DIGITIZER_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, DIGITIZER_EPSIZE, 1);
  389. #endif
  391.     usb_device_state_set_configuration(USB_DeviceState == DEVICE_STATE_Configured, USB_Device_ConfigurationNumber);
  392. }
  394. /* FIXME: Expose this table in the docs somehow
  395. Appendix G: HID Request Support Requirements
  397. The following table enumerates the requests that need to be supported by various types of HID class devices.
  399. Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
  400. ------------------------------------------------------------------------------------------
  401. Boot Mouse      Required    Optional    Optional    Optional    Required    Required
  402. Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
  403. Boot Keyboard   Required    Optional    Required    Required    Required    Required
  404. Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
  405. Other Device    Required    Optional    Optional    Optional    Optional    Optional
  406. */
  407. /** \brief Event handler for the USB_ControlRequest event.
  408.  *
  409.  *  This is fired before passing along unhandled control requests to the library for processing internally.
  410.  */
  411. void EVENT_USB_Device_ControlRequest(void) {
  412.     uint8_t *ReportData = NULL;
  413.     uint8_t  ReportSize = 0;
  415.     /* Handle HID Class specific requests */
  416.     switch (USB_ControlRequest.bRequest) {
  417.         case HID_REQ_GetReport:
  418.             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
  419.                 Endpoint_ClearSETUP();
  421.                 // Interface
  422.                 switch (USB_ControlRequest.wIndex) {
  423.                     case KEYBOARD_INTERFACE:
  424.                         // TODO: test/check
  425.                         ReportData = (uint8_t *)&keyboard_report_sent;
  426.                         ReportSize = sizeof(keyboard_report_sent);
  427.                         break;
  428.                 }
  430.                 /* Write the report data to the control endpoint */
  431.                 Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
  432.                 Endpoint_ClearOUT();
  433.             }
  435.             break;
  436.         case HID_REQ_SetReport:
  437.             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
  438.                 // Interface
  439.                 switch (USB_ControlRequest.wIndex) {
  440.                     case KEYBOARD_INTERFACE:
  441. #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
  442.                     case SHARED_INTERFACE:
  443. #endif
  444.                         Endpoint_ClearSETUP();
  446.                         while (!(Endpoint_IsOUTReceived())) {
  447.                             if (USB_DeviceState == DEVICE_STATE_Unattached) return;
  448.                         }
  450.                         if (Endpoint_BytesInEndpoint() == 2) {
  451.                             uint8_t report_id = Endpoint_Read_8();
  453.                             if (report_id == REPORT_ID_KEYBOARD || report_id == REPORT_ID_NKRO) {
  454.                                 usb_device_state_set_leds(Endpoint_Read_8());
  455.                             }
  456.                         } else {
  457.                             usb_device_state_set_leds(Endpoint_Read_8());
  458.                         }
  460.                         Endpoint_ClearOUT();
  461.                         Endpoint_ClearStatusStage();
  462.                         break;
  463.                 }
  464.             }
  466.             break;
  468.         case HID_REQ_GetProtocol:
  469.             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
  470.                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
  471.                     Endpoint_ClearSETUP();
  472.                     while (!(Endpoint_IsINReady()))
  473.                         ;
  474.                     Endpoint_Write_8(usb_device_state_get_protocol());
  475.                     Endpoint_ClearIN();
  476.                     Endpoint_ClearStatusStage();
  477.                 }
  478.             }
  480.             break;
  481.         case HID_REQ_SetProtocol:
  482.             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
  483.                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
  484.                     Endpoint_ClearSETUP();
  485.                     Endpoint_ClearStatusStage();
  487.                     usb_device_state_set_protocol(USB_ControlRequest.wValue & 0xFF);
  488.                     clear_keyboard();
  489.                 }
  490.             }
  492.             break;
  493.         case HID_REQ_SetIdle:
  494.             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
  495.                 Endpoint_ClearSETUP();
  496.                 Endpoint_ClearStatusStage();
  498.                 usb_device_state_set_idle_rate(USB_ControlRequest.wValue >> 8);
  499.             }
  501.             break;
  502.         case HID_REQ_GetIdle:
  503.             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
  504.                 Endpoint_ClearSETUP();
  505.                 while (!(Endpoint_IsINReady()))
  506.                     ;
  507.                 Endpoint_Write_8(usb_device_state_get_idle_rate());
  508.                 Endpoint_ClearIN();
  509.                 Endpoint_ClearStatusStage();
  510.             }
  512.             break;
  513.     }
  515. #ifdef VIRTSER_ENABLE
  516.     CDC_Device_ProcessControlRequest(&cdc_device);
  517. #endif
  518. }
  520. /*******************************************************************************
  521.  * Host driver
  522.  ******************************************************************************/
  524. /** \brief Send Keyboard
  525.  *
  526.  * FIXME: Needs doc
  527.  */
  528. static void send_keyboard(report_keyboard_t *report) {
  529.     /* If we're in Boot Protocol, don't send any report ID or other funky fields */
  530.     if (usb_device_state_get_protocol() == USB_PROTOCOL_BOOT) {
  531.         send_report(KEYBOARD_IN_EPNUM, &report->mods, 8);
  532.     } else {
  533.         send_report(KEYBOARD_IN_EPNUM, report, KEYBOARD_REPORT_SIZE);
  534.     }
  536.     keyboard_report_sent = *report;
  537. }
  539. /** \brief Send NKRO
  540.  *
  541.  * FIXME: Needs doc
  542.  */
  543. static void send_nkro(report_nkro_t *report) {
  544. #ifdef NKRO_ENABLE
  545.     send_report(SHARED_IN_EPNUM, report, sizeof(report_nkro_t));
  546. #endif
  547. }
  549. /** \brief Send Mouse
  550.  *
  551.  * FIXME: Needs doc
  552.  */
  553. static void send_mouse(report_mouse_t *report) {
  554. #ifdef MOUSE_ENABLE
  555.     send_report(MOUSE_IN_EPNUM, report, sizeof(report_mouse_t));
  556. #endif
  557. }
  559. /** \brief Send Extra
  560.  *
  561.  * FIXME: Needs doc
  562.  */
  563. static void send_extra(report_extra_t *report) {
  564. #ifdef EXTRAKEY_ENABLE
  565.     send_report(SHARED_IN_EPNUM, report, sizeof(report_extra_t));
  566. #endif
  567. }
  569. void send_joystick(report_joystick_t *report) {
  570. #ifdef JOYSTICK_ENABLE
  571.     send_report(JOYSTICK_IN_EPNUM, report, sizeof(report_joystick_t));
  572. #endif
  573. }
  575. void send_programmable_button(report_programmable_button_t *report) {
  576. #ifdef PROGRAMMABLE_BUTTON_ENABLE
  577.     send_report(SHARED_IN_EPNUM, report, sizeof(report_programmable_button_t));
  578. #endif
  579. }
  581. void send_digitizer(report_digitizer_t *report) {
  582. #ifdef DIGITIZER_ENABLE
  583.     send_report(DIGITIZER_IN_EPNUM, report, sizeof(report_digitizer_t));
  584. #endif
  585. }
  587. /*******************************************************************************
  588.  * sendchar
  589.  ******************************************************************************/
  590. #ifdef CONSOLE_ENABLE
  591. #    define SEND_TIMEOUT 5
  592. /** \brief Send Char
  593.  *
  594.  * FIXME: Needs doc
  595.  */
  596. int8_t sendchar(uint8_t c) {
  597.     // Do not wait if the previous write has timed_out.
  598.     // Because sendchar() is called so many times, waiting each call causes big lag.
  599.     // The `timed_out` state is an approximation of the ideal `is_listener_disconnected?` state.
  600.     static bool timed_out = false;
  602.     // prevents console_flush_task() from running during sendchar() runs.
  603.     // or char will be lost. These two function is mutually exclusive.
  604.     CONSOLE_FLUSH_SET(false);
  606.     if (USB_DeviceState != DEVICE_STATE_Configured) return -1;
  608.     uint8_t ep = Endpoint_GetCurrentEndpoint();
  609.     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
  610.     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
  611.         goto ERROR_EXIT;
  612.     }
  614.     if (timed_out && !Endpoint_IsReadWriteAllowed()) {
  615.         goto ERROR_EXIT;
  616.     }
  618.     timed_out = false;
  620.     uint8_t timeout = SEND_TIMEOUT;
  621.     while (!Endpoint_IsReadWriteAllowed()) {
  622.         if (USB_DeviceState != DEVICE_STATE_Configured) {
  623.             goto ERROR_EXIT;
  624.         }
  625.         if (Endpoint_IsStalled()) {
  626.             goto ERROR_EXIT;
  627.         }
  628.         if (!(timeout--)) {
  629.             timed_out = true;
  630.             goto ERROR_EXIT;
  631.         }
  632.         _delay_ms(1);
  633.     }
  635.     Endpoint_Write_8(c);
  637.     // send when bank is full
  638.     if (!Endpoint_IsReadWriteAllowed()) {
  639.         while (!(Endpoint_IsINReady()))
  640.             ;
  641.         Endpoint_ClearIN();
  642.     } else {
  643.         CONSOLE_FLUSH_SET(true);
  644.     }
  646.     Endpoint_SelectEndpoint(ep);
  647.     return 0;
  648. ERROR_EXIT:
  649.     Endpoint_SelectEndpoint(ep);
  650.     return -1;
  651. }
  652. #endif
  654. /*******************************************************************************
  655.  * MIDI
  656.  ******************************************************************************/
  658. #ifdef MIDI_ENABLE
  659. // clang-format off
  661. USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface = {
  662.     .Config = {
  663.         .StreamingInterfaceNumber = AS_INTERFACE,
  664.         .DataINEndpoint = {
  665.             .Address              = (MIDI_STREAM_IN_EPNUM | ENDPOINT_DIR_IN),
  666.             .Size                 = MIDI_STREAM_EPSIZE,
  667.             .Banks                = 1
  668.         },
  669.         .DataOUTEndpoint = {
  670.             .Address              = (MIDI_STREAM_OUT_EPNUM | ENDPOINT_DIR_OUT),
  671.             .Size                 = MIDI_STREAM_EPSIZE,
  672.             .Banks                = 1
  673.         }
  674.     }
  675. };
  677. // clang-format on
  679. void send_midi_packet(MIDI_EventPacket_t *event) {
  680.     MIDI_Device_SendEventPacket(&USB_MIDI_Interface, event);
  681. }
  683. bool recv_midi_packet(MIDI_EventPacket_t *const event) {
  684.     return MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, event);
  685. }
  687. #endif
  689. /*******************************************************************************
  690.  * VIRTUAL SERIAL
  691.  ******************************************************************************/
  693. #ifdef VIRTSER_ENABLE
  694. /** \brief Virtual Serial Init
  695.  *
  696.  * FIXME: Needs doc
  697.  */
  698. void virtser_init(void) {
  699.     cdc_device.State.ControlLineStates.DeviceToHost = CDC_CONTROL_LINE_IN_DSR;
  700.     CDC_Device_SendControlLineStateChange(&cdc_device);
  701. }
  703. /** \brief Virtual Serial Receive
  704.  *
  705.  * FIXME: Needs doc
  706.  */
  707. void virtser_recv(uint8_t c) __attribute__((weak));
  708. void virtser_recv(uint8_t c) {
  709.     // Ignore by default
  710. }
  712. /** \brief Virtual Serial Task
  713.  *
  714.  * FIXME: Needs doc
  715.  */
  716. void virtser_task(void) {
  717.     uint16_t count = CDC_Device_BytesReceived(&cdc_device);
  718.     uint8_t  ch;
  719.     for (; count; --count) {
  720.         ch = CDC_Device_ReceiveByte(&cdc_device);
  721.         virtser_recv(ch);
  722.     }
  723. }
  724. /** \brief Virtual Serial Send
  725.  *
  726.  * FIXME: Needs doc
  727.  */
  728. void virtser_send(const uint8_t byte) {
  729.     uint8_t timeout = 255;
  730.     uint8_t ep      = Endpoint_GetCurrentEndpoint();
  732.     if (cdc_device.State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR) {
  733.         /* IN packet */
  734.         Endpoint_SelectEndpoint(cdc_device.Config.DataINEndpoint.Address);
  736.         if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
  737.             Endpoint_SelectEndpoint(ep);
  738.             return;
  739.         }
  741.         while (timeout-- && !Endpoint_IsReadWriteAllowed())
  742.             _delay_us(40);
  744.         Endpoint_Write_8(byte);
  745.         CDC_Device_Flush(&cdc_device);
  747.         if (Endpoint_IsINReady()) {
  748.             Endpoint_ClearIN();
  749.         }
  751.         Endpoint_SelectEndpoint(ep);
  752.     }
  753. }
  754. #endif
  756. /*******************************************************************************
  757.  * main
  758.  ******************************************************************************/
  759. /** \brief Setup MCU
  760.  *
  761.  * FIXME: Needs doc
  762.  */
  763. static void setup_mcu(void) {
  764.     /* Disable watchdog if enabled by bootloader/fuses */
  765.     MCUSR &= ~_BV(WDRF);
  766.     wdt_disable();
  768. // For boards running at 3.3V and crystal at 16 MHz
  769. #if (F_CPU == 8000000 && F_USB == 16000000)
  770.     /* Divide clock by 2 */
  771.     clock_prescale_set(clock_div_2);
  772. #else /* Disable clock division */
  773.     clock_prescale_set(clock_div_1);
  774. #endif
  775. }
  777. /** \brief Setup USB
  778.  *
  779.  * FIXME: Needs doc
  780.  */
  781. static void setup_usb(void) {
  782.     // Leonardo needs. Without this USB device is not recognized.
  783.     USB_Disable();
  785.     USB_Init();
  787.     // for console_flush_task
  788.     USB_Device_EnableSOFEvents();
  789. }
  791. void protocol_setup(void) {
  792. #ifdef MIDI_ENABLE
  793.     setup_midi();
  794. #endif
  796.     setup_mcu();
  797.     usb_device_state_init();
  798. }
  800. void protocol_pre_init(void) {
  801.     setup_usb();
  802.     sei();
  804.     /* wait for USB startup & debug output */
  806. #ifdef USB_WAIT_FOR_ENUMERATION
  807.     while (USB_DeviceState != DEVICE_STATE_Configured) {
  808. #    if defined(INTERRUPT_CONTROL_ENDPOINT)
  809.         ;
  810. #    else
  811.         USB_USBTask();
  812. #    endif
  813.     }
  814.     print("USB configured.\n");
  815. #else
  816.     USB_USBTask();
  817. #endif
  818. }
  820. void protocol_post_init(void) {
  821.     host_set_driver(&lufa_driver);
  822. }
  824. void protocol_pre_task(void) {
  825. #if !defined(NO_USB_STARTUP_CHECK)
  826.     if (USB_DeviceState == DEVICE_STATE_Suspended) {
  827.         dprintln("suspending keyboard");
  828.         while (USB_DeviceState == DEVICE_STATE_Suspended) {
  829.             suspend_power_down();
  830.             if (suspend_wakeup_condition() && USB_Device_RemoteWakeupEnabled) {
  831.                 USB_Device_SendRemoteWakeup();
  832.                 clear_keyboard();
  834. #    if USB_SUSPEND_WAKEUP_DELAY > 0
  835.                 // Some hubs, kvm switches, and monitors do
  836.                 // weird things, with USB device state bouncing
  837.                 // around wildly on wakeup, yielding race
  838.                 // conditions that can corrupt the keyboard state.
  839.                 //
  840.                 // Pause for a while to let things settle...
  841.                 wait_ms(USB_SUSPEND_WAKEUP_DELAY);
  842. #    endif
  843.             }
  844.         }
  845.         suspend_wakeup_init();
  846.     }
  847. #endif
  848. }
  850. void protocol_post_task(void) {
  851. #ifdef CONSOLE_ENABLE
  852.     console_task();
  853. #endif
  855. #ifdef MIDI_ENABLE
  856.     MIDI_Device_USBTask(&USB_MIDI_Interface);
  857. #endif
  859. #ifdef VIRTSER_ENABLE
  860.     virtser_task();
  861.     CDC_Device_USBTask(&cdc_device);
  862. #endif
  864. #if !defined(INTERRUPT_CONTROL_ENDPOINT)
  865.     USB_USBTask();
  866. #endif
  867. }
  869. uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint16_t wIndex, const void **const DescriptorAddress) {
  870.     return get_usb_descriptor(wValue, wIndex, USB_ControlRequest.wLength, DescriptorAddress);
  871. }