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 = Endpoint_Read_8();
 523
 524                       if (report_id == REPORT_ID_KEYBOARD || report_id == REPORT_ID_NKRO) {
 525                         keyboard_led_stats = Endpoint_Read_8();
 526                       }
 527                     } else {
 528                       keyboard_led_stats = Endpoint_Read_8();
 529                     }
 530
 531                     Endpoint_ClearOUT();
 532                     Endpoint_ClearStatusStage();
 533                     break;
 534                 }
 535
 536             }
 537
 538             break;
 539
 540         case HID_REQ_GetProtocol:
 541             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 542             {
 543                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 544                     Endpoint_ClearSETUP();
 545                     while (!(Endpoint_IsINReady()));
 546                     Endpoint_Write_8(keyboard_protocol);
 547                     Endpoint_ClearIN();
 548                     Endpoint_ClearStatusStage();
 549                 }
 550             }
 551
 552             break;
 553         case HID_REQ_SetProtocol:
 554             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 555             {
 556                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 557                     Endpoint_ClearSETUP();
 558                     Endpoint_ClearStatusStage();
 559
 560                     keyboard_protocol = (USB_ControlRequest.wValue & 0xFF);
 561                     clear_keyboard();
 562                 }
 563             }
 564
 565             break;
 566         case HID_REQ_SetIdle:
 567             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 568             {
 569                 Endpoint_ClearSETUP();
 570                 Endpoint_ClearStatusStage();
 571
 572                 keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
 573             }
 574
 575             break;
 576         case HID_REQ_GetIdle:
 577             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 578             {
 579                 Endpoint_ClearSETUP();
 580                 while (!(Endpoint_IsINReady()));
 581                 Endpoint_Write_8(keyboard_idle);
 582                 Endpoint_ClearIN();
 583                 Endpoint_ClearStatusStage();
 584             }
 585
 586             break;
 587     }
 588
 589 #ifdef VIRTSER_ENABLE
 590     CDC_Device_ProcessControlRequest(&cdc_device);
 591 #endif
 592 }
 593
 594 /*******************************************************************************
 595  * Host driver
 596  ******************************************************************************/
 597 /** \brief Keyboard LEDs
 598  *
 599  * FIXME: Needs doc
 600  */
 601 static uint8_t keyboard_leds(void)
 602 {
 603     return keyboard_led_stats;
 604 }
 605
 606 /** \brief Send Keyboard
 607  *
 608  * FIXME: Needs doc
 609  */
 610 static void send_keyboard(report_keyboard_t *report)
 611 {
 612     uint8_t timeout = 255;
 613     uint8_t where = where_to_send();
 614
 615 #ifdef BLUETOOTH_ENABLE
 616   if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 617     #ifdef MODULE_ADAFRUIT_BLE
 618       adafruit_ble_send_keys(report->mods, report->keys, sizeof(report->keys));
 619     #elif MODULE_RN42
 620       bluefruit_serial_send(0xFD);
 621       bluefruit_serial_send(0x09);
 622       bluefruit_serial_send(0x01);
 623       bluefruit_serial_send(report->mods);
 624       bluefruit_serial_send(report->reserved);
 625       for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
 626         bluefruit_serial_send(report->keys[i]);
 627       }
 628     #else
 629       bluefruit_serial_send(0xFD);
 630       bluefruit_serial_send(report->mods);
 631       bluefruit_serial_send(report->reserved);
 632       for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
 633         bluefruit_serial_send(report->keys[i]);
 634       }
 635     #endif
 636   }
 637 #endif
 638
 639     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 640       return;
 641     }
 642
 643     /* Select the Keyboard Report Endpoint */
 644     uint8_t ep = KEYBOARD_IN_EPNUM;
 645     uint8_t size = KEYBOARD_REPORT_SIZE;
 646 #ifdef NKRO_ENABLE
 647     if (keyboard_protocol && keymap_config.nkro) {
 648         ep = SHARED_IN_EPNUM;
 649         size = sizeof(struct nkro_report);
 650     }
 651 #endif
 652     Endpoint_SelectEndpoint(ep);
 653     /* Check if write ready for a polling interval around 10ms */
 654     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 655     if (!Endpoint_IsReadWriteAllowed()) return;
 656
 657     /* If we're in Boot Protocol, don't send any report ID or other funky fields */
 658     if (!keyboard_protocol) {
 659         Endpoint_Write_Stream_LE(&report->mods, 8, NULL);
 660     } else {
 661         Endpoint_Write_Stream_LE(report, size, NULL);
 662     }
 663
 664     /* Finalize the stream transfer to send the last packet */
 665     Endpoint_ClearIN();
 666
 667     keyboard_report_sent = *report;
 668 }
 669
 670 /** \brief Send Mouse
 671  *
 672  * FIXME: Needs doc
 673  */
 674 static void send_mouse(report_mouse_t *report)
 675 {
 676 #ifdef MOUSE_ENABLE
 677     uint8_t timeout = 255;
 678     uint8_t where = where_to_send();
 679
 680 #ifdef BLUETOOTH_ENABLE
 681   if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 682     #ifdef MODULE_ADAFRUIT_BLE
 683       // FIXME: mouse buttons
 684       adafruit_ble_send_mouse_move(report->x, report->y, report->v, report->h, report->buttons);
 685     #else
 686       bluefruit_serial_send(0xFD);
 687       bluefruit_serial_send(0x00);
 688       bluefruit_serial_send(0x03);
 689       bluefruit_serial_send(report->buttons);
 690       bluefruit_serial_send(report->x);
 691       bluefruit_serial_send(report->y);
 692       bluefruit_serial_send(report->v); // should try sending the wheel v here
 693       bluefruit_serial_send(report->h); // should try sending the wheel h here
 694       bluefruit_serial_send(0x00);
 695     #endif
 696   }
 697 #endif
 698
 699     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 700       return;
 701     }
 702
 703     /* Select the Mouse Report Endpoint */
 704     Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
 705
 706     /* Check if write ready for a polling interval around 10ms */
 707     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 708     if (!Endpoint_IsReadWriteAllowed()) return;
 709
 710     /* Write Mouse Report Data */
 711     Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
 712
 713     /* Finalize the stream transfer to send the last packet */
 714     Endpoint_ClearIN();
 715 #endif
 716 }
 717
 718 /** \brief Send System
 719  *
 720  * FIXME: Needs doc
 721  */
 722 static void send_system(uint16_t data)
 723 {
 724 #ifdef EXTRAKEY_ENABLE
 725     uint8_t timeout = 255;
 726
 727     if (USB_DeviceState != DEVICE_STATE_Configured)
 728         return;
 729
 730     report_extra_t r = {
 731         .report_id = REPORT_ID_SYSTEM,
 732         .usage = data - SYSTEM_POWER_DOWN + 1
 733     };
 734     Endpoint_SelectEndpoint(SHARED_IN_EPNUM);
 735
 736     /* Check if write ready for a polling interval around 10ms */
 737     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 738     if (!Endpoint_IsReadWriteAllowed()) return;
 739
 740     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 741     Endpoint_ClearIN();
 742 #endif
 743 }
 744
 745 /** \brief Send Consumer
 746  *
 747  * FIXME: Needs doc
 748  */
 749 static void send_consumer(uint16_t data)
 750 {
 751 #ifdef EXTRAKEY_ENABLE
 752     uint8_t timeout = 255;
 753     uint8_t where = where_to_send();
 754
 755 #ifdef BLUETOOTH_ENABLE
 756     if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
 757       #ifdef MODULE_ADAFRUIT_BLE
 758         adafruit_ble_send_consumer_key(data, 0);
 759       #elif MODULE_RN42
 760         static uint16_t last_data = 0;
 761         if (data == last_data) return;
 762         last_data = data;
 763         uint16_t bitmap = CONSUMER2RN42(data);
 764         bluefruit_serial_send(0xFD);
 765         bluefruit_serial_send(0x03);
 766         bluefruit_serial_send(0x03);
 767         bluefruit_serial_send(bitmap&0xFF);
 768         bluefruit_serial_send((bitmap>>8)&0xFF);
 769       #else
 770         static uint16_t last_data = 0;
 771         if (data == last_data) return;
 772         last_data = data;
 773         uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
 774         bluefruit_serial_send(0xFD);
 775         bluefruit_serial_send(0x00);
 776         bluefruit_serial_send(0x02);
 777         bluefruit_serial_send((bitmap>>8)&0xFF);
 778         bluefruit_serial_send(bitmap&0xFF);
 779         bluefruit_serial_send(0x00);
 780         bluefruit_serial_send(0x00);
 781         bluefruit_serial_send(0x00);
 782         bluefruit_serial_send(0x00);
 783       #endif
 784     }
 785 #endif
 786
 787     if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
 788       return;
 789     }
 790
 791     report_extra_t r = {
 792         .report_id = REPORT_ID_CONSUMER,
 793         .usage = data
 794     };
 795     Endpoint_SelectEndpoint(SHARED_IN_EPNUM);
 796
 797     /* Check if write ready for a polling interval around 10ms */
 798     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 799     if (!Endpoint_IsReadWriteAllowed()) return;
 800
 801     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 802     Endpoint_ClearIN();
 803 #endif
 804 }
 805
 806
 807 /*******************************************************************************
 808  * sendchar
 809  ******************************************************************************/
 810 #ifdef CONSOLE_ENABLE
 811 #define SEND_TIMEOUT 5
 812 /** \brief Send Char
 813  *
 814  * FIXME: Needs doc
 815  */
 816 int8_t sendchar(uint8_t c)
 817 {
 818     // Not wait once timeouted.
 819     // Because sendchar() is called so many times, waiting each call causes big lag.
 820     static bool timeouted = false;
 821
 822     // prevents Console_Task() from running during sendchar() runs.
 823     // or char will be lost. These two function is mutually exclusive.
 824     CONSOLE_FLUSH_SET(false);
 825
 826     if (USB_DeviceState != DEVICE_STATE_Configured)
 827         return -1;
 828
 829     uint8_t ep = Endpoint_GetCurrentEndpoint();
 830     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 831     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 832         goto ERROR_EXIT;
 833     }
 834
 835     if (timeouted && !Endpoint_IsReadWriteAllowed()) {
 836         goto ERROR_EXIT;
 837     }
 838
 839     timeouted = false;
 840
 841     uint8_t timeout = SEND_TIMEOUT;
 842     while (!Endpoint_IsReadWriteAllowed()) {
 843         if (USB_DeviceState != DEVICE_STATE_Configured) {
 844             goto ERROR_EXIT;
 845         }
 846         if (Endpoint_IsStalled()) {
 847             goto ERROR_EXIT;
 848         }
 849         if (!(timeout--)) {
 850             timeouted = true;
 851             goto ERROR_EXIT;
 852         }
 853         _delay_ms(1);
 854     }
 855
 856     Endpoint_Write_8(c);
 857
 858     // send when bank is full
 859     if (!Endpoint_IsReadWriteAllowed()) {
 860         while (!(Endpoint_IsINReady()));
 861         Endpoint_ClearIN();
 862     } else {
 863         CONSOLE_FLUSH_SET(true);
 864     }
 865
 866     Endpoint_SelectEndpoint(ep);
 867     return 0;
 868 ERROR_EXIT:
 869     Endpoint_SelectEndpoint(ep);
 870     return -1;
 871 }
 872 #else
 873 int8_t sendchar(uint8_t c)
 874 {
 875     return 0;
 876 }
 877 #endif
 878
 879 /*******************************************************************************
 880  * MIDI
 881  ******************************************************************************/
 882
 883 #ifdef MIDI_ENABLE
 884 USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface =
 885 {
 886   .Config =
 887   {
 888     .StreamingInterfaceNumber = AS_INTERFACE,
 889     .DataINEndpoint           =
 890     {
 891       .Address          = MIDI_STREAM_IN_EPADDR,
 892       .Size             = MIDI_STREAM_EPSIZE,
 893       .Banks            = 1,
 894     },
 895     .DataOUTEndpoint          =
 896     {
 897       .Address          = MIDI_STREAM_OUT_EPADDR,
 898       .Size             = MIDI_STREAM_EPSIZE,
 899       .Banks            = 1,
 900     },
 901   },
 902 };
 903
 904 void send_midi_packet(MIDI_EventPacket_t* event) {
 905   MIDI_Device_SendEventPacket(&USB_MIDI_Interface, event);
 906 }
 907
 908 bool recv_midi_packet(MIDI_EventPacket_t* const event) {
 909   return MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, event);
 910 }
 911
 912 #endif
 913
 914 /*******************************************************************************
 915  * VIRTUAL SERIAL
 916  ******************************************************************************/
 917
 918 #ifdef VIRTSER_ENABLE
 919 /** \brief Virtual Serial Init
 920  *
 921  * FIXME: Needs doc
 922  */
 923 void virtser_init(void)
 924 {
 925   cdc_device.State.ControlLineStates.DeviceToHost = CDC_CONTROL_LINE_IN_DSR ;
 926   CDC_Device_SendControlLineStateChange(&cdc_device);
 927 }
 928
 929 /** \brief Virtual Serial Receive
 930  *
 931  * FIXME: Needs doc
 932  */
 933 void virtser_recv(uint8_t c) __attribute__ ((weak));
 934 void virtser_recv(uint8_t c)
 935 {
 936   // Ignore by default
 937 }
 938
 939 /** \brief Virtual Serial Task
 940  *
 941  * FIXME: Needs doc
 942  */
 943 void virtser_task(void)
 944 {
 945   uint16_t count = CDC_Device_BytesReceived(&cdc_device);
 946   uint8_t ch;
 947   if (count)
 948   {
 949     ch = CDC_Device_ReceiveByte(&cdc_device);
 950     virtser_recv(ch);
 951   }
 952 }
 953 /** \brief Virtual Serial Send
 954  *
 955  * FIXME: Needs doc
 956  */
 957 void virtser_send(const uint8_t byte)
 958 {
 959   uint8_t timeout = 255;
 960   uint8_t ep = Endpoint_GetCurrentEndpoint();
 961
 962   if (cdc_device.State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 963   {
 964     /* IN packet */
 965     Endpoint_SelectEndpoint(cdc_device.Config.DataINEndpoint.Address);
 966
 967     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 968         Endpoint_SelectEndpoint(ep);
 969         return;
 970     }
 971
 972     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 973
 974     Endpoint_Write_8(byte);
 975     CDC_Device_Flush(&cdc_device);
 976
 977     if (Endpoint_IsINReady()) {
 978       Endpoint_ClearIN();
 979     }
 980
 981     Endpoint_SelectEndpoint(ep);
 982   }
 983 }
 984 #endif
 985
 986 /*******************************************************************************
 987  * main
 988  ******************************************************************************/
 989 /** \brief Setup MCU
 990  *
 991  * FIXME: Needs doc
 992  */
 993 static void setup_mcu(void)
 994 {
 995     /* Disable watchdog if enabled by bootloader/fuses */
 996     MCUSR &= ~(1 << WDRF);
 997     wdt_disable();
 998
 999     /* Disable clock division */
1000     // clock_prescale_set(clock_div_1);
1001
1002     CLKPR = (1 << CLKPCE);
1003     CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
1004 }
1005
1006 /** \brief Setup USB
1007  *
1008  * FIXME: Needs doc
1009  */
1010 static void setup_usb(void)
1011 {
1012     // Leonardo needs. Without this USB device is not recognized.
1013     USB_Disable();
1014
1015     USB_Init();
1016
1017     // for Console_Task
1018     USB_Device_EnableSOFEvents();
1019     print_set_sendchar(sendchar);
1020 }
1021
1022 /** \brief Main
1023  *
1024  * FIXME: Needs doc
1025  */
1026 int main(void)  __attribute__ ((weak));
1027 int main(void)
1028 {
1029 #ifdef MIDI_ENABLE
1030     setup_midi();
1031 #endif
1032
1033     setup_mcu();
1034     keyboard_setup();
1035     setup_usb();
1036     sei();
1037
1038 #if defined(MODULE_ADAFRUIT_EZKEY) || defined(MODULE_RN42)
1039     serial_init();
1040 #endif
1041
1042     /* wait for USB startup & debug output */
1043
1044 #ifdef WAIT_FOR_USB
1045     while (USB_DeviceState != DEVICE_STATE_Configured) {
1046     #if defined(INTERRUPT_CONTROL_ENDPOINT)
1047             ;
1048     #else
1049             USB_USBTask();
1050     #endif
1051     }
1052     print("USB configured.\n");
1053 #else
1054     USB_USBTask();
1055 #endif
1056     /* init modules */
1057     keyboard_init();
1058     host_set_driver(&lufa_driver);
1059 #ifdef SLEEP_LED_ENABLE
1060     sleep_led_init();
1061 #endif
1062
1063 #ifdef VIRTSER_ENABLE
1064     virtser_init();
1065 #endif
1066
1067     print("Keyboard start.\n");
1068     while (1) {
1069         #if !defined(NO_USB_STARTUP_CHECK)
1070         while (USB_DeviceState == DEVICE_STATE_Suspended) {
1071             print("[s]");
1072             suspend_power_down();
1073             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
1074                     USB_Device_SendRemoteWakeup();
1075             }
1076         }
1077         #endif
1078
1079         keyboard_task();
1080
1081 #ifdef MIDI_ENABLE
1082         MIDI_Device_USBTask(&USB_MIDI_Interface);
1083 #endif
1084
1085 #if defined(RGBLIGHT_ANIMATIONS) & defined(RGBLIGHT_ENABLE)
1086         rgblight_task();
1087 #endif
1088
1089 #ifdef MODULE_ADAFRUIT_BLE
1090         adafruit_ble_task();
1091 #endif
1092
1093 #ifdef VIRTSER_ENABLE
1094         virtser_task();
1095         CDC_Device_USBTask(&cdc_device);
1096 #endif
1097
1098 #ifdef RAW_ENABLE
1099         raw_hid_task();
1100 #endif
1101
1102 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
1103         USB_USBTask();
1104 #endif
1105
1106     }
1107 }
1108
1109 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
1110                                     const uint16_t wIndex,
1111                                     const void** const DescriptorAddress)
1112 {
1113   return get_usb_descriptor(wValue, wIndex, DescriptorAddress);
1114 }
1115