tmk_core/protocol/lufa/LUFA-git/Demos/Host/LowLevel/GenericHIDHost/GenericHIDHost.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
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaims all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the GenericHIDHost demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "GenericHIDHost.h"
  38
  39 /** Main program entry point. This routine configures the hardware required by the application, then
  40  *  enters a loop to run the application tasks in sequence.
  41  */
  42 int main(void)
  43 {
  44         SetupHardware();
  45
  46         puts_P(PSTR(ESC_FG_CYAN "Generic HID Host Demo running.\r\n" ESC_FG_WHITE));
  47
  48         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  49         GlobalInterruptEnable();
  50
  51         for (;;)
  52         {
  53                 ReadNextReport();
  54
  55                 USB_USBTask();
  56         }
  57 }
  58
  59 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  60 void SetupHardware(void)
  61 {
  62 #if (ARCH == ARCH_AVR8)
  63         /* Disable watchdog if enabled by bootloader/fuses */
  64         MCUSR &= ~(1 << WDRF);
  65         wdt_disable();
  66
  67         /* Disable clock division */
  68         clock_prescale_set(clock_div_1);
  69 #endif
  70
  71         /* Hardware Initialization */
  72         Serial_Init(9600, false);
  73         LEDs_Init();
  74         USB_Init();
  75
  76         /* Create a stdio stream for the serial port for stdin and stdout */
  77         Serial_CreateStream(NULL);
  78 }
  79
  80 /** Event handler for the USB_DeviceAttached event. This indicates that a device has been attached to the host, and
  81  *  starts the library USB task to begin the enumeration and USB management process.
  82  */
  83 void EVENT_USB_Host_DeviceAttached(void)
  84 {
  85         puts_P(PSTR(ESC_FG_GREEN "Device Attached.\r\n" ESC_FG_WHITE));
  86         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  87 }
  88
  89 /** Event handler for the USB_DeviceUnattached event. This indicates that a device has been removed from the host, and
  90  *  stops the library USB task management process.
  91  */
  92 void EVENT_USB_Host_DeviceUnattached(void)
  93 {
  94         puts_P(PSTR(ESC_FG_GREEN "Device Unattached.\r\n" ESC_FG_WHITE));
  95         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  96 }
  97
  98 /** Event handler for the USB_DeviceEnumerationComplete event. This indicates that a device has been successfully
  99  *  enumerated by the host and is now ready to be used by the application.
 100  */
 101 void EVENT_USB_Host_DeviceEnumerationComplete(void)
 102 {
 103         puts_P(PSTR("Getting Config Data.\r\n"));
 104
 105         uint8_t ErrorCode;
 106
 107         /* Get and process the configuration descriptor data */
 108         if ((ErrorCode = ProcessConfigurationDescriptor()) != SuccessfulConfigRead)
 109         {
 110                 if (ErrorCode == ControlError)
 111                   puts_P(PSTR(ESC_FG_RED "Control Error (Get Configuration).\r\n"));
 112                 else
 113                   puts_P(PSTR(ESC_FG_RED "Invalid Device.\r\n"));
 114
 115                 printf_P(PSTR(" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 116
 117                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 118                 return;
 119         }
 120
 121         /* Set the device configuration to the first configuration (rarely do devices use multiple configurations) */
 122         if ((ErrorCode = USB_Host_SetDeviceConfiguration(1)) != HOST_SENDCONTROL_Successful)
 123         {
 124                 printf_P(PSTR(ESC_FG_RED "Control Error (Set Configuration).\r\n"
 125                                          " -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
 126
 127                 LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 128                 return;
 129         }
 130
 131         puts_P(PSTR("HID Device Enumerated.\r\n"));
 132         LEDs_SetAllLEDs(LEDMASK_USB_READY);
 133 }
 134
 135 /** Event handler for the USB_HostError event. This indicates that a hardware error occurred while in host mode. */
 136 void EVENT_USB_Host_HostError(const uint8_t ErrorCode)
 137 {
 138         USB_Disable();
 139
 140         printf_P(PSTR(ESC_FG_RED "Host Mode Error\r\n"
 141                                  " -- Error Code %d\r\n" ESC_FG_WHITE), ErrorCode);
 142
 143         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 144         for(;;);
 145 }
 146
 147 /** Event handler for the USB_DeviceEnumerationFailed event. This indicates that a problem occurred while
 148  *  enumerating an attached USB device.
 149  */
 150 void EVENT_USB_Host_DeviceEnumerationFailed(const uint8_t ErrorCode,
 151                                             const uint8_t SubErrorCode)
 152 {
 153         printf_P(PSTR(ESC_FG_RED "Dev Enum Error\r\n"
 154                                  " -- Error Code %d\r\n"
 155                                  " -- Sub Error Code %d\r\n"
 156                                  " -- In State %d\r\n" ESC_FG_WHITE), ErrorCode, SubErrorCode, USB_HostState);
 157
 158         LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 159 }
 160
 161 /** Reads in and processes the next report from the attached device, displaying the report
 162  *  contents on the board LEDs and via the serial port.
 163  */
 164 void ReadNextReport(void)
 165 {
 166         if (USB_HostState != HOST_STATE_Configured)
 167           return;
 168
 169         /* Select and unfreeze HID data IN pipe */
 170         Pipe_SelectPipe(HID_DATA_IN_PIPE);
 171         Pipe_Unfreeze();
 172
 173         /* Check to see if a packet has been received */
 174         if (!(Pipe_IsINReceived()))
 175         {
 176                 /* Refreeze HID data IN pipe */
 177                 Pipe_Freeze();
 178
 179                 return;
 180         }
 181
 182         /* Ensure pipe contains data before trying to read from it */
 183         if (Pipe_IsReadWriteAllowed())
 184         {
 185                 uint8_t ReportINData[Pipe_BytesInPipe()];
 186
 187                 /* Read in HID report data */
 188                 Pipe_Read_Stream_LE(&ReportINData, sizeof(ReportINData), NULL);
 189
 190                 /* Print report data through the serial port */
 191                 for (uint16_t CurrByte = 0; CurrByte < sizeof(ReportINData); CurrByte++)
 192                   printf_P(PSTR("0x%02X "), ReportINData[CurrByte]);
 193
 194                 puts_P(PSTR("\r\n"));
 195         }
 196
 197         /* Clear the IN endpoint, ready for next data packet */
 198         Pipe_ClearIN();
 199
 200         /* Refreeze HID data IN pipe */
 201         Pipe_Freeze();
 202 }
 203
 204 /** Writes a report to the attached device.
 205  *
 206  *  \param[in] ReportOUTData  Buffer containing the report to send to the device
 207  *  \param[in] ReportIndex    Index of the report in the device (zero if the device does not use multiple reports)
 208  *  \param[in] ReportType     Type of report to send, either REPORT_TYPE_OUT or REPORT_TYPE_FEATURE
 209  *  \param[in] ReportLength   Length of the report to send
 210  */
 211 void WriteNextReport(uint8_t* ReportOUTData,
 212                      const uint8_t ReportIndex,
 213                      const uint8_t ReportType,
 214                      uint16_t ReportLength)
 215 {
 216         if (USB_HostState != HOST_STATE_Configured)
 217           return;
 218
 219         /* Select the HID data OUT pipe */
 220         Pipe_SelectPipe(HID_DATA_OUT_PIPE);
 221
 222         /* Not all HID devices have an OUT endpoint (some require OUT reports to be sent over the
 223          * control endpoint instead) - check to see if the OUT endpoint has been initialized */
 224         if (Pipe_IsConfigured() && (ReportType == REPORT_TYPE_OUT))
 225         {
 226                 Pipe_Unfreeze();
 227
 228                 /* Ensure pipe is ready to be written to before continuing */
 229                 if (!(Pipe_IsOUTReady()))
 230                 {
 231                         /* Refreeze the data OUT pipe */
 232                         Pipe_Freeze();
 233
 234                         return;
 235                 }
 236
 237                 /* If the report index is used, send it before the report data */
 238                 if (ReportIndex)
 239                   Pipe_Write_8(ReportIndex);
 240
 241                 /* Write out HID report data */
 242                 Pipe_Write_Stream_LE(ReportOUTData, ReportLength, NULL);
 243
 244                 /* Clear the OUT endpoint, send last data packet */
 245                 Pipe_ClearOUT();
 246
 247                 /* Refreeze the data OUT pipe */
 248                 Pipe_Freeze();
 249         }
 250         else
 251         {
 252                 /* Class specific request to send a HID report to the device */
 253                 USB_ControlRequest = (USB_Request_Header_t)
 254                         {
 255                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 256                                 .bRequest      = HID_REQ_SetReport,
 257                                 .wValue        = ((ReportType << 8) | ReportIndex),
 258                                 .wIndex        = 0,
 259                                 .wLength       = ReportLength,
 260                         };
 261
 262                 /* Select the control pipe for the request transfer */
 263                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 264
 265                 /* Send the request to the device */
 266                 USB_Host_SendControlRequest(ReportOUTData);
 267         }
 268 }
 269