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
  55 uint8_t keyboard_idle = 0;
  56 uint8_t keyboard_protocol = 1;
  57 static uint8_t keyboard_led_stats = 0;
  58
  59 static report_keyboard_t keyboard_report_sent;
  60
  61
  62 /* Host driver */
  63 static uint8_t keyboard_leds(void);
  64 static void send_keyboard(report_keyboard_t *report);
  65 static void send_mouse(report_mouse_t *report);
  66 static void send_system(uint16_t data);
  67 static void send_consumer(uint16_t data);
  68 host_driver_t lufa_driver = {
  69     keyboard_leds,
  70     send_keyboard,
  71     send_mouse,
  72     send_system,
  73     send_consumer
  74 };
  75
  76
  77 /*******************************************************************************
  78  * Console
  79  ******************************************************************************/
  80 #ifdef CONSOLE_ENABLE
  81 static void Console_Task(void)
  82 {
  83     /* Device must be connected and configured for the task to run */
  84     if (USB_DeviceState != DEVICE_STATE_Configured)
  85         return;
  86
  87     uint8_t ep = Endpoint_GetCurrentEndpoint();
  88
  89 #if 0
  90     // TODO: impl receivechar()/recvchar()
  91     Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
  92
  93     /* Check to see if a packet has been sent from the host */
  94     if (Endpoint_IsOUTReceived())
  95     {
  96         /* Check to see if the packet contains data */
  97         if (Endpoint_IsReadWriteAllowed())
  98         {
  99             /* Create a temporary buffer to hold the read in report from the host */
 100             uint8_t ConsoleData[CONSOLE_EPSIZE];
 101
 102             /* Read Console Report Data */
 103             Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
 104
 105             /* Process Console Report Data */
 106             //ProcessConsoleHIDReport(ConsoleData);
 107         }
 108
 109         /* Finalize the stream transfer to send the last packet */
 110         Endpoint_ClearOUT();
 111     }
 112 #endif
 113
 114     /* IN packet */
 115     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 116     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 117         Endpoint_SelectEndpoint(ep);
 118         return;
 119     }
 120
 121     // fill empty bank
 122     while (Endpoint_IsReadWriteAllowed())
 123         Endpoint_Write_8(0);
 124
 125     // flash senchar packet
 126     if (Endpoint_IsINReady()) {
 127         Endpoint_ClearIN();
 128     }
 129
 130     Endpoint_SelectEndpoint(ep);
 131 }
 132 #else
 133 static void Console_Task(void)
 134 {
 135 }
 136 #endif
 137
 138
 139 /*******************************************************************************
 140  * USB Events
 141  ******************************************************************************/
 142 /*
 143  * Event Order of Plug in:
 144  * 0) EVENT_USB_Device_Connect
 145  * 1) EVENT_USB_Device_Suspend
 146  * 2) EVENT_USB_Device_Reset
 147  * 3) EVENT_USB_Device_Wake
 148 */
 149 void EVENT_USB_Device_Connect(void)
 150 {
 151 }
 152
 153 void EVENT_USB_Device_Disconnect(void)
 154 {
 155 }
 156
 157 void EVENT_USB_Device_Reset(void)
 158 {
 159 }
 160
 161 void EVENT_USB_Device_Suspend()
 162 {
 163 #ifdef SLEEP_LED_ENABLE
 164     sleep_led_enable();
 165 #endif
 166 }
 167
 168 void EVENT_USB_Device_WakeUp()
 169 {
 170     suspend_wakeup_init();
 171
 172 #ifdef SLEEP_LED_ENABLE
 173     sleep_led_disable();
 174     // NOTE: converters may not accept this
 175     led_set(host_keyboard_leds());
 176 #endif
 177 }
 178
 179 void EVENT_USB_Device_StartOfFrame(void)
 180 {
 181     Console_Task();
 182 }
 183
 184 /** Event handler for the USB_ConfigurationChanged event.
 185  * This is fired when the host sets the current configuration of the USB device after enumeration.
 186  */
 187 void EVENT_USB_Device_ConfigurationChanged(void)
 188 {
 189     bool ConfigSuccess = true;
 190
 191     /* Setup Keyboard HID Report Endpoints */
 192     ConfigSuccess &= ENDPOINT_CONFIG(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 193                                      KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 194
 195 #ifdef MOUSE_ENABLE
 196     /* Setup Mouse HID Report Endpoint */
 197     ConfigSuccess &= ENDPOINT_CONFIG(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 198                                      MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
 199 #endif
 200
 201 #ifdef EXTRAKEY_ENABLE
 202     /* Setup Extra HID Report Endpoint */
 203     ConfigSuccess &= ENDPOINT_CONFIG(EXTRAKEY_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 204                                      EXTRAKEY_EPSIZE, ENDPOINT_BANK_SINGLE);
 205 #endif
 206
 207 #ifdef CONSOLE_ENABLE
 208     /* Setup Console HID Report Endpoints */
 209     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 210                                      CONSOLE_EPSIZE, ENDPOINT_BANK_DOUBLE);
 211 #if 0
 212     ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 213                                      CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 214 #endif
 215 #endif
 216
 217 #ifdef NKRO_ENABLE
 218     /* Setup NKRO HID Report Endpoints */
 219     ConfigSuccess &= ENDPOINT_CONFIG(NKRO_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 220                                      NKRO_EPSIZE, ENDPOINT_BANK_SINGLE);
 221 #endif
 222 }
 223
 224 /*
 225 Appendix G: HID Request Support Requirements
 226
 227 The following table enumerates the requests that need to be supported by various types of HID class devices.
 228
 229 Device type     GetReport   SetReport   GetIdle     SetIdle     GetProtocol SetProtocol
 230 ------------------------------------------------------------------------------------------
 231 Boot Mouse      Required    Optional    Optional    Optional    Required    Required
 232 Non-Boot Mouse  Required    Optional    Optional    Optional    Optional    Optional
 233 Boot Keyboard   Required    Optional    Required    Required    Required    Required
 234 Non-Boot Keybrd Required    Optional    Required    Required    Optional    Optional
 235 Other Device    Required    Optional    Optional    Optional    Optional    Optional
 236 */
 237 /** Event handler for the USB_ControlRequest event.
 238  *  This is fired before passing along unhandled control requests to the library for processing internally.
 239  */
 240 void EVENT_USB_Device_ControlRequest(void)
 241 {
 242     uint8_t* ReportData = NULL;
 243     uint8_t  ReportSize = 0;
 244
 245     /* Handle HID Class specific requests */
 246     switch (USB_ControlRequest.bRequest)
 247     {
 248         case HID_REQ_GetReport:
 249             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 250             {
 251                 Endpoint_ClearSETUP();
 252
 253                 // Interface
 254                 switch (USB_ControlRequest.wIndex) {
 255                 case KEYBOARD_INTERFACE:
 256                     // TODO: test/check
 257                     ReportData = (uint8_t*)&keyboard_report_sent;
 258                     ReportSize = sizeof(keyboard_report_sent);
 259                     break;
 260                 }
 261
 262                 /* Write the report data to the control endpoint */
 263                 Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
 264                 Endpoint_ClearOUT();
 265             }
 266
 267             break;
 268         case HID_REQ_SetReport:
 269             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 270             {
 271
 272                 // Interface
 273                 switch (USB_ControlRequest.wIndex) {
 274                 case KEYBOARD_INTERFACE:
 275                     Endpoint_ClearSETUP();
 276
 277                     while (!(Endpoint_IsOUTReceived())) {
 278                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 279                           return;
 280                     }
 281                     keyboard_led_stats = Endpoint_Read_8();
 282
 283                     Endpoint_ClearOUT();
 284                     Endpoint_ClearStatusStage();
 285                     break;
 286                 }
 287
 288             }
 289
 290             break;
 291
 292         case HID_REQ_GetProtocol:
 293             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 294             {
 295                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 296                     Endpoint_ClearSETUP();
 297                     while (!(Endpoint_IsINReady()));
 298                     Endpoint_Write_8(keyboard_protocol);
 299                     Endpoint_ClearIN();
 300                     Endpoint_ClearStatusStage();
 301                 }
 302             }
 303
 304             break;
 305         case HID_REQ_SetProtocol:
 306             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 307             {
 308                 if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
 309                     Endpoint_ClearSETUP();
 310                     Endpoint_ClearStatusStage();
 311
 312                     keyboard_protocol = ((USB_ControlRequest.wValue & 0xFF) != 0x00);
 313 #ifdef NKRO_ENABLE
 314                     keyboard_nkro = !!keyboard_protocol;
 315 #endif
 316                     clear_keyboard();
 317                 }
 318             }
 319
 320             break;
 321         case HID_REQ_SetIdle:
 322             if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 323             {
 324                 Endpoint_ClearSETUP();
 325                 Endpoint_ClearStatusStage();
 326
 327                 keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
 328             }
 329
 330             break;
 331         case HID_REQ_GetIdle:
 332             if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 333             {
 334                 Endpoint_ClearSETUP();
 335                 while (!(Endpoint_IsINReady()));
 336                 Endpoint_Write_8(keyboard_idle);
 337                 Endpoint_ClearIN();
 338                 Endpoint_ClearStatusStage();
 339             }
 340
 341             break;
 342     }
 343 }
 344
 345 /*******************************************************************************
 346  * Host driver
 347  ******************************************************************************/
 348 static uint8_t keyboard_leds(void)
 349 {
 350     return keyboard_led_stats;
 351 }
 352
 353 static void send_keyboard(report_keyboard_t *report)
 354 {
 355     uint8_t timeout = 255;
 356
 357     if (USB_DeviceState != DEVICE_STATE_Configured)
 358         return;
 359
 360     /* Select the Keyboard Report Endpoint */
 361 #ifdef NKRO_ENABLE
 362     if (keyboard_nkro) {
 363         /* Report protocol - NKRO */
 364         Endpoint_SelectEndpoint(NKRO_IN_EPNUM);
 365
 366         /* Check if write ready for a polling interval around 1ms */
 367         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(4);
 368         if (!Endpoint_IsReadWriteAllowed()) return;
 369
 370         /* Write Keyboard Report Data */
 371         Endpoint_Write_Stream_LE(report, NKRO_EPSIZE, NULL);
 372     }
 373     else
 374 #endif
 375     {
 376         /* Boot protocol */
 377         Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
 378
 379         /* Check if write ready for a polling interval around 10ms */
 380         while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 381         if (!Endpoint_IsReadWriteAllowed()) return;
 382
 383         /* Write Keyboard Report Data */
 384         Endpoint_Write_Stream_LE(report, KEYBOARD_EPSIZE, NULL);
 385     }
 386
 387     /* Finalize the stream transfer to send the last packet */
 388     Endpoint_ClearIN();
 389
 390     keyboard_report_sent = *report;
 391 }
 392
 393 static void send_mouse(report_mouse_t *report)
 394 {
 395 #ifdef MOUSE_ENABLE
 396     uint8_t timeout = 255;
 397
 398     if (USB_DeviceState != DEVICE_STATE_Configured)
 399         return;
 400
 401     /* Select the Mouse Report Endpoint */
 402     Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
 403
 404     /* Check if write ready for a polling interval around 10ms */
 405     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 406     if (!Endpoint_IsReadWriteAllowed()) return;
 407
 408     /* Write Mouse Report Data */
 409     Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
 410
 411     /* Finalize the stream transfer to send the last packet */
 412     Endpoint_ClearIN();
 413 #endif
 414 }
 415
 416 static void send_system(uint16_t data)
 417 {
 418     uint8_t timeout = 255;
 419
 420     if (USB_DeviceState != DEVICE_STATE_Configured)
 421         return;
 422
 423     report_extra_t r = {
 424         .report_id = REPORT_ID_SYSTEM,
 425         .usage = data
 426     };
 427     Endpoint_SelectEndpoint(EXTRAKEY_IN_EPNUM);
 428
 429     /* Check if write ready for a polling interval around 10ms */
 430     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 431     if (!Endpoint_IsReadWriteAllowed()) return;
 432
 433     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 434     Endpoint_ClearIN();
 435 }
 436
 437 static void send_consumer(uint16_t data)
 438 {
 439     uint8_t timeout = 255;
 440
 441     if (USB_DeviceState != DEVICE_STATE_Configured)
 442         return;
 443
 444     report_extra_t r = {
 445         .report_id = REPORT_ID_CONSUMER,
 446         .usage = data
 447     };
 448     Endpoint_SelectEndpoint(EXTRAKEY_IN_EPNUM);
 449
 450     /* Check if write ready for a polling interval around 10ms */
 451     while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
 452     if (!Endpoint_IsReadWriteAllowed()) return;
 453
 454     Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 455     Endpoint_ClearIN();
 456 }
 457
 458
 459 /*******************************************************************************
 460  * sendchar
 461  ******************************************************************************/
 462 #ifdef CONSOLE_ENABLE
 463 #define SEND_TIMEOUT 5
 464 int8_t sendchar(uint8_t c)
 465 {
 466     // Not wait once timeouted.
 467     // Because sendchar() is called so many times, waiting each call causes big lag.
 468     static bool timeouted = false;
 469
 470     if (USB_DeviceState != DEVICE_STATE_Configured)
 471         return -1;
 472
 473     uint8_t ep = Endpoint_GetCurrentEndpoint();
 474     Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 475     if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
 476         Endpoint_SelectEndpoint(ep);
 477         return -1;
 478     }
 479
 480     if (timeouted && !Endpoint_IsReadWriteAllowed()) {
 481         Endpoint_SelectEndpoint(ep);
 482         return - 1;
 483     }
 484
 485     timeouted = false;
 486
 487     uint8_t timeout = SEND_TIMEOUT;
 488     uint16_t prevFN = USB_Device_GetFrameNumber();
 489     while (!Endpoint_IsReadWriteAllowed()) {
 490         switch (USB_DeviceState) {
 491         case DEVICE_STATE_Unattached:
 492         case DEVICE_STATE_Suspended:
 493             return -1;
 494         }
 495         if (Endpoint_IsStalled()) {
 496             Endpoint_SelectEndpoint(ep);
 497             return -1;
 498         }
 499         if (prevFN != USB_Device_GetFrameNumber()) {
 500             if (!(timeout--)) {
 501                 timeouted = true;
 502                 Endpoint_SelectEndpoint(ep);
 503                 return -1;
 504             }
 505             prevFN = USB_Device_GetFrameNumber();
 506         }
 507     }
 508
 509     Endpoint_Write_8(c);
 510
 511     // send when bank is full
 512     if (!Endpoint_IsReadWriteAllowed())
 513         Endpoint_ClearIN();
 514
 515     Endpoint_SelectEndpoint(ep);
 516     return 0;
 517 }
 518 #else
 519 int8_t sendchar(uint8_t c)
 520 {
 521     return 0;
 522 }
 523 #endif
 524
 525
 526 /*******************************************************************************
 527  * main
 528  ******************************************************************************/
 529 static void SetupHardware(void)
 530 {
 531     /* Disable watchdog if enabled by bootloader/fuses */
 532     MCUSR &= ~(1 << WDRF);
 533     wdt_disable();
 534
 535     /* Disable clock division */
 536     clock_prescale_set(clock_div_1);
 537
 538     // Leonardo needs. Without this USB device is not recognized.
 539     USB_Disable();
 540
 541     USB_Init();
 542
 543     // for Console_Task
 544     USB_Device_EnableSOFEvents();
 545     print_set_sendchar(sendchar);
 546 }
 547
 548 int main(void)  __attribute__ ((weak));
 549 int main(void)
 550 {
 551     SetupHardware();
 552     sei();
 553
 554     /* wait for USB startup & debug output */
 555     while (USB_DeviceState != DEVICE_STATE_Configured) {
 556 #if defined(INTERRUPT_CONTROL_ENDPOINT)
 557         ;
 558 #else
 559         USB_USBTask();
 560 #endif
 561     }
 562     print("USB configured.\n");
 563
 564     /* init modules */
 565     keyboard_init();
 566     host_set_driver(&lufa_driver);
 567 #ifdef SLEEP_LED_ENABLE
 568     sleep_led_init();
 569 #endif
 570
 571     print("Keyboard start.\n");
 572     while (1) {
 573         while (USB_DeviceState == DEVICE_STATE_Suspended) {
 574             suspend_power_down();
 575             if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
 576                     USB_Device_SendRemoteWakeup();
 577             }
 578         }
 579
 580         keyboard_task();
 581
 582 #if !defined(INTERRUPT_CONTROL_ENDPOINT)
 583         USB_USBTask();
 584 #endif
 585     }
 586 }