LUFA/Drivers/USB/Class/Host/HID.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 disclaim 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 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_HOST)
  33
  34 #define INCLUDE_FROM_HID_CLASS_HOST_C
  35 #include "HID.h"
  36
  37 uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                 void* ConfigDescriptorData)
  39 {
  40         uint8_t FoundEndpoints = 0;
  41
  42         memset(&HIDInterfaceInfo->State, 0x00, sizeof(HIDInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  45           return HID_ENUMERROR_InvalidConfigDescriptor;
  46
  47         USB_Descriptor_Interface_t* CurrentHIDInterface;
  48
  49         do
  50         {
  51                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  52                                                                           DComp_HID_Host_NextHIDInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  53                 {
  54                         return HID_ENUMERROR_NoHIDInterfaceFound;
  55                 }
  56
  57                 CurrentHIDInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
  58         } while (HIDInterfaceInfo->Config.HIDInterfaceProtocol &&
  59                  (CurrentHIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
  60
  61         HIDInterfaceInfo->State.InterfaceNumber      = CurrentHIDInterface->InterfaceNumber;
  62         HIDInterfaceInfo->State.SupportsBootProtocol = (CurrentHIDInterface->SubClass != HID_NON_BOOT_PROTOCOL);
  63
  64         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData, DComp_NextHID) != DESCRIPTOR_SEARCH_COMP_Found)
  65         {
  66                 return HID_ENUMERROR_NoHIDDescriptorFound;
  67         }
  68
  69         HIDInterfaceInfo->State.HIDReportSize = DESCRIPTOR_CAST(ConfigDescriptorData, USB_HID_Descriptor_t).HIDReportLength;
  70
  71         while (FoundEndpoints != (HID_FOUND_DATAPIPE_IN | HID_FOUND_DATAPIPE_OUT))
  72         {
  73                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  74                                               DComp_HID_Host_NextHIDInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  75                 {
  76                         if (FoundEndpoints & HID_FOUND_DATAPIPE_IN)
  77                           break;
  78
  79                         return HID_ENUMERROR_EndpointsNotFound;
  80                 }
  81
  82                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  83
  84                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  85                 {
  86                         Pipe_ConfigurePipe(HIDInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
  87                                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  88                                                            HIDInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  89                         HIDInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
  90
  91                         FoundEndpoints |= HID_FOUND_DATAPIPE_IN;
  92                 }
  93                 else
  94                 {
  95                         Pipe_ConfigurePipe(HIDInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_OUT,
  96                                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  97                                                            HIDInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  98                         HIDInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
  99
 100                         HIDInterfaceInfo->State.DeviceUsesOUTPipe = true;
 101
 102                         FoundEndpoints |= HID_FOUND_DATAPIPE_OUT;
 103                 }
 104         }
 105
 106         HIDInterfaceInfo->State.LargestReportSize = 8;
 107         HIDInterfaceInfo->State.IsActive = true;
 108         return HID_ENUMERROR_NoError;
 109 }
 110
 111 static uint8_t DComp_HID_Host_NextHIDInterface(void* const CurrentDescriptor)
 112 {
 113         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 114         {
 115                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 116                                                                                 USB_Descriptor_Interface_t);
 117
 118                 if (CurrentInterface->Class == HID_INTERFACE_CLASS)
 119                   return DESCRIPTOR_SEARCH_Found;
 120         }
 121
 122         return DESCRIPTOR_SEARCH_NotFound;
 123 }
 124
 125 static uint8_t DComp_NextHID(void* const CurrentDescriptor)
 126 {
 127         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_HID)
 128           return DESCRIPTOR_SEARCH_Found;
 129         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 130           return DESCRIPTOR_SEARCH_Fail;
 131         else
 132           return DESCRIPTOR_SEARCH_NotFound;
 133 }
 134
 135 static uint8_t DComp_HID_Host_NextHIDInterfaceEndpoint(void* const CurrentDescriptor)
 136 {
 137         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 138         {
 139                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 140                                                                               USB_Descriptor_Endpoint_t);
 141
 142                 if (!(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress)))
 143                   return DESCRIPTOR_SEARCH_Found;
 144         }
 145         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 146         {
 147                 return DESCRIPTOR_SEARCH_Fail;
 148         }
 149
 150         return DESCRIPTOR_SEARCH_NotFound;
 151 }
 152
 153 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 154 uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, const uint8_t ReportID, void* Buffer)
 155 {
 156         USB_ControlRequest = (USB_Request_Header_t)
 157         {
 158                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 159                 .bRequest      = REQ_SetReport,
 160                 .wValue        = (REPORT_ITEM_TYPE_In << 8) | ReportID,
 161                 .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 162                 .wLength       = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, ReportID, REPORT_ITEM_TYPE_In),
 163         };
 164
 165         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 166
 167         return USB_Host_SendControlRequest(Buffer);
 168 }
 169 #endif
 170
 171 uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo, void* Buffer)
 172 {
 173         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 174           return PIPE_READYWAIT_DeviceDisconnected;
 175
 176         uint8_t ErrorCode;
 177
 178         Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
 179         Pipe_Unfreeze();
 180
 181         uint16_t ReportSize;
 182
 183 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 184         if (!(HIDInterfaceInfo->State.UsingBootProtocol))
 185         {
 186                 uint8_t ReportID = 0;
 187
 188                 if (HIDInterfaceInfo->Config.HIDParserData->UsingReportIDs)
 189                 {
 190                         ReportID = Pipe_Read_Byte();
 191                         *((uint8_t*)Buffer++) = ReportID;
 192                 }
 193
 194                 ReportSize = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, ReportID, REPORT_ITEM_TYPE_In);
 195         }
 196         else
 197 #endif
 198         {
 199                 ReportSize = Pipe_BytesInPipe();
 200         }
 201
 202         if ((ErrorCode = Pipe_Read_Stream_LE(Buffer, ReportSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 203           return ErrorCode;
 204
 205         Pipe_ClearIN();
 206         Pipe_Freeze();
 207
 208         return PIPE_RWSTREAM_NoError;
 209 }
 210
 211 uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 212 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 213                                 const uint8_t ReportID,
 214 #endif
 215                                 void* Buffer, const uint16_t ReportSize)
 216 {
 217 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 218         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 219           return false;
 220
 221         if (HIDInterfaceInfo->State.DeviceUsesOUTPipe)
 222         {
 223                 uint8_t ErrorCode;
 224
 225                 Pipe_SelectPipe(HIDInterfaceInfo->Config.DataOUTPipeNumber);
 226                 Pipe_Unfreeze();
 227
 228                 if (ReportID)
 229                   Pipe_Write_Stream_LE(&ReportID, sizeof(ReportID), NO_STREAM_CALLBACK);
 230
 231                 if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, ReportSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 232                   return ErrorCode;
 233
 234                 Pipe_ClearOUT();
 235                 Pipe_Freeze();
 236
 237                 return PIPE_RWSTREAM_NoError;
 238         }
 239         else
 240 #endif
 241         {
 242                 USB_ControlRequest = (USB_Request_Header_t)
 243                 {
 244                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 245                         .bRequest      = REQ_SetReport,
 246 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 247                         .wValue        = (REPORT_ITEM_TYPE_Out << 8) | ReportID,
 248 #else
 249                         .wValue        = 0,
 250 #endif
 251                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 252                         .wLength       = ReportSize,
 253                 };
 254
 255                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 256
 257                 return USB_Host_SendControlRequest(Buffer);
 258         }
 259 }
 260
 261 bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 262 {
 263         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 264           return false;
 265
 266         bool ReportReceived;
 267
 268         Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipeNumber);
 269         Pipe_Unfreeze();
 270
 271         ReportReceived = Pipe_IsINReceived();
 272
 273         Pipe_Freeze();
 274
 275         return ReportReceived;
 276 }
 277
 278 uint8_t HID_Host_SetBootProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 279 {
 280         uint8_t ErrorCode;
 281
 282         USB_ControlRequest = (USB_Request_Header_t)
 283                 {
 284                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 285                         .bRequest      = REQ_SetProtocol,
 286                         .wValue        = 0,
 287                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 288                         .wLength       = 0,
 289                 };
 290
 291         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 292
 293         if (!(HIDInterfaceInfo->State.SupportsBootProtocol))
 294           return HID_ERROR_LOGICAL;
 295
 296         if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 297           return ErrorCode;
 298
 299         HIDInterfaceInfo->State.LargestReportSize = 8;
 300         HIDInterfaceInfo->State.UsingBootProtocol = true;
 301
 302         return HOST_SENDCONTROL_Successful;
 303 }
 304
 305 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 306 uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 307 {
 308         uint8_t ErrorCode;
 309
 310         uint8_t HIDReportData[HIDInterfaceInfo->State.HIDReportSize];
 311
 312         USB_ControlRequest = (USB_Request_Header_t)
 313                 {
 314                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
 315                         .bRequest      = REQ_GetDescriptor,
 316                         .wValue        = (DTYPE_Report << 8),
 317                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 318                         .wLength       = HIDInterfaceInfo->State.HIDReportSize,
 319                 };
 320
 321         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 322
 323         if ((ErrorCode = USB_Host_SendControlRequest(HIDReportData)) != HOST_SENDCONTROL_Successful)
 324           return ErrorCode;
 325
 326         if (HIDInterfaceInfo->State.UsingBootProtocol)
 327         {
 328                 USB_ControlRequest = (USB_Request_Header_t)
 329                         {
 330                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 331                                 .bRequest      = REQ_SetProtocol,
 332                                 .wValue        = 1,
 333                                 .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 334                                 .wLength       = 0,
 335                         };
 336
 337                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 338                   return ErrorCode;
 339
 340                 HIDInterfaceInfo->State.UsingBootProtocol = false;
 341         }
 342
 343         if (HIDInterfaceInfo->Config.HIDParserData == NULL)
 344           return HID_ERROR_LOGICAL;
 345
 346         if ((ErrorCode = USB_ProcessHIDReport(HIDReportData, HIDInterfaceInfo->State.HIDReportSize,
 347                                               HIDInterfaceInfo->Config.HIDParserData)) != HID_PARSE_Successful)
 348         {
 349                 return HID_ERROR_LOGICAL | ErrorCode;
 350         }
 351
 352         uint8_t LargestReportSizeBits = HIDInterfaceInfo->Config.HIDParserData->LargestReportSizeBits;
 353         HIDInterfaceInfo->State.LargestReportSize = (LargestReportSizeBits >> 3) + ((LargestReportSizeBits & 0x07) != 0);
 354
 355         return 0;
 356 }
 357 #endif
 358
 359 #endif