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