tmk_core/protocol/lufa/LUFA-git/Demos/Device/LowLevel/Keyboard/Keyboard.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2014.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2014  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11   Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
  12
  13   Permission to use, copy, modify, distribute, and sell this
  14   software and its documentation for any purpose is hereby granted
  15   without fee, provided that the above copyright notice appear in
  16   all copies and that both that the copyright notice and this
  17   permission notice and warranty disclaimer appear in supporting
  18   documentation, and that the name of the author not be used in
  19   advertising or publicity pertaining to distribution of the
  20   software without specific, written prior permission.
  21
  22   The author disclaims all warranties with regard to this
  23   software, including all implied warranties of merchantability
  24   and fitness.  In no event shall the author be liable for any
  25   special, indirect or consequential damages or any damages
  26   whatsoever resulting from loss of use, data or profits, whether
  27   in an action of contract, negligence or other tortious action,
  28   arising out of or in connection with the use or performance of
  29   this software.
  30 */
  31
  32 /** \file
  33  *
  34  *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
  35  *  is responsible for the initial application hardware configuration.
  36  */
  37
  38 #include "Keyboard.h"
  39
  40 /** Indicates what report mode the host has requested, true for normal HID reporting mode, \c false for special boot
  41  *  protocol reporting mode.
  42  */
  43 static bool UsingReportProtocol = true;
  44
  45 /** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
  46  *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
  47  */
  48 static uint16_t IdleCount = 500;
  49
  50 /** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
  51  *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
  52  *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
  53  */
  54 static uint16_t IdleMSRemaining = 0;
  55
  56
  57 /** Main program entry point. This routine configures the hardware required by the application, then
  58  *  enters a loop to run the application tasks in sequence.
  59  */
  60 int main(void)
  61 {
  62         SetupHardware();
  63
  64         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  65         GlobalInterruptEnable();
  66
  67         for (;;)
  68         {
  69                 HID_Task();
  70                 USB_USBTask();
  71         }
  72 }
  73
  74 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  75 void SetupHardware(void)
  76 {
  77 #if (ARCH == ARCH_AVR8)
  78         /* Disable watchdog if enabled by bootloader/fuses */
  79         MCUSR &= ~(1 << WDRF);
  80         wdt_disable();
  81
  82         /* Disable clock division */
  83         clock_prescale_set(clock_div_1);
  84 #elif (ARCH == ARCH_XMEGA)
  85         /* Start the PLL to multiply the 2MHz RC oscillator to 32MHz and switch the CPU core to run from it */
  86         XMEGACLK_StartPLL(CLOCK_SRC_INT_RC2MHZ, 2000000, F_CPU);
  87         XMEGACLK_SetCPUClockSource(CLOCK_SRC_PLL);
  88
  89         /* Start the 32MHz internal RC oscillator and start the DFLL to increase it to 48MHz using the USB SOF as a reference */
  90         XMEGACLK_StartInternalOscillator(CLOCK_SRC_INT_RC32MHZ);
  91         XMEGACLK_StartDFLL(CLOCK_SRC_INT_RC32MHZ, DFLL_REF_INT_USBSOF, F_USB);
  92
  93         PMIC.CTRL = PMIC_LOLVLEN_bm | PMIC_MEDLVLEN_bm | PMIC_HILVLEN_bm;
  94 #endif
  95
  96         /* Hardware Initialization */
  97         Joystick_Init();
  98         LEDs_Init();
  99         USB_Init();
 100         Buttons_Init();
 101 }
 102
 103 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
 104  *  starts the library USB task to begin the enumeration and USB management process.
 105  */
 106 void EVENT_USB_Device_Connect(void)
 107 {
 108         /* Indicate USB enumerating */
 109         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 110
 111         /* Default to report protocol on connect */
 112         UsingReportProtocol = true;
 113 }
 114
 115 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 116  *  the status LEDs.
 117  */
 118 void EVENT_USB_Device_Disconnect(void)
 119 {
 120         /* Indicate USB not ready */
 121         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 122 }
 123
 124 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
 125  *  of the USB device after enumeration, and configures the keyboard device endpoints.
 126  */
 127 void EVENT_USB_Device_ConfigurationChanged(void)
 128 {
 129         bool ConfigSuccess = true;
 130
 131         /* Setup HID Report Endpoints */
 132         ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
 133         ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPADDR, EP_TYPE_INTERRUPT, KEYBOARD_EPSIZE, 1);
 134
 135         /* Turn on Start-of-Frame events for tracking HID report period expiry */
 136         USB_Device_EnableSOFEvents();
 137
 138         /* Indicate endpoint configuration success or failure */
 139         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 140 }
 141
 142 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 143  *  the device from the USB host before passing along unhandled control requests to the library for processing
 144  *  internally.
 145  */
 146 void EVENT_USB_Device_ControlRequest(void)
 147 {
 148         /* Handle HID Class specific requests */
 149         switch (USB_ControlRequest.bRequest)
 150         {
 151                 case HID_REQ_GetReport:
 152                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 153                         {
 154                                 USB_KeyboardReport_Data_t KeyboardReportData;
 155
 156                                 /* Create the next keyboard report for transmission to the host */
 157                                 CreateKeyboardReport(&KeyboardReportData);
 158
 159                                 Endpoint_ClearSETUP();
 160
 161                                 /* Write the report data to the control endpoint */
 162                                 Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 163                                 Endpoint_ClearOUT();
 164                         }
 165
 166                         break;
 167                 case HID_REQ_SetReport:
 168                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 169                         {
 170                                 Endpoint_ClearSETUP();
 171
 172                                 /* Wait until the LED report has been sent by the host */
 173                                 while (!(Endpoint_IsOUTReceived()))
 174                                 {
 175                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 176                                           return;
 177                                 }
 178
 179                                 /* Read in the LED report from the host */
 180                                 uint8_t LEDStatus = Endpoint_Read_8();
 181
 182                                 Endpoint_ClearOUT();
 183                                 Endpoint_ClearStatusStage();
 184
 185                                 /* Process the incoming LED report */
 186                                 ProcessLEDReport(LEDStatus);
 187                         }
 188
 189                         break;
 190                 case HID_REQ_GetProtocol:
 191                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 192                         {
 193                                 Endpoint_ClearSETUP();
 194
 195                                 /* Write the current protocol flag to the host */
 196                                 Endpoint_Write_8(UsingReportProtocol);
 197
 198                                 Endpoint_ClearIN();
 199                                 Endpoint_ClearStatusStage();
 200                         }
 201
 202                         break;
 203                 case HID_REQ_SetProtocol:
 204                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 205                         {
 206                                 Endpoint_ClearSETUP();
 207                                 Endpoint_ClearStatusStage();
 208
 209                                 /* Set or clear the flag depending on what the host indicates that the current Protocol should be */
 210                                 UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 211                         }
 212
 213                         break;
 214                 case HID_REQ_SetIdle:
 215                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 216                         {
 217                                 Endpoint_ClearSETUP();
 218                                 Endpoint_ClearStatusStage();
 219
 220                                 /* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
 221                                 IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
 222                         }
 223
 224                         break;
 225                 case HID_REQ_GetIdle:
 226                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 227                         {
 228                                 Endpoint_ClearSETUP();
 229
 230                                 /* Write the current idle duration to the host, must be divided by 4 before sent to host */
 231                                 Endpoint_Write_8(IdleCount >> 2);
 232
 233                                 Endpoint_ClearIN();
 234                                 Endpoint_ClearStatusStage();
 235                         }
 236
 237                         break;
 238         }
 239 }
 240
 241 /** Event handler for the USB device Start Of Frame event. */
 242 void EVENT_USB_Device_StartOfFrame(void)
 243 {
 244         /* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
 245         if (IdleMSRemaining)
 246           IdleMSRemaining--;
 247 }
 248
 249 /** Fills the given HID report data structure with the next HID report to send to the host.
 250  *
 251  *  \param[out] ReportData  Pointer to a HID report data structure to be filled
 252  */
 253 void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
 254 {
 255         uint8_t JoyStatus_LCL     = Joystick_GetStatus();
 256         uint8_t ButtonStatus_LCL  = Buttons_GetStatus();
 257
 258         uint8_t UsedKeyCodes      = 0;
 259
 260         /* Clear the report contents */
 261         memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
 262
 263         /* Make sent key uppercase by indicating that the left shift key is pressed */
 264         ReportData->Modifier = HID_KEYBOARD_MODIFIER_LEFTSHIFT;
 265
 266         if (JoyStatus_LCL & JOY_UP)
 267           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_A;
 268         else if (JoyStatus_LCL & JOY_DOWN)
 269           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_B;
 270
 271         if (JoyStatus_LCL & JOY_LEFT)
 272           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_C;
 273         else if (JoyStatus_LCL & JOY_RIGHT)
 274           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_D;
 275
 276         if (JoyStatus_LCL & JOY_PRESS)
 277           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_E;
 278
 279         if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 280           ReportData->KeyCode[UsedKeyCodes++] = HID_KEYBOARD_SC_F;
 281 }
 282
 283 /** Processes a received LED report, and updates the board LEDs states to match.
 284  *
 285  *  \param[in] LEDReport  LED status report from the host
 286  */
 287 void ProcessLEDReport(const uint8_t LEDReport)
 288 {
 289         uint8_t LEDMask = LEDS_LED2;
 290
 291         if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
 292           LEDMask |= LEDS_LED1;
 293
 294         if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
 295           LEDMask |= LEDS_LED3;
 296
 297         if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
 298           LEDMask |= LEDS_LED4;
 299
 300         /* Set the status LEDs to the current Keyboard LED status */
 301         LEDs_SetAllLEDs(LEDMask);
 302 }
 303
 304 /** Sends the next HID report to the host, via the keyboard data endpoint. */
 305 void SendNextReport(void)
 306 {
 307         static USB_KeyboardReport_Data_t PrevKeyboardReportData;
 308         USB_KeyboardReport_Data_t        KeyboardReportData;
 309         bool                             SendReport = false;
 310
 311         /* Create the next keyboard report for transmission to the host */
 312         CreateKeyboardReport(&KeyboardReportData);
 313
 314         /* Check if the idle period is set and has elapsed */
 315         if (IdleCount && (!(IdleMSRemaining)))
 316         {
 317                 /* Reset the idle time remaining counter */
 318                 IdleMSRemaining = IdleCount;
 319
 320                 /* Idle period is set and has elapsed, must send a report to the host */
 321                 SendReport = true;
 322         }
 323         else
 324         {
 325                 /* Check to see if the report data has changed - if so a report MUST be sent */
 326                 SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
 327         }
 328
 329         /* Select the Keyboard Report Endpoint */
 330         Endpoint_SelectEndpoint(KEYBOARD_IN_EPADDR);
 331
 332         /* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
 333         if (Endpoint_IsReadWriteAllowed() && SendReport)
 334         {
 335                 /* Save the current report data for later comparison to check for changes */
 336                 PrevKeyboardReportData = KeyboardReportData;
 337
 338                 /* Write Keyboard Report Data */
 339                 Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
 340
 341                 /* Finalize the stream transfer to send the last packet */
 342                 Endpoint_ClearIN();
 343         }
 344 }
 345
 346 /** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
 347 void ReceiveNextReport(void)
 348 {
 349         /* Select the Keyboard LED Report Endpoint */
 350         Endpoint_SelectEndpoint(KEYBOARD_OUT_EPADDR);
 351
 352         /* Check if Keyboard LED Endpoint contains a packet */
 353         if (Endpoint_IsOUTReceived())
 354         {
 355                 /* Check to see if the packet contains data */
 356                 if (Endpoint_IsReadWriteAllowed())
 357                 {
 358                         /* Read in the LED report from the host */
 359                         uint8_t LEDReport = Endpoint_Read_8();
 360
 361                         /* Process the read LED report from the host */
 362                         ProcessLEDReport(LEDReport);
 363                 }
 364
 365                 /* Handshake the OUT Endpoint - clear endpoint and ready for next report */
 366                 Endpoint_ClearOUT();
 367         }
 368 }
 369
 370 /** Function to manage HID report generation and transmission to the host, when in report mode. */
 371 void HID_Task(void)
 372 {
 373         /* Device must be connected and configured for the task to run */
 374         if (USB_DeviceState != DEVICE_STATE_Configured)
 375           return;
 376
 377         /* Send the next keypress report to the host */
 378         SendNextReport();
 379
 380         /* Process the LED report sent from the host */
 381         ReceiveNextReport();
 382 }
 383