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 "descriptor.h"
  53 #include "lufa.h"
  54 #include "quantum.h"
  55
  56 #ifdef NKRO_ENABLE
  57   #include "keycode_config.h"
  58
  59   extern keymap_config_t keymap_config;
  60 #endif
  61
  62
  63 #ifdef AUDIO_ENABLE
  64     #include <audio.h>
  65 #endif
  66
  67 #ifdef BLUETOOTH_ENABLE
  68     #include "bluetooth.h"
  69 #endif
  70
  71 #ifdef VIRTSER_ENABLE
  72     #include "virtser.h"
  73 #endif
  74
  75 #ifdef RGB_MIDI
  76     #include "rgblight.h"
  77 #endif
  78
  79 uint8_t keyboard_idle = 0;
  80 /* 0: Boot Protocol, 1: Report Protocol(default) */
  81 uint8_t keyboard_protocol = 1;
  82 static uint8_t keyboard_led_stats = 0;
  83
  84 static report_keyboard_t keyboard_report_sent;
  85
  86 #ifdef MIDI_ENABLE
  87 static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
  88 static void usb_get_midi(MidiDevice * device);
  89 static void midi_usb_init(MidiDevice * device);
  90 #endif
  91
  92 /* Host driver */
  93 static uint8_t keyboard_leds(void);
  94 static void send_keyboard(report_keyboard_t *report);
  95 static void send_mouse(report_mouse_t *report);
  96 static void send_system(uint16_t data);
  97 static void send_consumer(uint16_t data);
  98 host_driver_t lufa_driver = {
  99     keyboard_leds,
 100     send_keyboard,
 101     send_mouse,
 102     send_system,
 103     send_consumer,
 104 #ifdef MIDI_ENABLE
 105     usb_send_func,
 106     usb_get_midi,
 107     midi_usb_init
 108 #endif
 109 };
 110
 111 /*******************************************************************************
 112  * MIDI
 113  ******************************************************************************/
 114
 115 #ifdef MIDI_ENABLE
 116 USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface =
 117 {
 118   .Config =
 119   {
 120     .StreamingInterfaceNumber = AS_INTERFACE,
 121     .DataINEndpoint           =
 122     {
 123       .Address          = MIDI_STREAM_IN_EPADDR,
 124       .Size             = MIDI_STREAM_EPSIZE,
 125       .Banks            = 1,
 126     },
 127     .DataOUTEndpoint          =
 128     {
 129       .Address          = MIDI_STREAM_OUT_EPADDR,
 130       .Size             = MIDI_STREAM_EPSIZE,
 131       .Banks            = 1,
 132     },
 133   },
 134 };
 135
 136 #define SYSEX_START_OR_CONT 0x40
 137 #define SYSEX_ENDS_IN_1 0x50
 138 #define SYSEX_ENDS_IN_2 0x60
 139 #define SYSEX_ENDS_IN_3 0x70
 140
 141 #define SYS_COMMON_1 0x50
 142 #define SYS_COMMON_2 0x20
 143 #define SYS_COMMON_3 0x30
 144 #endif
 145
 146 #ifdef VIRTSER_ENABLE
 147 USB_ClassInfo_CDC_Device_t cdc_device =
 148 {
 149   .Config =
 150   {
 151     .ControlInterfaceNumber = CCI_INTERFACE,
 152     .DataINEndpoint         =
 153     {
 154       .Address          = CDC_IN_EPADDR,
 155       .Size             = CDC_EPSIZE,
 156       .Banks            = 1,
 157     },
 158     .DataOUTEndpoint        =
 159     {
 160       .Address          = CDC_OUT_EPADDR,
 161       .Size             = CDC_EPSIZE,
 162       .Banks            = 1,
 163     },
 164     .NotificationEndpoint   =
 165     {
 166       .Address          = CDC_NOTIFICATION_EPADDR,
 167       .Size             = CDC_NOTIFICATION_EPSIZE,
 168       .Banks            = 1,
 169     },
 170   },
 171 };
 172 #endif
 173
 174
 175 /*******************************************************************************
 176  * Console
 177  ******************************************************************************/
 178 #ifdef CONSOLE_ENABLE
 179 static void Console_Task(void)
 180 {
 181     /* Device must be connected and configured for the task to run */
 182     if (USB_DeviceState != DEVICE_STATE_Configured)
 183         return;
 184
 185     uint8_t ep = Endpoint_GetCurrentEndpoint();
 186
 187 #if 0
 188     // TODO: impl receivechar()/recvchar()
 189     Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
 190
 191     /* Check to see if a packet has been sent from the host */
 192     if (Endpoint_IsOUTReceived())
 193     {
 194         /* Check to see if the packet contains data */
 195         if (Endpoint_IsReadWriteAllowed())
 196         {
 197             /* Create a temporary buffer to hold the read in report from the host */
 198             uint8_t ConsoleData[CONSOLE_EPSIZE];
 199
 200             /* Read Console Report Data */
 201             Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
 202
 203             /* Process Console Report Data */
 204             //ProcessConsoleHIDReport(ConsoleData);
 205         }
 206
 207         /* Finalize the stream transfer to send the last packet */
 208         Endpoint_ClearOUT();
 209     }
 210 #endif
 211
 212     /* IN packet */
 213     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 214     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 215         Endpoint_SelectEndpoint(ep);
 216         return;
 217     }
 218
 219     // fill empty bank
 220     while (Endpoint_IsReadWriteAllowed())
 221         Endpoint_Write_8(0);
 222
 223     // flash senchar packet
 224     if (Endpoint_IsINReady()) {
 225         Endpoint_ClearIN();
 226     }
 227
 228     Endpoint_SelectEndpoint(ep);
 229 }
 230 #endif
 231
 232
 233 /*******************************************************************************
 234  * USB Events
 235  ******************************************************************************/
 236 /*
 237  * Event Order of Plug in:
 238  * 0) EVENT_USB_Device_Connect
 239  * 1) EVENT_USB_Device_Suspend
 240  * 2) EVENT_USB_Device_Reset
 241  * 3) EVENT_USB_Device_Wake
 242 */
 243 void EVENT_USB_Device_Connect(void)
 244 {
 245     print("[C]");
 246     /* For battery powered device */
 247     if (!USB_IsInitialized) {
 248         USB_Disable();
 249         USB_Init();
 250         USB_Device_EnableSOFEvents();
 251     }
 252 }
 253
 254 void EVENT_USB_Device_Disconnect(void)
 255 {
 256     print("[D]");
 257     /* For battery powered device */
 258     USB_IsInitialized = false;
 259 /* TODO: This doesn't work. After several plug in/outs can not be enumerated.
 260     if (USB_IsInitialized) {
 261         USB_Disable();  // Disable all interrupts
 262         USB_Controller_Enable();
 263         USB_INT_Enable(USB_INT_VBUSTI);
 264     }
 265 */
 266 }
 267
 268 void EVENT_USB_Device_Reset(void)
 269 {
 270     print("[R]");
 271 }
 272
 273 void EVENT_USB_Device_Suspend()
 274 {
 275     print("[S]");
 276 #ifdef SLEEP_LED_ENABLE
 277     sleep_led_enable();
 278 #endif
 279 }
 280
 281 void EVENT_USB_Device_WakeUp()
 282 {
 283     print("[W]");
 284     suspend_wakeup_init();
 285
 286 #ifdef SLEEP_LED_ENABLE
 287     sleep_led_disable();
 288     // NOTE: converters may not accept this
 289     led_set(host_keyboard_leds());
 290 #endif
 291 }
 292
 293 #ifdef CONSOLE_ENABLE
 294 static bool console_flush = false;
 295 #define CONSOLE_FLUSH_SET(b)   do { \
 296     uint8_t sreg = SREG; cli(); console_flush = b; SREG = sreg; \
 297 } while (0)
 298
 299 // called every 1ms
 300 void EVENT_USB_Device_StartOfFrame(void)
 301 {
 302     static uint8_t count;
 303     if (++count % 50) return;
 304     count = 0;
 305
 306     if (!console_flush) return;
 307     Console_Task();
 308     console_flush = false;
 309 }
 310 #endif
 311
 312 /** Event handler for the USB_ConfigurationChanged event.
 313  * This is fired when the host sets the current configuration of the USB device after enumeration.
 314  *
 315  * ATMega32u2 supports dual bank(ping-pong mode) only on endpoint 3 and 4,
 316  * it is safe to use singl bank for all endpoints.
 317  */
 318 void EVENT_USB_Device_ConfigurationChanged(void)
 319 {
 320     bool ConfigSuccess = true;
 321
 322     /* Setup Keyboard HID Report Endpoints */
 323     ConfigSuccess &= ENDPOINT_CONFIG(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 324                                      KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 325
 326 #ifdef MOUSE_ENABLE
 327     /* Setup Mouse HID Report Endpoint */
 328     ConfigSuccess &= ENDPOINT_CONFIG(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 329                                      MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
 330 #endif
 331
 332 #ifdef EXTRAKEY_ENABLE
 333     /* Setup Extra HID Report Endpoint */
 334     ConfigSuccess &= ENDPOINT_CONFIG(EXTRAKEY_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 335                                      EXTRAKEY_EPSIZE, ENDPOINT_BANK_SINGLE);
 336 #endif
 337
 338 #ifdef CONSOLE_ENABLE
 339     /* Setup Console HID Report Endpoints */
 340     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 341                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 342 #if 0
 343     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 344                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 345 #endif
 346 #endif
 347
 348 #ifdef NKRO_ENABLE
 349     /* Setup NKRO HID Report Endpoints */
 350     ConfigSuccess &= ENDPOINT_CONFIG(NKRO_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 351                                      NKRO_EPSIZE, ENDPOINT_BANK_SINGLE);
 352 #endif
 353
 354 #ifdef MIDI_ENABLE
 355     ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
 356     ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
 357 #endif
 358
 359 #ifdef VIRTSER_ENABLE
 360     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
 361     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_OUT_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
 362     ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_IN_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
 363 #endif
 364 }
 365
 366 /*
 367 Appendix G: HID Request Support Requirements
 368
 369 The following table enumerates the requests that need to be supported by various types of HID class devices.
 370
 371 Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
 372 ------------------------------------------------------------------------------------------
 373 Boot Mouse      Required    Optional    Optional    Optional    Required    Required
 374 Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
 375 Boot Keyboard   Required    Optional    Required    Required    Required    Required
 376 Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
 377 Other Device    Required    Optional    Optional    Optional    Optional    Optional
 378 */
 379 /** Event handler for the USB_ControlRequest event.
 380  *  This is fired before passing along unhandled control requests to the library for processing internally.
 381  */
 382 void EVENT_USB_Device_ControlRequest(void)
 383 {
 384     uint8_t* ReportData = NULL;
 385     uint8_t  ReportSize = 0;
 386
 387     /* Handle HID Class specific requests */
 388     switch (USB_ControlRequest.bRequest)
 389     {
 390         case HID_REQ_GetReport:
 391             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 392             {
 393                 Endpoint_ClearSETUP();
 394
 395                 // Interface
 396                 switch (USB_ControlRequest.wIndex) {
 397                 case KEYBOARD_INTERFACE:
 398                     // TODO: test/check
 399                     ReportData = (uint8_t*)&keyboard_report_sent;
 400                     ReportSize = sizeof(keyboard_report_sent);
 401                     break;
 402                 }
 403
 404                 /* Write the report data to the control endpoint */
 405                 Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
 406                 Endpoint_ClearOUT();
 407             }
 408
 409             break;
 410         case HID_REQ_SetReport:
 411             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 412             {
 413
 414                 // Interface
 415                 switch (USB_ControlRequest.wIndex) {
 416                 case KEYBOARD_INTERFACE:
 417 #ifdef NKRO_ENABLE
 418                 case NKRO_INTERFACE:
 419 #endif
 420                     Endpoint_ClearSETUP();
 421
 422                     while (!(Endpoint_IsOUTReceived())) {
 423                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 424                           return;
 425                     }
 426                     keyboard_led_stats = Endpoint_Read_8();
 427
 428                     Endpoint_ClearOUT();
 429                     Endpoint_ClearStatusStage();
 430                     break;
 431                 }
 432
 433             }
 434
 435             break;
 436
 437         case HID_REQ_GetProtocol:
 438             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 439             {
 440                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 441                     Endpoint_ClearSETUP();
 442                     while (!(Endpoint_IsINReady()));
 443                     Endpoint_Write_8(keyboard_protocol);
 444                     Endpoint_ClearIN();
 445                     Endpoint_ClearStatusStage();
 446                 }
 447             }
 448
 449             break;
 450         case HID_REQ_SetProtocol:
 451             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 452             {
 453                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 454                     Endpoint_ClearSETUP();
 455                     Endpoint_ClearStatusStage();
 456
 457                     keyboard_protocol = (USB_ControlRequest.wValue & 0xFF);
 458                     clear_keyboard();
 459                 }
 460             }
 461
 462             break;
 463         case HID_REQ_SetIdle:
 464             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 465             {
 466                 Endpoint_ClearSETUP();
 467                 Endpoint_ClearStatusStage();
 468
 469                 keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
 470             }
 471
 472             break;
 473         case HID_REQ_GetIdle:
 474             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 475             {
 476                 Endpoint_ClearSETUP();
 477                 while (!(Endpoint_IsINReady()));
 478                 Endpoint_Write_8(keyboard_idle);
 479                 Endpoint_ClearIN();
 480                 Endpoint_ClearStatusStage();
 481             }
 482
 483             break;
 484     }
 485
 486 #ifdef VIRTSER_ENABLE
 487     CDC_Device_ProcessControlRequest(&cdc_device);
 488 #endif
 489 }
 490
 491 /*******************************************************************************
 492  * Host driver
 493 p
 494  ******************************************************************************/
 495 static uint8_t keyboard_leds(void)
 496 {
 497     return keyboard_led_stats;
 498 }
 499
 500 static void send_keyboard(report_keyboard_t *report)
 501 {
 502
 503 #ifdef BLUETOOTH_ENABLE
 504     bluefruit_serial_send(0xFD);
 505     for (uint8_t i = 0; i < KEYBOARD_EPSIZE; i++) {
 506         bluefruit_serial_send(report->raw[i]);
 507     }
 508 #endif
 509
 510     uint8_t timeout = 255;
 511
 512     if (USB_DeviceState != DEVICE_STATE_Configured)
 513         return;
 514
 515     /* Select the Keyboard Report Endpoint */
 516 #ifdef NKRO_ENABLE
 517     if (keyboard_protocol && keymap_config.nkro) {
 518         /* Report protocol - NKRO */
 519         Endpoint_SelectEndpoint(NKRO_IN_EPNUM);
 520
 521         /* Check if write ready for a polling interval around 1ms */
 522         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(4);
 523         if (!Endpoint_IsReadWriteAllowed()) return;
 524
 525         /* Write Keyboard Report Data */
 526         Endpoint_Write_Stream_LE(report, NKRO_EPSIZE, NULL);
 527     }
 528     else
 529 #endif
 530     {
 531         /* Boot protocol */
 532         Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
 533
 534         /* Check if write ready for a polling interval around 10ms */
 535         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 536         if (!Endpoint_IsReadWriteAllowed()) return;
 537
 538         /* Write Keyboard Report Data */
 539         Endpoint_Write_Stream_LE(report, KEYBOARD_EPSIZE, NULL);
 540     }
 541
 542     /* Finalize the stream transfer to send the last packet */
 543     Endpoint_ClearIN();
 544
 545     keyboard_report_sent = *report;
 546 }
 547
 548 static void send_mouse(report_mouse_t *report)
 549 {
 550 #ifdef MOUSE_ENABLE
 551
 552 #ifdef BLUETOOTH_ENABLE
 553     bluefruit_serial_send(0xFD);
 554     bluefruit_serial_send(0x00);
 555     bluefruit_serial_send(0x03);
 556     bluefruit_serial_send(report->buttons);
 557     bluefruit_serial_send(report->x);
 558     bluefruit_serial_send(report->y);
 559     bluefruit_serial_send(report->v); // should try sending the wheel v here
 560     bluefruit_serial_send(report->h); // should try sending the wheel h here
 561     bluefruit_serial_send(0x00);
 562 #endif
 563
 564     uint8_t timeout = 255;
 565
 566     if (USB_DeviceState != DEVICE_STATE_Configured)
 567         return;
 568
 569     /* Select the Mouse Report Endpoint */
 570     Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
 571
 572     /* Check if write ready for a polling interval around 10ms */
 573     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 574     if (!Endpoint_IsReadWriteAllowed()) return;
 575
 576     /* Write Mouse Report Data */
 577     Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
 578
 579     /* Finalize the stream transfer to send the last packet */
 580     Endpoint_ClearIN();
 581 #endif
 582 }
 583
 584 static void send_system(uint16_t data)
 585 {
 586     uint8_t timeout = 255;
 587
 588     if (USB_DeviceState != DEVICE_STATE_Configured)
 589         return;
 590
 591     report_extra_t r = {
 592         .report_id = REPORT_ID_SYSTEM,
 593         .usage = data
 594     };
 595     Endpoint_SelectEndpoint(EXTRAKEY_IN_EPNUM);
 596
 597     /* Check if write ready for a polling interval around 10ms */
 598     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 599     if (!Endpoint_IsReadWriteAllowed()) return;
 600
 601     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 602     Endpoint_ClearIN();
 603 }
 604
 605 static void send_consumer(uint16_t data)
 606 {
 607
 608 #ifdef BLUETOOTH_ENABLE
 609     static uint16_t last_data = 0;
 610     if (data == last_data) return;
 611     last_data = data;
 612     uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
 613     bluefruit_serial_send(0xFD);
 614     bluefruit_serial_send(0x00);
 615     bluefruit_serial_send(0x02);
 616     bluefruit_serial_send((bitmap>>8)&0xFF);
 617     bluefruit_serial_send(bitmap&0xFF);
 618     bluefruit_serial_send(0x00);
 619     bluefruit_serial_send(0x00);
 620     bluefruit_serial_send(0x00);
 621     bluefruit_serial_send(0x00);
 622 #endif
 623
 624     uint8_t timeout = 255;
 625
 626     if (USB_DeviceState != DEVICE_STATE_Configured)
 627         return;
 628
 629     report_extra_t r = {
 630         .report_id = REPORT_ID_CONSUMER,
 631         .usage = data
 632     };
 633     Endpoint_SelectEndpoint(EXTRAKEY_IN_EPNUM);
 634
 635     /* Check if write ready for a polling interval around 10ms */
 636     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 637     if (!Endpoint_IsReadWriteAllowed()) return;
 638
 639     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 640     Endpoint_ClearIN();
 641 }
 642
 643
 644 /*******************************************************************************
 645  * sendchar
 646  ******************************************************************************/
 647 #ifdef CONSOLE_ENABLE
 648 #define SEND_TIMEOUT 5
 649 int8_t sendchar(uint8_t c)
 650 {
 651     // Not wait once timeouted.
 652     // Because sendchar() is called so many times, waiting each call causes big lag.
 653     static bool timeouted = false;
 654
 655     // prevents Console_Task() from running during sendchar() runs.
 656     // or char will be lost. These two function is mutually exclusive.
 657     CONSOLE_FLUSH_SET(false);
 658
 659     if (USB_DeviceState != DEVICE_STATE_Configured)
 660         return -1;
 661
 662     uint8_t ep = Endpoint_GetCurrentEndpoint();
 663     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 664     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 665         goto ERROR_EXIT;
 666     }
 667
 668     if (timeouted && !Endpoint_IsReadWriteAllowed()) {
 669         goto ERROR_EXIT;
 670     }
 671
 672     timeouted = false;
 673
 674     uint8_t timeout = SEND_TIMEOUT;
 675     while (!Endpoint_IsReadWriteAllowed()) {
 676         if (USB_DeviceState != DEVICE_STATE_Configured) {
 677             goto ERROR_EXIT;
 678         }
 679         if (Endpoint_IsStalled()) {
 680             goto ERROR_EXIT;
 681         }
 682         if (!(timeout--)) {
 683             timeouted = true;
 684             goto ERROR_EXIT;
 685         }
 686         _delay_ms(1);
 687     }
 688
 689     Endpoint_Write_8(c);
 690
 691     // send when bank is full
 692     if (!Endpoint_IsReadWriteAllowed()) {
 693         while (!(Endpoint_IsINReady()));
 694         Endpoint_ClearIN();
 695     } else {
 696         CONSOLE_FLUSH_SET(true);
 697     }
 698
 699     Endpoint_SelectEndpoint(ep);
 700     return 0;
 701 ERROR_EXIT:
 702     Endpoint_SelectEndpoint(ep);
 703     return -1;
 704 }
 705 #else
 706 int8_t sendchar(uint8_t c)
 707 {
 708     return 0;
 709 }
 710 #endif
 711
 712 /*******************************************************************************
 713  * MIDI
 714  ******************************************************************************/
 715
 716 #ifdef MIDI_ENABLE
 717 static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
 718   MIDI_EventPacket_t event;
 719   event.Data1 = byte0;
 720   event.Data2 = byte1;
 721   event.Data3 = byte2;
 722
 723   uint8_t cable = 0;
 724
 725 // Endpoint_SelectEndpoint(MIDI_STREAM_IN_EPNUM);
 726
 727   //if the length is undefined we assume it is a SYSEX message
 728   if (midi_packet_length(byte0) == UNDEFINED) {
 729     switch(cnt) {
 730       case 3:
 731         if (byte2 == SYSEX_END)
 732           event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_3);
 733         else
 734           event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
 735         break;
 736       case 2:
 737         if (byte1 == SYSEX_END)
 738           event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_2);
 739         else
 740           event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
 741         break;
 742       case 1:
 743         if (byte0 == SYSEX_END)
 744           event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_1);
 745         else
 746           event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
 747         break;
 748       default:
 749         return; //invalid cnt
 750     }
 751   } else {
 752     //deal with 'system common' messages
 753     //TODO are there any more?
 754     switch(byte0 & 0xF0){
 755       case MIDI_SONGPOSITION:
 756         event.Event = MIDI_EVENT(cable, SYS_COMMON_3);
 757         break;
 758       case MIDI_SONGSELECT:
 759       case MIDI_TC_QUARTERFRAME:
 760         event.Event = MIDI_EVENT(cable, SYS_COMMON_2);
 761         break;
 762       default:
 763         event.Event = MIDI_EVENT(cable, byte0);
 764         break;
 765     }
 766   }
 767
 768 // Endpoint_Write_Stream_LE(&event, sizeof(event), NULL);
 769 // Endpoint_ClearIN();
 770
 771   MIDI_Device_SendEventPacket(&USB_MIDI_Interface, &event);
 772   MIDI_Device_Flush(&USB_MIDI_Interface);
 773   MIDI_Device_USBTask(&USB_MIDI_Interface);
 774   USB_USBTask();
 775 }
 776
 777 static void usb_get_midi(MidiDevice * device) {
 778   MIDI_EventPacket_t event;
 779   while (MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, &event)) {
 780
 781     midi_packet_length_t length = midi_packet_length(event.Data1);
 782     uint8_t input[3];
 783     input[0] = event.Data1;
 784     input[1] = event.Data2;
 785     input[2] = event.Data3;
 786     if (length == UNDEFINED) {
 787       //sysex
 788       if (event.Event == MIDI_EVENT(0, SYSEX_START_OR_CONT) || event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_3)) {
 789         length = 3;
 790       } else if (event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_2)) {
 791         length = 2;
 792       } else if(event.Event ==  MIDI_EVENT(0, SYSEX_ENDS_IN_1)) {
 793         length = 1;
 794       } else {
 795         //XXX what to do?
 796       }
 797     }
 798
 799     //pass the data to the device input function
 800     if (length != UNDEFINED)
 801       midi_device_input(device, length, input);
 802   }
 803   MIDI_Device_USBTask(&USB_MIDI_Interface);
 804   USB_USBTask();
 805 }
 806
 807 static void midi_usb_init(MidiDevice * device){
 808   midi_device_init(device);
 809   midi_device_set_send_func(device, usb_send_func);
 810   midi_device_set_pre_input_process_func(device, usb_get_midi);
 811
 812   // SetupHardware();
 813   sei();
 814 }
 815
 816 void MIDI_Task(void)
 817 {
 818
 819     /* Device must be connected and configured for the task to run */
 820     dprint("in MIDI_TASK\n");
 821     if (USB_DeviceState != DEVICE_STATE_Configured)
 822       return;
 823     dprint("continuing in MIDI_TASK\n");
 824
 825     Endpoint_SelectEndpoint(MIDI_STREAM_IN_EPADDR);
 826
 827     if (Endpoint_IsINReady())
 828     {
 829
 830         dprint("Endpoint is ready\n");
 831
 832         uint8_t MIDICommand = 0;
 833         uint8_t MIDIPitch;
 834
 835         /* Get board button status - if pressed use channel 10 (percussion), otherwise use channel 1 */
 836         uint8_t Channel = MIDI_CHANNEL(1);
 837
 838         MIDICommand = MIDI_COMMAND_NOTE_ON;
 839         MIDIPitch   = 0x3E;
 840
 841         /* Check if a MIDI command is to be sent */
 842         if (MIDICommand)
 843         {
 844             dprint("Command exists\n");
 845             MIDI_EventPacket_t MIDIEvent = (MIDI_EventPacket_t)
 846                 {
 847                     .Event       = MIDI_EVENT(0, MIDICommand),
 848
 849                     .Data1       = MIDICommand | Channel,
 850                     .Data2       = MIDIPitch,
 851                     .Data3       = MIDI_STANDARD_VELOCITY,
 852                 };
 853
 854             /* Write the MIDI event packet to the endpoint */
 855             Endpoint_Write_Stream_LE(&MIDIEvent, sizeof(MIDIEvent), NULL);
 856
 857             /* Send the data in the endpoint to the host */
 858             Endpoint_ClearIN();
 859         }
 860     }
 861
 862
 863     /* Select the MIDI OUT stream */
 864     Endpoint_SelectEndpoint(MIDI_STREAM_OUT_EPADDR);
 865
 866     /* Check if a MIDI command has been received */
 867     if (Endpoint_IsOUTReceived())
 868     {
 869         MIDI_EventPacket_t MIDIEvent;
 870
 871         /* Read the MIDI event packet from the endpoint */
 872         Endpoint_Read_Stream_LE(&MIDIEvent, sizeof(MIDIEvent), NULL);
 873
 874         /* If the endpoint is now empty, clear the bank */
 875         if (!(Endpoint_BytesInEndpoint()))
 876         {
 877             /* Clear the endpoint ready for new packet */
 878             Endpoint_ClearOUT();
 879         }
 880     }
 881 }
 882
 883 #endif
 884
 885 /*******************************************************************************
 886  * VIRTUAL SERIAL
 887  ******************************************************************************/
 888
 889 #ifdef VIRTSER_ENABLE
 890 void virtser_init(void)
 891 {
 892   cdc_device.State.ControlLineStates.DeviceToHost = CDC_CONTROL_LINE_IN_DSR ;
 893   CDC_Device_SendControlLineStateChange(&cdc_device);
 894 }
 895
 896 void virtser_recv(uint8_t c) __attribute__ ((weak));
 897 void virtser_recv(uint8_t c)
 898 {
 899   // Ignore by default
 900 }
 901
 902 void virtser_task(void)
 903 {
 904   uint16_t count = CDC_Device_BytesReceived(&cdc_device);
 905   uint8_t ch;
 906   if (count)
 907   {
 908     ch = CDC_Device_ReceiveByte(&cdc_device);
 909     virtser_recv(ch);
 910   }
 911 }
 912 void virtser_send(const uint8_t byte)
 913 {
 914   uint8_t timeout = 255;
 915   uint8_t ep = Endpoint_GetCurrentEndpoint();
 916
 917   if (cdc_device.State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR)
 918   {
 919     /* IN packet */
 920     Endpoint_SelectEndpoint(cdc_device.Config.DataINEndpoint.Address);
 921
 922     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 923         Endpoint_SelectEndpoint(ep);
 924         return;
 925     }
 926
 927     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 928
 929     Endpoint_Write_8(byte);
 930     CDC_Device_Flush(&cdc_device);
 931
 932     if (Endpoint_IsINReady()) {
 933       Endpoint_ClearIN();
 934     }
 935
 936     Endpoint_SelectEndpoint(ep);
 937   }
 938 }
 939 #endif
 940
 941 /*******************************************************************************
 942  * main
 943  ******************************************************************************/
 944 static void setup_mcu(void)
 945 {
 946     /* Disable watchdog if enabled by bootloader/fuses */
 947     MCUSR &= ~(1 << WDRF);
 948     wdt_disable();
 949
 950     /* Disable clock division */
 951     // clock_prescale_set(clock_div_1);
 952
 953     CLKPR = (1 << CLKPCE);
 954     CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
 955 }
 956
 957 static void setup_usb(void)
 958 {
 959     // Leonardo needs. Without this USB device is not recognized.
 960     USB_Disable();
 961
 962     USB_Init();
 963
 964     // for Console_Task
 965     USB_Device_EnableSOFEvents();
 966     print_set_sendchar(sendchar);
 967 }
 968
 969
 970 #ifdef MIDI_ENABLE
 971 void fallthrough_callback(MidiDevice * device,
 972     uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
 973 void cc_callback(MidiDevice * device,
 974     uint8_t chan, uint8_t num, uint8_t val);
 975 void sysex_callback(MidiDevice * device,
 976     uint16_t start, uint8_t length, uint8_t * data);
 977 #endif
 978
 979 int main(void)  __attribute__ ((weak));
 980 int main(void)
 981 {
 982
 983 #ifdef MIDI_ENABLE
 984     midi_device_init(&midi_device);
 985     midi_device_set_send_func(&midi_device, usb_send_func);
 986     midi_device_set_pre_input_process_func(&midi_device, usb_get_midi);
 987 #endif
 988
 989     setup_mcu();
 990     keyboard_setup();
 991     setup_usb();
 992     sei();
 993
 994 #ifdef MIDI_ENABLE
 995     midi_register_fallthrough_callback(&midi_device, fallthrough_callback);
 996     midi_register_cc_callback(&midi_device, cc_callback);
 997     midi_register_sysex_callback(&midi_device, sysex_callback);
 998
 999     // init_notes();
1000     // midi_send_cc(&midi_device, 0, 1, 2);
1001     // midi_send_cc(&midi_device, 15, 1, 0);
1002     // midi_send_noteon(&midi_device, 0, 64, 127);
1003     // midi_send_noteoff(&midi_device, 0, 64, 127);
1004 #endif
1005
1006 #ifdef BLUETOOTH_ENABLE
1007     serial_init();
1008 #endif
1009
1010     /* wait for USB startup & debug output */
1011
1012 #ifdef WAIT_FOR_USB
1013     while (USB_DeviceState != DEVICE_STATE_Configured) {
1014     #if defined(INTERRUPT_CONTROL_ENDPOINT)
1015             ;
1016     #else
1017             USB_USBTask();
1018     #endif
1019     }
1020     print("USB configured.\n");
1021 #else
1022     USB_USBTask();
1023 #endif
1024     /* init modules */
1025     keyboard_init();
1026     host_set_driver(&lufa_driver);
1027 #ifdef SLEEP_LED_ENABLE
1028     sleep_led_init();
1029 #endif
1030
1031 #ifdef VIRTSER_ENABLE
1032     virtser_init();
1033 #endif
1034
1035     print("Keyboard start.\n");
1036     while (1) {
1037         #ifndef BLUETOOTH_ENABLE
1038         while (USB_DeviceState == DEVICE_STATE_Suspended) {
1039             print("[s]");
1040             suspend_power_down();
1041             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
1042                     USB_Device_SendRemoteWakeup();
1043             }
1044         }
1045         #endif
1046
1047         keyboard_task();
1048
1049 #ifdef MIDI_ENABLE
1050         midi_device_process(&midi_device);
1051         // MIDI_Task();
1052 #endif
1053
1054 #ifdef RGBLIGHT_ENABLE
1055         rgblight_task();
1056 #endif
1057
1058 #ifdef VIRTSER_ENABLE
1059         virtser_task();
1060         CDC_Device_USBTask(&cdc_device);
1061 #endif
1062
1063 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
1064         USB_USBTask();
1065 #endif
1066     }
1067 }
1068
1069 #ifdef MIDI_ENABLE
1070 void fallthrough_callback(MidiDevice * device,
1071     uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2){
1072
1073 #ifdef AUDIO_ENABLE
1074   if (cnt == 3) {
1075     switch (byte0 & 0xF0) {
1076         case MIDI_NOTEON:
1077             play_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0), (byte2 & 0x7F) / 8);
1078             break;
1079         case MIDI_NOTEOFF:
1080             stop_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0));
1081             break;
1082     }
1083   }
1084   if (byte0 == MIDI_STOP) {
1085     stop_all_notes();
1086   }
1087 #endif
1088 }
1089
1090 #ifdef RGB_MIDI
1091     rgblight_config_t rgblight_config;
1092 #endif
1093
1094 void cc_callback(MidiDevice * device,
1095     uint8_t chan, uint8_t num, uint8_t val) {
1096   //sending it back on the next channel
1097   // midi_send_cc(device, (chan + 1) % 16, num, val);
1098     #ifdef RGB_MIDI
1099         rgblight_config.raw = eeconfig_read_rgblight();
1100         switch (num) {
1101             case 14:
1102                 rgblight_config.hue = val * 360 / 127;
1103             break;
1104             case 15:
1105                 rgblight_config.sat = val << 1;
1106             break;
1107             case 16:
1108                 rgblight_config.val = val << 1;
1109             break;
1110         }
1111         rgblight_sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val);
1112     #endif
1113 }
1114
1115 uint8_t midi_buffer[MIDI_SYSEX_BUFFER] = {0};
1116
1117 void sysex_callback(MidiDevice * device, uint16_t start, uint8_t length, uint8_t * data) {
1118   // for (int i = 0; i < length; i++)
1119   //   midi_send_cc(device, 15, 0x7F & data[i], 0x7F & (start + i));
1120     // if (start == 0x27) {
1121         // SEND_STRING("\n");
1122         // send_word(start);
1123         // SEND_STRING(": ");
1124         for (uint8_t place = 0; place < length; place++) {
1125             // send_byte(*data);
1126             midi_buffer[start + place] = *data;
1127             if (*data == 0xF7 && midi_buffer[0] == 0xF0)
1128                 sysex_buffer_callback(device, start + place, midi_buffer);
1129             // SEND_STRING(" ");
1130             data++;
1131         }
1132     // }
1133
1134 }
1135
1136 uint32_t decode_uint32_chunk(uint8_t * data) {
1137     uint32_t part1 = *data++;
1138     uint32_t part2 = *data++;
1139     uint32_t part3 = *data++;
1140     uint32_t part4 = *data++;
1141     uint32_t part5 = *data++;
1142     return ((part1 & 0x1FUL) << 28) | (part2 << 21) | (part3 << 14) | (part4 << 7) | part5;
1143 }
1144
1145 uint32_t decode_uint8_chunk(uint8_t * data) {
1146     uint32_t part4 = *data++;
1147     uint32_t part5 = *data++;
1148     return (part4 << 7) | part5;
1149 }
1150
1151 void encode_uint32_chunk(uint32_t data, uint8_t * pointer) {
1152     *pointer++ = (data >> 28) & 0x7F;
1153     *pointer++ = (data >> 21) & 0x7F;
1154     *pointer++ = (data >> 14) & 0x7F;
1155     *pointer++ = (data >> 7) & 0x7F;
1156     *pointer++ = (data) & 0x7F;
1157 }
1158
1159 void encode_uint8_chunk(uint8_t data, uint8_t * pointer) {
1160     *pointer++ = (data >> 7) & 0x7F;
1161     *pointer++ = (data) & 0x7F;
1162 }
1163
1164 void sysex_buffer_callback(MidiDevice * device, uint8_t length, uint8_t * data) {
1165     // uint8_t * pointer_copy = data; // use for debugging
1166
1167     //data++; // i'm 98% sure there's a better way to do this
1168     data++;
1169     data++;
1170     data++;
1171     data++;
1172
1173     switch (*data++) {
1174         case 0x07: ; // Quantum action
1175             break;
1176         case 0x08: ; // Keyboard acion
1177             break;
1178         case 0x09: ; // User action
1179             break;
1180         case 0x12: ; // Set info on keyboard
1181             switch (*data++) {
1182                 case 0x02: ; // set default layer
1183                     uint8_t default_layer = decode_uint8_chunk(data);
1184                     eeconfig_update_default_layer(default_layer);
1185                     default_layer_set((uint32_t)default_layer);
1186                     break;
1187                 case 0x08: ; // set keymap options
1188                     uint8_t keymap_options = decode_uint8_chunk(data);
1189                     eeconfig_update_keymap(keymap_options);
1190                     break;
1191             }
1192             break;
1193         case 0x13: ; // Get info from keyboard
1194             switch (*data++) {
1195                 case 0x00: ; // Handshake
1196                     send_bytes_sysex(0x00, NULL, 0);
1197                     break;
1198                 case 0x01: ; // Get debug state
1199                     uint8_t debug[2];
1200                     encode_uint8_chunk(eeprom_read_byte(EECONFIG_DEBUG), debug);
1201                     send_bytes_sysex(0x01, debug, 2);
1202                     break;
1203                 case 0x02: ; // Get default layer
1204                     uint8_t default_layer[2];
1205                     encode_uint8_chunk(eeprom_read_byte(EECONFIG_DEFAULT_LAYER), default_layer);
1206                     send_bytes_sysex(0x02, default_layer, 2);
1207                     break;
1208                 #ifdef AUDIO_ENABLE
1209                 case 0x03: ; // Get backlight state
1210                     uint8_t audio[2];
1211                     encode_uint8_chunk(eeprom_read_byte(EECONFIG_AUDIO), audio);
1212                     send_bytes_sysex(0x03, audio, 2);
1213                 #endif
1214                 case 0x04: ; // Get layer state
1215                     uint8_t layers[5];
1216                     encode_uint32_chunk(layer_state, layers);
1217                     send_bytes_sysex(0x04, layers, 5);
1218                     break;
1219                 #ifdef BACKLIGHT_ENABLE
1220                 case 0x06: ; // Get backlight state
1221                     uint8_t backlight[2];
1222                     encode_uint8_chunk(eeprom_read_byte(EECONFIG_BACKLIGHT), backlight);
1223                     send_bytes_sysex(0x06, backlight, 2);
1224                 #endif
1225                 #ifdef RGBLIGHT_ENABLE
1226                 case 0x07: ; // Get rgblight state
1227                     uint8_t rgblight[2];
1228                     encode_uint32_chunk(eeprom_read_dword(EECONFIG_RGBLIGHT), rgblight);
1229                     send_bytes_sysex(0x07, rgblight, 5);
1230                 #endif
1231                 case 0x08: ; // Keymap options
1232                     uint8_t keymap_options[2];
1233                     encode_uint8_chunk(eeconfig_read_keymap(), keymap_options);
1234                     send_bytes_sysex(0x08, keymap_options, 2);
1235                     break;
1236             }
1237             break;
1238         #ifdef RGBLIGHT_ENABLE
1239         case 0x27: ; // RGB LED functions
1240             switch (*data++) {
1241                 case 0x00: ; // Update HSV
1242                     uint32_t hsv = decode_uint32_chunk(data);
1243                     rgblight_sethsv(((hsv >> 16) & 0xFFFF) % 360, (hsv >> 8) & 0xFF, hsv & 0xFF);
1244                     break;
1245                 case 0x01: ; // Update RGB
1246                     break;
1247                 case 0x02: ; // Update mode
1248                     uint8_t rgb_mode = decode_uint8_chunk(data);
1249                     rgblight_mode(rgb_mode);
1250                     break;
1251             }
1252             break;
1253         #endif
1254     }
1255
1256     // SEND_STRING("\nDATA:\n");
1257     // while (*pointer_copy != 0xF7) {
1258     //     send_byte(*pointer_copy++);
1259     //     SEND_STRING(" ");
1260     // }
1261
1262 }
1263
1264 void send_unicode_midi(uint32_t unicode) {
1265     uint8_t chunk[5];
1266     encode_uint32_chunk(unicode, chunk);
1267     send_bytes_sysex(0x05, chunk, 5);
1268 }
1269
1270 void send_bytes_sysex(uint8_t type, uint8_t * bytes, uint8_t length) {
1271     uint8_t * array = malloc(sizeof(uint8_t) * (length + 6));
1272     array[0] = 0xF0;
1273     array[1] = 0x00;
1274     array[2] = 0x00;
1275     array[3] = 0x00;
1276     array[4] = type;
1277     array[length + 5] = 0xF7;
1278     memcpy(array + 5, bytes, length);
1279     midi_send_array(&midi_device, length + 6, array);
1280 }
1281
1282 #endif