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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2018.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2018  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 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "../../Core/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_HOST)
  35
  36 #define  __INCLUDE_FROM_HID_DRIVER
  37 #define  __INCLUDE_FROM_HID_HOST_C
  38 #include "HIDClassHost.h"
  39
  40 uint8_t HID_Host_ConfigurePipes(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
  41                                 uint16_t ConfigDescriptorSize,
  42                                 void* ConfigDescriptorData)
  43 {
  44         USB_Descriptor_Endpoint_t*  DataINEndpoint  = NULL;
  45         USB_Descriptor_Endpoint_t*  DataOUTEndpoint = NULL;
  46         USB_Descriptor_Interface_t* HIDInterface    = NULL;
  47         USB_HID_Descriptor_HID_t*   HIDDescriptor   = NULL;
  48
  49         memset(&HIDInterfaceInfo->State, 0x00, sizeof(HIDInterfaceInfo->State));
  50
  51         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  52           return HID_ENUMERROR_InvalidConfigDescriptor;
  53
  54         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  55         {
  56                 if (!(HIDInterface) ||
  57                     USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  58                                               DCOMP_HID_Host_NextHIDInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  59                 {
  60                         if (DataINEndpoint)
  61                           break;
  62
  63                         do
  64                         {
  65                                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  66                                                               DCOMP_HID_Host_NextHIDInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  67                                 {
  68                                         return HID_ENUMERROR_NoCompatibleInterfaceFound;
  69                                 }
  70
  71                                 HIDInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
  72                         } while (HIDInterfaceInfo->Config.HIDInterfaceProtocol &&
  73                                          (HIDInterface->Protocol != HIDInterfaceInfo->Config.HIDInterfaceProtocol));
  74
  75                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  76                                                       DCOMP_HID_Host_NextHIDDescriptor) != DESCRIPTOR_SEARCH_COMP_Found)
  77                         {
  78                                 return HID_ENUMERROR_NoCompatibleInterfaceFound;
  79                         }
  80
  81                         HIDDescriptor = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_HID_Descriptor_HID_t);
  82
  83                         DataINEndpoint  = NULL;
  84                         DataOUTEndpoint = NULL;
  85
  86                         continue;
  87                 }
  88
  89                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  90
  91                 if ((EndpointData->EndpointAddress & ENDPOINT_DIR_MASK) == ENDPOINT_DIR_IN)
  92                   DataINEndpoint  = EndpointData;
  93                 else
  94                   DataOUTEndpoint = EndpointData;
  95         }
  96
  97         HIDInterfaceInfo->Config.DataINPipe.Size  = le16_to_cpu(DataINEndpoint->EndpointSize);
  98         HIDInterfaceInfo->Config.DataINPipe.EndpointAddress = DataINEndpoint->EndpointAddress;
  99         HIDInterfaceInfo->Config.DataINPipe.Type  = EP_TYPE_INTERRUPT;
 100
 101         if (!(Pipe_ConfigurePipeTable(&HIDInterfaceInfo->Config.DataINPipe, 1)))
 102           return HID_ENUMERROR_PipeConfigurationFailed;
 103
 104         if (DataOUTEndpoint)
 105         {
 106                 HIDInterfaceInfo->Config.DataOUTPipe.Size = le16_to_cpu(DataOUTEndpoint->EndpointSize);
 107                 HIDInterfaceInfo->Config.DataOUTPipe.EndpointAddress = DataOUTEndpoint->EndpointAddress;
 108                 HIDInterfaceInfo->Config.DataOUTPipe.Type = EP_TYPE_INTERRUPT;
 109
 110                 if (!(Pipe_ConfigurePipeTable(&HIDInterfaceInfo->Config.DataOUTPipe, 1)))
 111                   return HID_ENUMERROR_PipeConfigurationFailed;
 112         }
 113
 114         HIDInterfaceInfo->State.InterfaceNumber      = HIDInterface->InterfaceNumber;
 115         HIDInterfaceInfo->State.HIDReportSize        = LE16_TO_CPU(HIDDescriptor->HIDReportLength);
 116         HIDInterfaceInfo->State.DeviceUsesOUTPipe    = DataOUTEndpoint;
 117         HIDInterfaceInfo->State.SupportsBootProtocol = (HIDInterface->SubClass != HID_CSCP_NonBootProtocol);
 118         HIDInterfaceInfo->State.LargestReportSize    = 8;
 119         HIDInterfaceInfo->State.IsActive             = true;
 120
 121         return HID_ENUMERROR_NoError;
 122 }
 123
 124 static uint8_t DCOMP_HID_Host_NextHIDInterface(void* const CurrentDescriptor)
 125 {
 126         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 127
 128         if (Header->Type == DTYPE_Interface)
 129         {
 130                 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
 131
 132                 if (Interface->Class == HID_CSCP_HIDClass)
 133                   return DESCRIPTOR_SEARCH_Found;
 134         }
 135
 136         return DESCRIPTOR_SEARCH_NotFound;
 137 }
 138
 139 static uint8_t DCOMP_HID_Host_NextHIDDescriptor(void* const CurrentDescriptor)
 140 {
 141         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 142
 143         if (Header->Type == HID_DTYPE_HID)
 144           return DESCRIPTOR_SEARCH_Found;
 145         else if (Header->Type == DTYPE_Interface)
 146           return DESCRIPTOR_SEARCH_Fail;
 147         else
 148           return DESCRIPTOR_SEARCH_NotFound;
 149 }
 150
 151 static uint8_t DCOMP_HID_Host_NextHIDInterfaceEndpoint(void* const CurrentDescriptor)
 152 {
 153         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 154
 155         if (Header->Type == DTYPE_Endpoint)
 156         {
 157                 USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
 158
 159                 if (!(Pipe_IsEndpointBound(Endpoint->EndpointAddress)))
 160                   return DESCRIPTOR_SEARCH_Found;
 161         }
 162         else if (Header->Type == DTYPE_Interface)
 163         {
 164                 return DESCRIPTOR_SEARCH_Fail;
 165         }
 166
 167         return DESCRIPTOR_SEARCH_NotFound;
 168 }
 169
 170 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 171 uint8_t HID_Host_ReceiveReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 172                                    const uint8_t ReportID,
 173                                    void* Buffer)
 174 {
 175         USB_ControlRequest = (USB_Request_Header_t)
 176         {
 177                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 178                 .bRequest      = HID_REQ_SetReport,
 179                 .wValue        = ((HID_REPORT_ITEM_In + 1) << 8) | ReportID,
 180                 .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 181                 .wLength       = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, ReportID, HID_REPORT_ITEM_In),
 182         };
 183
 184         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 185
 186         return USB_Host_SendControlRequest(Buffer);
 187 }
 188 #endif
 189
 190 uint8_t HID_Host_ReceiveReport(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 191                                void* Buffer)
 192 {
 193         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 194           return PIPE_READYWAIT_DeviceDisconnected;
 195
 196         uint8_t ErrorCode;
 197
 198         Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipe.Address);
 199         Pipe_Unfreeze();
 200
 201         uint16_t ReportSize;
 202         uint8_t* BufferPos = Buffer;
 203
 204 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 205         if (!(HIDInterfaceInfo->State.UsingBootProtocol))
 206         {
 207                 uint8_t ReportID = 0;
 208
 209                 if (HIDInterfaceInfo->Config.HIDParserData->UsingReportIDs)
 210                 {
 211                         ReportID = Pipe_Read_8();
 212                         *(BufferPos++) = ReportID;
 213                 }
 214
 215                 ReportSize = USB_GetHIDReportSize(HIDInterfaceInfo->Config.HIDParserData, ReportID, HID_REPORT_ITEM_In);
 216         }
 217         else
 218 #endif
 219         {
 220                 ReportSize = Pipe_BytesInPipe();
 221         }
 222
 223         if ((ErrorCode = Pipe_Read_Stream_LE(BufferPos, ReportSize, NULL)) != PIPE_RWSTREAM_NoError)
 224           return ErrorCode;
 225
 226         Pipe_ClearIN();
 227         Pipe_Freeze();
 228
 229         return PIPE_RWSTREAM_NoError;
 230 }
 231
 232 uint8_t HID_Host_SendReportByID(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 233 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 234                                 const uint8_t ReportID,
 235 #endif
 236                                 const uint8_t ReportType,
 237                                 void* Buffer,
 238                                 const uint16_t ReportSize)
 239 {
 240 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 241         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 242           return PIPE_RWSTREAM_NoError;
 243
 244         if (HIDInterfaceInfo->State.DeviceUsesOUTPipe && (ReportType == HID_REPORT_ITEM_Out))
 245         {
 246                 uint8_t ErrorCode;
 247
 248                 Pipe_SelectPipe(HIDInterfaceInfo->Config.DataOUTPipe.Address);
 249                 Pipe_Unfreeze();
 250
 251                 if (ReportID)
 252                   Pipe_Write_Stream_LE(&ReportID, sizeof(ReportID), NULL);
 253
 254                 if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, ReportSize, NULL)) != PIPE_RWSTREAM_NoError)
 255                   return ErrorCode;
 256
 257                 Pipe_ClearOUT();
 258                 Pipe_Freeze();
 259
 260                 return PIPE_RWSTREAM_NoError;
 261         }
 262         else
 263 #endif
 264         {
 265                 USB_ControlRequest = (USB_Request_Header_t)
 266                 {
 267                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 268                         .bRequest      = HID_REQ_SetReport,
 269 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 270                         .wValue        = ((ReportType + 1) << 8) | ReportID,
 271 #else
 272                         .wValue        = ((ReportType + 1) << 8),
 273 #endif
 274                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 275                         .wLength       = ReportSize,
 276                 };
 277
 278                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 279
 280                 return USB_Host_SendControlRequest(Buffer);
 281         }
 282 }
 283
 284 bool HID_Host_IsReportReceived(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 285 {
 286         if ((USB_HostState != HOST_STATE_Configured) || !(HIDInterfaceInfo->State.IsActive))
 287           return false;
 288
 289         bool ReportReceived;
 290
 291         Pipe_SelectPipe(HIDInterfaceInfo->Config.DataINPipe.Address);
 292         Pipe_Unfreeze();
 293
 294         ReportReceived = Pipe_IsINReceived();
 295
 296         Pipe_Freeze();
 297
 298         return ReportReceived;
 299 }
 300
 301 uint8_t HID_Host_SetBootProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 302 {
 303         uint8_t ErrorCode;
 304
 305         if (!(HIDInterfaceInfo->State.SupportsBootProtocol))
 306           return HID_ERROR_LOGICAL;
 307
 308         USB_ControlRequest = (USB_Request_Header_t)
 309                 {
 310                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 311                         .bRequest      = HID_REQ_SetProtocol,
 312                         .wValue        = 0,
 313                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 314                         .wLength       = 0,
 315                 };
 316
 317         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 318
 319         if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 320           return ErrorCode;
 321
 322         HIDInterfaceInfo->State.LargestReportSize = 8;
 323         HIDInterfaceInfo->State.UsingBootProtocol = true;
 324
 325         return HOST_SENDCONTROL_Successful;
 326 }
 327
 328 uint8_t HID_Host_SetIdlePeriod(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo,
 329                                const uint16_t MS)
 330 {
 331         USB_ControlRequest = (USB_Request_Header_t)
 332                 {
 333                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 334                         .bRequest      = HID_REQ_SetIdle,
 335                         .wValue        = ((MS << 6) & 0xFF00),
 336                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 337                         .wLength       = 0,
 338                 };
 339
 340         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 341
 342         return USB_Host_SendControlRequest(NULL);
 343 }
 344
 345 #if !defined(HID_HOST_BOOT_PROTOCOL_ONLY)
 346 uint8_t HID_Host_SetReportProtocol(USB_ClassInfo_HID_Host_t* const HIDInterfaceInfo)
 347 {
 348         uint8_t ErrorCode;
 349
 350         uint8_t HIDReportData[HIDInterfaceInfo->State.HIDReportSize];
 351
 352         USB_ControlRequest = (USB_Request_Header_t)
 353                 {
 354                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
 355                         .bRequest      = REQ_GetDescriptor,
 356                         .wValue        = (HID_DTYPE_Report << 8),
 357                         .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 358                         .wLength       = HIDInterfaceInfo->State.HIDReportSize,
 359                 };
 360
 361         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 362
 363         if ((ErrorCode = USB_Host_SendControlRequest(HIDReportData)) != HOST_SENDCONTROL_Successful)
 364           return ErrorCode;
 365
 366         if (HIDInterfaceInfo->State.UsingBootProtocol)
 367         {
 368                 USB_ControlRequest = (USB_Request_Header_t)
 369                         {
 370                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 371                                 .bRequest      = HID_REQ_SetProtocol,
 372                                 .wValue        = 1,
 373                                 .wIndex        = HIDInterfaceInfo->State.InterfaceNumber,
 374                                 .wLength       = 0,
 375                         };
 376
 377                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 378                   return ErrorCode;
 379
 380                 HIDInterfaceInfo->State.UsingBootProtocol = false;
 381         }
 382
 383         if (HIDInterfaceInfo->Config.HIDParserData == NULL)
 384           return HID_ERROR_LOGICAL;
 385
 386         if ((ErrorCode = USB_ProcessHIDReport(HIDReportData, HIDInterfaceInfo->State.HIDReportSize,
 387                                               HIDInterfaceInfo->Config.HIDParserData)) != HID_PARSE_Successful)
 388         {
 389                 return HID_ERROR_LOGICAL | ErrorCode;
 390         }
 391
 392         uint16_t LargestReportSizeBits = HIDInterfaceInfo->Config.HIDParserData->LargestReportSizeBits;
 393         HIDInterfaceInfo->State.LargestReportSize = (LargestReportSizeBits >> 3) + ((LargestReportSizeBits & 0x07) != 0);
 394
 395         return 0;
 396 }
 397 #endif
 398
 399 #endif
 400