tmk_core/protocol/lufa/lufa.c

   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  */
   7
   8 /*
   9              LUFA Library
  10      Copyright (C) Dean Camera, 2012.
  11
  12   dean [at] fourwalledcubicle [dot] com
  13            www.lufa-lib.org
  14 */
  15
  16 /*
  17   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  18   Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
  19
  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.
  28
  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 */
  38
  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
  52 #include "usb_descriptor.h"
  53 #include "lufa.h"
  54 #include "quantum.h"
  55 #include <util/atomic.h>
  56 #include "outputselect.h"
  57 #include "rgblight_reconfig.h"
  58
  59 #ifdef NKRO_ENABLE
  60   #include "keycode_config.h"
  61
  62   extern keymap_config_t keymap_config;
  63 #endif
  64
  65
  66 #ifdef AUDIO_ENABLE
  67     #include <audio.h>
  68 #endif
  69
  70 #ifdef BLUETOOTH_ENABLE
  71   #ifdef MODULE_ADAFRUIT_BLE
  72     #include "adafruit_ble.h"
  73   #else
  74     #include "bluetooth.h"
  75   #endif
  76 #endif
  77
  78 #ifdef VIRTSER_ENABLE
  79     #include "virtser.h"
  80 #endif
  81
  82 #if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE)
  83     #include "rgblight.h"
  84 #endif
  85
  86 #ifdef MIDI_ENABLE
  87   #include "qmk_midi.h"
  88 #endif
  89
  90 #ifdef RAW_ENABLE
  91         #include "raw_hid.h"
  92 #endif
  93
  94 uint8_t keyboard_idle = 0;
  95 /* 0: Boot Protocol, 1: Report Protocol(default) */
  96 uint8_t keyboard_protocol = 1;
  97 static uint8_t keyboard_led_stats = 0;
  98
  99 static report_keyboard_t keyboard_report_sent;
 100
 101 /* Host driver */
 102 static uint8_t keyboard_leds(void);
 103 static void send_keyboard(report_keyboard_t *report);
 104 static void send_mouse(report_mouse_t *report);
 105 static void send_system(uint16_t data);
 106 static void send_consumer(uint16_t data);
 107 host_driver_t lufa_driver = {
 108     keyboard_leds,
 109     send_keyboard,
 110     send_mouse,
 111     send_system,
 112     send_consumer,
 113 };
 114
 115 #ifdef VIRTSER_ENABLE
 116 USB_ClassInfo_CDC_Device_t cdc_device =
 117 {
 118   .Config =
 119   {
 120     .ControlInterfaceNumber = CCI_INTERFACE,
 121     .DataINEndpoint         =
 122     {
 123       .Address          = CDC_IN_EPADDR,
 124       .Size             = CDC_EPSIZE,
 125       .Banks            = 1,
 126     },
 127     .DataOUTEndpoint        =
 128     {
 129       .Address          = CDC_OUT_EPADDR,
 130       .Size             = CDC_EPSIZE,
 131       .Banks            = 1,
 132     },
 133     .NotificationEndpoint   =
 134     {
 135       .Address          = CDC_NOTIFICATION_EPADDR,
 136       .Size             = CDC_NOTIFICATION_EPSIZE,
 137       .Banks            = 1,
 138     },
 139   },
 140 };
 141 #endif
 142
 143 #ifdef RAW_ENABLE
 144
 145 /** \brief Raw HID Send
 146  *
 147  * FIXME: Needs doc
 148  */
 149 void raw_hid_send( uint8_t *data, uint8_t length )
 150 {
 151         // TODO: implement variable size packet
 152         if ( length != RAW_EPSIZE )
 153         {
 154                 return;
 155         }
 156
 157         if (USB_DeviceState != DEVICE_STATE_Configured)
 158         {
 159                 return;
 160         }
 161
 162         // TODO: decide if we allow calls to raw_hid_send() in the middle
 163         // of other endpoint usage.
 164         uint8_t ep = Endpoint_GetCurrentEndpoint();
 165
 166         Endpoint_SelectEndpoint(RAW_IN_EPNUM);
 167
 168         // Check to see if the host is ready to accept another packet
 169         if (Endpoint_IsINReady())
 170         {
 171                 // Write data
 172                 Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL);
 173                 // Finalize the stream transfer to send the last packet
 174                 Endpoint_ClearIN();
 175         }
 176
 177         Endpoint_SelectEndpoint(ep);
 178 }
 179
 180 /** \brief Raw HID Receive
 181  *
 182  * FIXME: Needs doc
 183  */
 184 __attribute__ ((weak))
 185 void raw_hid_receive( uint8_t *data, uint8_t length )
 186 {
 187         // Users should #include "raw_hid.h" in their own code
 188         // and implement this function there. Leave this as weak linkage
 189         // so users can opt to not handle data coming in.
 190 }
 191
 192 /** \brief Raw HID Task
 193  *
 194  * FIXME: Needs doc
 195  */
 196 static void raw_hid_task(void)
 197 {
 198         // Create a temporary buffer to hold the read in data from the host
 199         uint8_t data[RAW_EPSIZE];
 200         bool data_read = false;
 201
 202         // Device must be connected and configured for the task to run
 203         if (USB_DeviceState != DEVICE_STATE_Configured)
 204         return;
 205
 206         Endpoint_SelectEndpoint(RAW_OUT_EPNUM);
 207
 208         // Check to see if a packet has been sent from the host
 209         if (Endpoint_IsOUTReceived())
 210         {
 211                 // Check to see if the packet contains data
 212                 if (Endpoint_IsReadWriteAllowed())
 213                 {
 214                         /* Read data */
 215                         Endpoint_Read_Stream_LE(data, sizeof(data), NULL);
 216                         data_read = true;
 217                 }
 218
 219                 // Finalize the stream transfer to receive the last packet
 220                 Endpoint_ClearOUT();
 221
 222                 if ( data_read )
 223                 {
 224                         raw_hid_receive( data, sizeof(data) );
 225                 }
 226         }
 227 }
 228 #endif
 229
 230 /*******************************************************************************
 231  * Console
 232  ******************************************************************************/
 233 #ifdef CONSOLE_ENABLE
 234 /** \brief Console Task
 235  *
 236  * FIXME: Needs doc
 237  */
 238 static void Console_Task(void)
 239 {
 240     /* Device must be connected and configured for the task to run */
 241     if (USB_DeviceState != DEVICE_STATE_Configured)
 242         return;
 243
 244     uint8_t ep = Endpoint_GetCurrentEndpoint();
 245
 246 #if 0
 247     // TODO: impl receivechar()/recvchar()
 248     Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
 249
 250     /* Check to see if a packet has been sent from the host */
 251     if (Endpoint_IsOUTReceived())
 252     {
 253         /* Check to see if the packet contains data */
 254         if (Endpoint_IsReadWriteAllowed())
 255         {
 256             /* Create a temporary buffer to hold the read in report from the host */
 257             uint8_t ConsoleData[CONSOLE_EPSIZE];
 258
 259             /* Read Console Report Data */
 260             Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
 261
 262             /* Process Console Report Data */
 263             //ProcessConsoleHIDReport(ConsoleData);
 264         }
 265
 266         /* Finalize the stream transfer to send the last packet */
 267         Endpoint_ClearOUT();
 268     }
 269 #endif
 270
 271     /* IN packet */
 272     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 273     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 274         Endpoint_SelectEndpoint(ep);
 275         return;
 276     }
 277
 278     // fill empty bank
 279     while (Endpoint_IsReadWriteAllowed())
 280         Endpoint_Write_8(0);
 281
 282     // flash senchar packet
 283     if (Endpoint_IsINReady()) {
 284         Endpoint_ClearIN();
 285     }
 286
 287     Endpoint_SelectEndpoint(ep);
 288 }
 289 #endif
 290
 291
 292 /*******************************************************************************
 293  * USB Events
 294  ******************************************************************************/
 295 /*
 296  * Event Order of Plug in:
 297  * 0) EVENT_USB_Device_Connect
 298  * 1) EVENT_USB_Device_Suspend
 299  * 2) EVENT_USB_Device_Reset
 300  * 3) EVENT_USB_Device_Wake
 301 */
 302 /** \brief Event USB Device Connect
 303  *
 304  * FIXME: Needs doc
 305  */
 306 void EVENT_USB_Device_Connect(void)
 307 {
 308     print("[C]");
 309     /* For battery powered device */
 310     if (!USB_IsInitialized) {
 311         USB_Disable();
 312         USB_Init();
 313         USB_Device_EnableSOFEvents();
 314     }
 315 }
 316
 317 /** \brief Event USB Device Connect
 318  *
 319  * FIXME: Needs doc
 320  */
 321 void EVENT_USB_Device_Disconnect(void)
 322 {
 323     print("[D]");
 324     /* For battery powered device */
 325     USB_IsInitialized = false;
 326 /* TODO: This doesn't work. After several plug in/outs can not be enumerated.
 327     if (USB_IsInitialized) {
 328         USB_Disable();  // Disable all interrupts
 329         USB_Controller_Enable();
 330         USB_INT_Enable(USB_INT_VBUSTI);
 331     }
 332 */
 333 }
 334
 335 /** \brief Event USB Device Connect
 336  *
 337  * FIXME: Needs doc
 338  */
 339 void EVENT_USB_Device_Reset(void)
 340 {
 341     print("[R]");
 342 }
 343
 344 /** \brief Event USB Device Connect
 345  *
 346  * FIXME: Needs doc
 347  */
 348 void EVENT_USB_Device_Suspend()
 349 {
 350     print("[S]");
 351 #ifdef SLEEP_LED_ENABLE
 352     sleep_led_enable();
 353 #endif
 354 }
 355
 356 /** \brief Event USB Device Connect
 357  *
 358  * FIXME: Needs doc
 359  */
 360 void EVENT_USB_Device_WakeUp()
 361 {
 362     print("[W]");
 363     suspend_wakeup_init();
 364
 365 #ifdef SLEEP_LED_ENABLE
 366     sleep_led_disable();
 367     // NOTE: converters may not accept this
 368     led_set(host_keyboard_leds());
 369 #endif
 370 }
 371
 372
 373
 374 #ifdef CONSOLE_ENABLE
 375 static bool console_flush = false;
 376 #define CONSOLE_FLUSH_SET(b)   do { \
 377   ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {\
 378     console_flush = b; \
 379   } \
 380 } while (0)
 381
 382 /** \brief Event USB Device Start Of Frame
 383  *
 384  * FIXME: Needs doc
 385  * called every 1ms
 386  */
 387 void EVENT_USB_Device_StartOfFrame(void)
 388 {
 389     static uint8_t count;
 390     if (++count % 50) return;
 391     count = 0;
 392
 393     if (!console_flush) return;
 394     Console_Task();
 395     console_flush = false;
 396 }
 397
 398 #endif
 399
 400 /** \brief Event handler for the USB_ConfigurationChanged event.
 401  *
 402  * This is fired when the host sets the current configuration of the USB device after enumeration.
 403  *
 404  * ATMega32u2 supports dual bank(ping-pong mode) only on endpoint 3 and 4,
 405  * it is safe to use single bank for all endpoints.
 406  */
 407 void EVENT_USB_Device_ConfigurationChanged(void)
 408 {
 409     bool ConfigSuccess = true;
 410
 411     /* Setup Keyboard HID Report Endpoints */
 412 #ifndef KEYBOARD_SHARED_EP
 413     ConfigSuccess &= ENDPOINT_CONFIG(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 414                                      KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 415 #endif
 416
 417 #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
 418     /* Setup Mouse HID Report Endpoint */
 419     ConfigSuccess &= ENDPOINT_CONFIG(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 420                                      MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
 421 #endif
 422
 423 #ifdef SHARED_EP_ENABLE
 424     /* Setup Shared HID Report Endpoint */
 425     ConfigSuccess &= ENDPOINT_CONFIG(SHARED_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 426                                      SHARED_EPSIZE, ENDPOINT_BANK_SINGLE);
 427 #endif
 428
 429 #ifdef RAW_ENABLE
 430     /* Setup Raw HID Report Endpoints */
 431     ConfigSuccess &= ENDPOINT_CONFIG(RAW_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 432                                                                          RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
 433     ConfigSuccess &= ENDPOINT_CONFIG(RAW_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 434                                                                          RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
 435 #endif
 436
 437 #ifdef CONSOLE_ENABLE
 438     /* Setup Console HID Report Endpoints */
 439     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 440                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 441 #if 0
 442     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 443                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 444 #endif
 445 #endif
 446
 447 #ifdef MIDI_ENABLE
 448     ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
 449     ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
 450 #endif
 451
 452 #ifdef VIRTSER_ENABLE
 453     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
 454     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_OUT_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
 455     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_IN_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
 456 #endif
 457 }
 458
 459 /* FIXME: Expose this table in the docs somehow
 460 Appendix G: HID Request Support Requirements
 461
 462 The following table enumerates the requests that need to be supported by various types of HID class devices.
 463
 464 Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
 465 ------------------------------------------------------------------------------------------
 466 Boot Mouse      Required    Optional    Optional    Optional    Required    Required
 467 Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
 468 Boot Keyboard   Required    Optional    Required    Required    Required    Required
 469 Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
 470 Other Device    Required    Optional    Optional    Optional    Optional    Optional
 471 */
 472 /** \brief Event handler for the USB_ControlRequest event.
 473  *
 474  *  This is fired before passing along unhandled control requests to the library for processing internally.
 475  */
 476 void EVENT_USB_Device_ControlRequest(void)
 477 {
 478     uint8_t* ReportData = NULL;
 479     uint8_t  ReportSize = 0;
 480
 481     /* Handle HID Class specific requests */
 482     switch (USB_ControlRequest.bRequest)
 483     {
 484         case HID_REQ_GetReport:
 485             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 486             {
 487                 Endpoint_ClearSETUP();
 488
 489                 // Interface
 490                 switch (USB_ControlRequest.wIndex) {
 491                 case KEYBOARD_INTERFACE:
 492                     // TODO: test/check
 493                     ReportData = (uint8_t*)&keyboard_report_sent;
 494                     ReportSize = sizeof(keyboard_report_sent);
 495                     break;
 496                 }
 497
 498                 /* Write the report data to the control endpoint */
 499                 Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
 500                 Endpoint_ClearOUT();
 501             }
 502
 503             break;
 504         case HID_REQ_SetReport:
 505             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 506             {
 507
 508                 // Interface
 509                 switch (USB_ControlRequest.wIndex) {
 510                 case KEYBOARD_INTERFACE:
 511 #if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
 512                 case SHARED_INTERFACE:
 513 #endif
 514                     Endpoint_ClearSETUP();
 515
 516                     while (!(Endpoint_IsOUTReceived())) {
 517                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 518                           return;
 519                     }
 520
 521                     if (Endpoint_BytesInEndpoint() == 2) {
 522                       uint8_t report_id = REPORT_ID_KEYBOARD;
 523
 524                       if (keyboard_protocol) {
 525                         report_id = Endpoint_Read_8();
 526                       }
 527
 528                       if (report_id == REPORT_ID_KEYBOARD || report_id == REPORT_ID_NKRO) {
 529                         keyboard_led_stats = Endpoint_Read_8();
 530                       }
 531                     } else {
 532                       keyboard_led_stats = Endpoint_Read_8();
 533                     }
 534
 535                     Endpoint_ClearOUT();
 536                     Endpoint_ClearStatusStage();
 537                     break;
 538                 }
 539
 540             }
 541
 542             break;
 543
 544         case HID_REQ_GetProtocol:
 545             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 546             {
 547                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 548                     Endpoint_ClearSETUP();
 549                     while (!(Endpoint_IsINReady()));
 550                     Endpoint_Write_8(keyboard_protocol);
 551                     Endpoint_ClearIN();
 552                     Endpoint_ClearStatusStage();
 553                 }
 554             }
 555
 556             break;
 557         case HID_REQ_SetProtocol:
 558             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 559             {
 560                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 561                     Endpoint_ClearSETUP();
 562                     Endpoint_ClearStatusStage();
 563
 564                     keyboard_protocol = (USB_ControlRequest.wValue & 0xFF);
 565                     clear_keyboard();
 566                 }
 567             }
 568
 569             break;
 570         case HID_REQ_SetIdle:
 571             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 572             {
 573                 Endpoint_ClearSETUP();
 574                 Endpoint_ClearStatusStage();
 575
 576                 keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
 577             }
 578
 579             break;
 580         case HID_REQ_GetIdle:
 581             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 582             {
 583                 Endpoint_ClearSETUP();
 584                 while (!(Endpoint_IsINReady()));
 585                 Endpoint_Write_8(keyboard_idle);
 586                 Endpoint_ClearIN();
 587                 Endpoint_ClearStatusStage();
 588             }
 589
 590             break;
 591     }
 592
 593 #ifdef VIRTSER_ENABLE
 594     CDC_Device_ProcessControlRequest(&cdc_device);
 595 #endif
 596 }
 597
 598 /*******************************************************************************
 599  * Host driver
 600  ******************************************************************************/
 601 /** \brief Keyboard LEDs
 602  *
 603  * FIXME: Needs doc
 604  */
 605 static uint8_t keyboard_leds(void)
 606 {
 607     return keyboard_led_stats;
 608 }
 609
 610 /** \brief Send Keyboard
 611  *
 612  * FIXME: Needs doc
 613  */
 614 static void send_keyboard(report_keyboard_t *report)
 615 {
 616     uint8_t timeout = 255;
 617     uint8_t where = where_to_send();
 618
 619 #ifdef BLUETOOTH_ENABLE
 620   if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 621     #ifdef MODULE_ADAFRUIT_BLE
 622       adafruit_ble_send_keys(report->mods, report->keys, sizeof(report->keys));
 623     #elif MODULE_RN42
 624       bluefruit_serial_send(0xFD);
 625       bluefruit_serial_send(0x09);
 626       bluefruit_serial_send(0x01);
 627       bluefruit_serial_send(report->mods);
 628       bluefruit_serial_send(report->reserved);
 629       for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
 630         bluefruit_serial_send(report->keys[i]);
 631       }
 632     #else
 633       bluefruit_serial_send(0xFD);
 634       bluefruit_serial_send(report->mods);
 635       bluefruit_serial_send(report->reserved);
 636       for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
 637         bluefruit_serial_send(report->keys[i]);
 638       }
 639     #endif
 640   }
 641 #endif
 642
 643     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 644       return;
 645     }
 646
 647     /* Select the Keyboard Report Endpoint */
 648     uint8_t ep = KEYBOARD_IN_EPNUM;
 649     uint8_t size = KEYBOARD_REPORT_SIZE;
 650 #ifdef NKRO_ENABLE
 651     if (keyboard_protocol && keymap_config.nkro) {
 652         ep = SHARED_IN_EPNUM;
 653         size = sizeof(struct nkro_report);
 654     }
 655 #endif
 656     Endpoint_SelectEndpoint(ep);
 657     /* Check if write ready for a polling interval around 10ms */
 658     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 659     if (!Endpoint_IsReadWriteAllowed()) return;
 660
 661     /* If we're in Boot Protocol, don't send any report ID or other funky fields */
 662     if (!keyboard_protocol) {
 663         Endpoint_Write_Stream_LE(&report->mods, 8, NULL);
 664     } else {
 665         Endpoint_Write_Stream_LE(report, size, NULL);
 666     }
 667
 668     /* Finalize the stream transfer to send the last packet */
 669     Endpoint_ClearIN();
 670
 671     keyboard_report_sent = *report;
 672 }
 673
 674 /** \brief Send Mouse
 675  *
 676  * FIXME: Needs doc
 677  */
 678 static void send_mouse(report_mouse_t *report)
 679 {
 680 #ifdef MOUSE_ENABLE
 681     uint8_t timeout = 255;
 682     uint8_t where = where_to_send();
 683
 684 #ifdef BLUETOOTH_ENABLE
 685   if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 686     #ifdef MODULE_ADAFRUIT_BLE
 687       // FIXME: mouse buttons
 688       adafruit_ble_send_mouse_move(report->x, report->y, report->v, report->h, report->buttons);
 689     #else
 690       bluefruit_serial_send(0xFD);
 691       bluefruit_serial_send(0x00);
 692       bluefruit_serial_send(0x03);
 693       bluefruit_serial_send(report->buttons);
 694       bluefruit_serial_send(report->x);
 695       bluefruit_serial_send(report->y);
 696       bluefruit_serial_send(report->v); // should try sending the wheel v here
 697       bluefruit_serial_send(report->h); // should try sending the wheel h here
 698       bluefruit_serial_send(0x00);
 699     #endif
 700   }
 701 #endif
 702
 703     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 704       return;
 705     }
 706
 707     /* Select the Mouse Report Endpoint */
 708     Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
 709
 710     /* Check if write ready for a polling interval around 10ms */
 711     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 712     if (!Endpoint_IsReadWriteAllowed()) return;
 713
 714     /* Write Mouse Report Data */
 715     Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
 716
 717     /* Finalize the stream transfer to send the last packet */
 718     Endpoint_ClearIN();
 719 #endif
 720 }
 721
 722 /** \brief Send System
 723  *
 724  * FIXME: Needs doc
 725  */
 726 static void send_system(uint16_t data)
 727 {
 728 #ifdef EXTRAKEY_ENABLE
 729     uint8_t timeout = 255;
 730
 731     if (USB_DeviceState != DEVICE_STATE_Configured)
 732         return;
 733
 734     report_extra_t r = {
 735         .report_id = REPORT_ID_SYSTEM,
 736         .usage = data - SYSTEM_POWER_DOWN + 1
 737     };
 738     Endpoint_SelectEndpoint(SHARED_IN_EPNUM);
 739
 740     /* Check if write ready for a polling interval around 10ms */
 741     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 742     if (!Endpoint_IsReadWriteAllowed()) return;
 743
 744     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 745     Endpoint_ClearIN();
 746 #endif
 747 }
 748
 749 /** \brief Send Consumer
 750  *
 751  * FIXME: Needs doc
 752  */
 753 static void send_consumer(uint16_t data)
 754 {
 755 #ifdef EXTRAKEY_ENABLE
 756     uint8_t timeout = 255;
 757     uint8_t where = where_to_send();
 758
 759 #ifdef BLUETOOTH_ENABLE
 760     if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 761       #ifdef MODULE_ADAFRUIT_BLE
 762         adafruit_ble_send_consumer_key(data, 0);
 763       #elif MODULE_RN42
 764         static uint16_t last_data = 0;
 765         if (data == last_data) return;
 766         last_data = data;
 767         uint16_t bitmap = CONSUMER2RN42(data);
 768         bluefruit_serial_send(0xFD);
 769         bluefruit_serial_send(0x03);
 770         bluefruit_serial_send(0x03);
 771         bluefruit_serial_send(bitmap&0xFF);
 772         bluefruit_serial_send((bitmap>>8)&0xFF);
 773       #else
 774         static uint16_t last_data = 0;
 775         if (data == last_data) return;
 776         last_data = data;
 777         uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
 778         bluefruit_serial_send(0xFD);
 779         bluefruit_serial_send(0x00);
 780         bluefruit_serial_send(0x02);
 781         bluefruit_serial_send((bitmap>>8)&0xFF);
 782         bluefruit_serial_send(bitmap&0xFF);
 783         bluefruit_serial_send(0x00);
 784         bluefruit_serial_send(0x00);
 785         bluefruit_serial_send(0x00);
 786         bluefruit_serial_send(0x00);
 787       #endif
 788     }
 789 #endif
 790
 791     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 792       return;
 793     }
 794
 795     report_extra_t r = {
 796         .report_id = REPORT_ID_CONSUMER,
 797         .usage = data
 798     };
 799     Endpoint_SelectEndpoint(SHARED_IN_EPNUM);
 800
 801     /* Check if write ready for a polling interval around 10ms */
 802     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 803     if (!Endpoint_IsReadWriteAllowed()) return;
 804
 805     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 806     Endpoint_ClearIN();
 807 #endif
 808 }
 809
 810
 811 /*******************************************************************************
 812  * sendchar
 813  ******************************************************************************/
 814 #ifdef CONSOLE_ENABLE
 815 #define SEND_TIMEOUT 5
 816 /** \brief Send Char
 817  *
 818  * FIXME: Needs doc
 819  */
 820 int8_t sendchar(uint8_t c)
 821 {
 822     // Not wait once timeouted.
 823     // Because sendchar() is called so many times, waiting each call causes big lag.
 824     static bool timeouted = false;
 825
 826     // prevents Console_Task() from running during sendchar() runs.
 827     // or char will be lost. These two function is mutually exclusive.
 828     CONSOLE_FLUSH_SET(false);
 829
 830     if (USB_DeviceState != DEVICE_STATE_Configured)
 831         return -1;
 832
 833     uint8_t ep = Endpoint_GetCurrentEndpoint();
 834     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 835     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 836         goto ERROR_EXIT;
 837     }
 838
 839     if (timeouted && !Endpoint_IsReadWriteAllowed()) {
 840         goto ERROR_EXIT;
 841     }
 842
 843     timeouted = false;
 844
 845     uint8_t timeout = SEND_TIMEOUT;
 846     while (!Endpoint_IsReadWriteAllowed()) {
 847         if (USB_DeviceState != DEVICE_STATE_Configured) {
 848             goto ERROR_EXIT;
 849         }
 850         if (Endpoint_IsStalled()) {
 851             goto ERROR_EXIT;
 852         }
 853         if (!(timeout--)) {
 854             timeouted = true;
 855             goto ERROR_EXIT;
 856         }
 857         _delay_ms(1);
 858     }
 859
 860     Endpoint_Write_8(c);
 861
 862     // send when bank is full
 863     if (!Endpoint_IsReadWriteAllowed()) {
 864         while (!(Endpoint_IsINReady()));
 865         Endpoint_ClearIN();
 866     } else {
 867         CONSOLE_FLUSH_SET(true);
 868     }
 869
 870     Endpoint_SelectEndpoint(ep);
 871     return 0;
 872 ERROR_EXIT:
 873     Endpoint_SelectEndpoint(ep);
 874     return -1;
 875 }
 876 #else
 877 int8_t sendchar(uint8_t c)
 878 {
 879     return 0;
 880 }
 881 #endif
 882
 883 /*******************************************************************************
 884  * MIDI
 885  ******************************************************************************/
 886
 887 #ifdef MIDI_ENABLE
 888 USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface =
 889 {
 890   .Config =
 891   {
 892     .StreamingInterfaceNumber = AS_INTERFACE,
 893     .DataINEndpoint           =
 894     {
 895       .Address          = MIDI_STREAM_IN_EPADDR,
 896       .Size             = MIDI_STREAM_EPSIZE,
 897       .Banks            = 1,
 898     },
 899     .DataOUTEndpoint          =
 900     {
 901       .Address          = MIDI_STREAM_OUT_EPADDR,
 902       .Size             = MIDI_STREAM_EPSIZE,
 903       .Banks            = 1,
 904     },
 905   },
 906 };
 907
 908 void send_midi_packet(MIDI_EventPacket_t* event) {
 909   MIDI_Device_SendEventPacket(&USB_MIDI_Interface, event);
 910 }
 911
 912 bool recv_midi_packet(MIDI_EventPacket_t* const event) {
 913   return MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, event);
 914 }
 915
 916 #endif
 917
 918 /*******************************************************************************
 919  * VIRTUAL SERIAL
 920  ******************************************************************************/
 921
 922 #ifdef VIRTSER_ENABLE
 923 /** \brief Virtual Serial Init
 924  *
 925  * FIXME: Needs doc
 926  */
 927 void virtser_init(void)
 928 {
 929   cdc_device.State.ControlLineStates.DeviceToHost = CDC_CONTROL_LINE_IN_DSR ;
 930   CDC_Device_SendControlLineStateChange(&cdc_device);
 931 }
 932
 933 /** \brief Virtual Serial Receive
 934  *
 935  * FIXME: Needs doc
 936  */
 937 void virtser_recv(uint8_t c) __attribute__ ((weak));
 938 void virtser_recv(uint8_t c)
 939 {
 940   // Ignore by default
 941 }
 942
 943 /** \brief Virtual Serial Task
 944  *
 945  * FIXME: Needs doc
 946  */
 947 void virtser_task(void)
 948 {
 949   uint16_t count = CDC_Device_BytesReceived(&cdc_device);
 950   uint8_t ch;
 951   if (count)
 952   {
 953     ch = CDC_Device_ReceiveByte(&cdc_device);
 954     virtser_recv(ch);
 955   }
 956 }
 957 /** \brief Virtual Serial Send
 958  *
 959  * FIXME: Needs doc
 960  */
 961 void virtser_send(const uint8_t byte)
 962 {
 963   uint8_t timeout = 255;
 964   uint8_t ep = Endpoint_GetCurrentEndpoint();
 965
 966   if (cdc_device.State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 967   {
 968     /* IN packet */
 969     Endpoint_SelectEndpoint(cdc_device.Config.DataINEndpoint.Address);
 970
 971     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 972         Endpoint_SelectEndpoint(ep);
 973         return;
 974     }
 975
 976     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 977
 978     Endpoint_Write_8(byte);
 979     CDC_Device_Flush(&cdc_device);
 980
 981     if (Endpoint_IsINReady()) {
 982       Endpoint_ClearIN();
 983     }
 984
 985     Endpoint_SelectEndpoint(ep);
 986   }
 987 }
 988 #endif
 989
 990 /*******************************************************************************
 991  * main
 992  ******************************************************************************/
 993 /** \brief Setup MCU
 994  *
 995  * FIXME: Needs doc
 996  */
 997 static void setup_mcu(void)
 998 {
 999     /* Disable watchdog if enabled by bootloader/fuses */
1000     MCUSR &= ~(1 << WDRF);
1001     wdt_disable();
1002
1003     /* Disable clock division */
1004     // clock_prescale_set(clock_div_1);
1005
1006     CLKPR = (1 << CLKPCE);
1007     CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
1008 }
1009
1010 /** \brief Setup USB
1011  *
1012  * FIXME: Needs doc
1013  */
1014 static void setup_usb(void)
1015 {
1016     // Leonardo needs. Without this USB device is not recognized.
1017     USB_Disable();
1018
1019     USB_Init();
1020
1021     // for Console_Task
1022     USB_Device_EnableSOFEvents();
1023     print_set_sendchar(sendchar);
1024 }
1025
1026 /** \brief Main
1027  *
1028  * FIXME: Needs doc
1029  */
1030 int main(void)  __attribute__ ((weak));
1031 int main(void)
1032 {
1033 #ifdef MIDI_ENABLE
1034     setup_midi();
1035 #endif
1036
1037     setup_mcu();
1038     keyboard_setup();
1039     setup_usb();
1040     sei();
1041
1042 #if defined(MODULE_ADAFRUIT_EZKEY) || defined(MODULE_RN42)
1043     serial_init();
1044 #endif
1045
1046     /* wait for USB startup & debug output */
1047
1048 #ifdef WAIT_FOR_USB
1049     while (USB_DeviceState != DEVICE_STATE_Configured) {
1050     #if defined(INTERRUPT_CONTROL_ENDPOINT)
1051             ;
1052     #else
1053             USB_USBTask();
1054     #endif
1055     }
1056     print("USB configured.\n");
1057 #else
1058     USB_USBTask();
1059 #endif
1060     /* init modules */
1061     keyboard_init();
1062     host_set_driver(&lufa_driver);
1063 #ifdef SLEEP_LED_ENABLE
1064     sleep_led_init();
1065 #endif
1066
1067 #ifdef VIRTSER_ENABLE
1068     virtser_init();
1069 #endif
1070
1071     print("Keyboard start.\n");
1072     while (1) {
1073         #if !defined(NO_USB_STARTUP_CHECK)
1074         while (USB_DeviceState == DEVICE_STATE_Suspended) {
1075             print("[s]");
1076             suspend_power_down();
1077             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
1078                     USB_Device_SendRemoteWakeup();
1079             }
1080         }
1081         #endif
1082
1083         keyboard_task();
1084
1085 #ifdef MIDI_ENABLE
1086         MIDI_Device_USBTask(&USB_MIDI_Interface);
1087 #endif
1088
1089 #if defined(RGBLIGHT_ANIMATIONS) & defined(RGBLIGHT_ENABLE)
1090         rgblight_task();
1091 #endif
1092
1093 #ifdef MODULE_ADAFRUIT_BLE
1094         adafruit_ble_task();
1095 #endif
1096
1097 #ifdef VIRTSER_ENABLE
1098         virtser_task();
1099         CDC_Device_USBTask(&cdc_device);
1100 #endif
1101
1102 #ifdef RAW_ENABLE
1103         raw_hid_task();
1104 #endif
1105
1106 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
1107         USB_USBTask();
1108 #endif
1109
1110     }
1111 }
1112
1113 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
1114                                     const uint16_t wIndex,
1115                                     const void** const DescriptorAddress)
1116 {
1117   return get_usb_descriptor(wValue, wIndex, DescriptorAddress);
1118 }
1119