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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  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 "../../Core/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_HOST)
  35
  36 #define  __INCLUDE_FROM_AOA_DRIVER
  37 #define  __INCLUDE_FROM_ANDROIDACCESSORY_HOST_C
  38 #include "AndroidAccessoryClassHost.h"
  39
  40 bool AOA_Host_ValidateAccessoryDevice(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
  41                                       const USB_Descriptor_Device_t* const DeviceDescriptor,
  42                                       bool* const NeedModeSwitch)
  43 {
  44         (void)AOAInterfaceInfo;
  45
  46         if (DeviceDescriptor->Header.Type != DTYPE_Device)
  47           return false;
  48
  49         *NeedModeSwitch = ((DeviceDescriptor->ProductID != ANDROID_ACCESSORY_PRODUCT_ID) &&
  50                            (DeviceDescriptor->ProductID != ANDROID_ACCESSORY_ADB_PRODUCT_ID));
  51
  52         return true;
  53 }
  54
  55 uint8_t AOA_Host_ConfigurePipes(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
  56                                 uint16_t ConfigDescriptorSize,
  57                                 void* ConfigDescriptorData)
  58 {
  59         USB_Descriptor_Endpoint_t*  DataINEndpoint  = NULL;
  60         USB_Descriptor_Endpoint_t*  DataOUTEndpoint = NULL;
  61         USB_Descriptor_Interface_t* AOAInterface    = NULL;
  62
  63         memset(&AOAInterfaceInfo->State, 0x00, sizeof(AOAInterfaceInfo->State));
  64
  65         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  66           return AOA_ENUMERROR_InvalidConfigDescriptor;
  67
  68         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  69                                       DCOMP_AOA_Host_NextAndroidAccessoryInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  70         {
  71                 return AOA_ENUMERROR_NoCompatibleInterfaceFound;
  72         }
  73
  74         AOAInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
  75
  76         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  77         {
  78                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  79                                               DCOMP_AOA_Host_NextInterfaceBulkEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  80                 {
  81                         return AOA_ENUMERROR_NoCompatibleInterfaceFound;
  82                 }
  83
  84                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  85
  86                 if ((EndpointData->EndpointAddress & ENDPOINT_DIR_MASK) == ENDPOINT_DIR_IN)
  87                   DataINEndpoint  = EndpointData;
  88                 else
  89                   DataOUTEndpoint = EndpointData;
  90         }
  91
  92         for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
  93         {
  94                 uint16_t Size;
  95                 uint8_t  Type;
  96                 uint8_t  Token;
  97                 uint8_t  EndpointAddress;
  98                 bool     DoubleBanked;
  99
 100                 if (PipeNum == AOAInterfaceInfo->Config.DataINPipeNumber)
 101                 {
 102                         Size            = le16_to_cpu(DataINEndpoint->EndpointSize);
 103                         EndpointAddress = DataINEndpoint->EndpointAddress;
 104                         Token           = PIPE_TOKEN_IN;
 105                         Type            = EP_TYPE_BULK;
 106                         DoubleBanked    = AOAInterfaceInfo->Config.DataINPipeDoubleBank;
 107
 108                         AOAInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
 109                 }
 110                 else if (PipeNum == AOAInterfaceInfo->Config.DataOUTPipeNumber)
 111                 {
 112                         Size            = le16_to_cpu(DataOUTEndpoint->EndpointSize);
 113                         EndpointAddress = DataOUTEndpoint->EndpointAddress;
 114                         Token           = PIPE_TOKEN_OUT;
 115                         Type            = EP_TYPE_BULK;
 116                         DoubleBanked    = AOAInterfaceInfo->Config.DataOUTPipeDoubleBank;
 117
 118                         AOAInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
 119                 }
 120                 else
 121                 {
 122                         continue;
 123                 }
 124
 125                 if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
 126                                          DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
 127                 {
 128                         return AOA_ENUMERROR_PipeConfigurationFailed;
 129                 }
 130         }
 131
 132         AOAInterfaceInfo->State.IsActive        = true;
 133         AOAInterfaceInfo->State.InterfaceNumber = AOAInterface->InterfaceNumber;
 134
 135         return AOA_ENUMERROR_NoError;
 136 }
 137
 138 static uint8_t DCOMP_AOA_Host_NextAndroidAccessoryInterface(void* const CurrentDescriptor)
 139 {
 140         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 141
 142         if (Header->Type == DTYPE_Interface)
 143         {
 144                 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
 145
 146                 if ((Interface->Class    == AOA_CSCP_AOADataClass)    &&
 147                     (Interface->SubClass == AOA_CSCP_AOADataSubclass) &&
 148                     (Interface->Protocol == AOA_CSCP_AOADataProtocol))
 149                 {
 150                         return DESCRIPTOR_SEARCH_Found;
 151                 }
 152         }
 153
 154         return DESCRIPTOR_SEARCH_NotFound;
 155 }
 156
 157 static uint8_t DCOMP_AOA_Host_NextInterfaceBulkEndpoint(void* const CurrentDescriptor)
 158 {
 159         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 160
 161         if (Header->Type == DTYPE_Endpoint)
 162         {
 163                 USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
 164
 165                 uint8_t EndpointType = (Endpoint->Attributes & EP_TYPE_MASK);
 166
 167                 if ((EndpointType == EP_TYPE_BULK) && (!(Pipe_IsEndpointBound(Endpoint->EndpointAddress))))
 168                   return DESCRIPTOR_SEARCH_Found;
 169         }
 170         else if (Header->Type == DTYPE_Interface)
 171         {
 172                 return DESCRIPTOR_SEARCH_Fail;
 173         }
 174
 175         return DESCRIPTOR_SEARCH_NotFound;
 176 }
 177
 178 void AOA_Host_USBTask(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 179 {
 180         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 181           return;
 182
 183         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 184         AOA_Host_Flush(AOAInterfaceInfo);
 185         #endif
 186 }
 187
 188 uint8_t AOA_Host_StartAccessoryMode(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 189 {
 190         uint8_t ErrorCode;
 191
 192         uint16_t AccessoryProtocol;
 193         if ((ErrorCode = AOA_Host_GetAccessoryProtocol(&AccessoryProtocol)) != HOST_WAITERROR_Successful)
 194           return ErrorCode;
 195
 196         if (AccessoryProtocol != CPU_TO_LE16(AOA_PROTOCOL_AccessoryV1))
 197           return AOA_ERROR_LOGICAL_CMD_FAILED;
 198
 199         for (uint8_t PropertyIndex = 0; PropertyIndex < AOA_STRING_TOTAL_STRINGS; PropertyIndex++)
 200         {
 201                 if ((ErrorCode = AOA_Host_SendPropertyString(AOAInterfaceInfo, PropertyIndex)) != HOST_WAITERROR_Successful)
 202                   return ErrorCode;
 203         }
 204
 205         USB_ControlRequest = (USB_Request_Header_t)
 206         {
 207                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_VENDOR | REQREC_DEVICE),
 208                 .bRequest      = AOA_REQ_StartAccessoryMode,
 209                 .wValue        = 0,
 210                 .wIndex        = 0,
 211                 .wLength       = 0,
 212         };
 213
 214         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 215         return USB_Host_SendControlRequest(NULL);
 216 }
 217
 218 static uint8_t AOA_Host_GetAccessoryProtocol(uint16_t* const Protocol)
 219 {
 220         USB_ControlRequest = (USB_Request_Header_t)
 221         {
 222                 .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_VENDOR | REQREC_DEVICE),
 223                 .bRequest      = AOA_REQ_GetAccessoryProtocol,
 224                 .wValue        = 0,
 225                 .wIndex        = 0,
 226                 .wLength       = sizeof(uint16_t),
 227         };
 228
 229         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 230         return USB_Host_SendControlRequest(Protocol);
 231 }
 232
 233 static uint8_t AOA_Host_SendPropertyString(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 234                                            const uint8_t StringIndex)
 235 {
 236         const char* String = ((char**)&AOAInterfaceInfo->Config.PropertyStrings)[StringIndex];
 237
 238         if (String == NULL)
 239           String = "";
 240
 241         USB_ControlRequest = (USB_Request_Header_t)
 242         {
 243                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_VENDOR | REQREC_DEVICE),
 244                 .bRequest      = AOA_REQ_SendString,
 245                 .wValue        = 0,
 246                 .wIndex        = StringIndex,
 247                 .wLength       = (strlen(String) + 1),
 248         };
 249
 250         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 251         return USB_Host_SendControlRequest((char*)String);
 252 }
 253
 254 uint8_t AOA_Host_SendData(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 255                           const uint8_t* const Buffer,
 256                           const uint16_t Length)
 257 {
 258         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 259           return PIPE_READYWAIT_DeviceDisconnected;
 260
 261         uint8_t ErrorCode;
 262
 263         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
 264
 265         Pipe_Unfreeze();
 266         ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL);
 267         Pipe_Freeze();
 268
 269         return ErrorCode;
 270 }
 271
 272 uint8_t AOA_Host_SendString(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 273                             const char* const String)
 274 {
 275         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 276           return PIPE_READYWAIT_DeviceDisconnected;
 277
 278         uint8_t ErrorCode;
 279
 280         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
 281
 282         Pipe_Unfreeze();
 283         ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL);
 284         Pipe_Freeze();
 285
 286         return ErrorCode;
 287 }
 288
 289 uint8_t AOA_Host_SendByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 290                           const uint8_t Data)
 291 {
 292         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 293           return PIPE_READYWAIT_DeviceDisconnected;
 294
 295         uint8_t ErrorCode;
 296
 297         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
 298         Pipe_Unfreeze();
 299
 300         if (!(Pipe_IsReadWriteAllowed()))
 301         {
 302                 Pipe_ClearOUT();
 303
 304                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 305                   return ErrorCode;
 306         }
 307
 308         Pipe_Write_8(Data);
 309         Pipe_Freeze();
 310
 311         return PIPE_READYWAIT_NoError;
 312 }
 313
 314 uint16_t AOA_Host_BytesReceived(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 315 {
 316         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 317           return 0;
 318
 319         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);
 320         Pipe_Unfreeze();
 321
 322         if (Pipe_IsINReceived())
 323         {
 324                 if (!(Pipe_BytesInPipe()))
 325                 {
 326                         Pipe_ClearIN();
 327                         Pipe_Freeze();
 328                         return 0;
 329                 }
 330                 else
 331                 {
 332                         Pipe_Freeze();
 333                         return Pipe_BytesInPipe();
 334                 }
 335         }
 336         else
 337         {
 338                 Pipe_Freeze();
 339
 340                 return 0;
 341         }
 342 }
 343
 344 int16_t AOA_Host_ReceiveByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 345 {
 346         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 347           return -1;
 348
 349         int16_t ReceivedByte = -1;
 350
 351         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);
 352         Pipe_Unfreeze();
 353
 354         if (Pipe_IsINReceived())
 355         {
 356                 if (Pipe_BytesInPipe())
 357                   ReceivedByte = Pipe_Read_8();
 358
 359                 if (!(Pipe_BytesInPipe()))
 360                   Pipe_ClearIN();
 361         }
 362
 363         Pipe_Freeze();
 364
 365         return ReceivedByte;
 366 }
 367
 368 uint8_t AOA_Host_Flush(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
 369 {
 370         if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
 371           return PIPE_READYWAIT_DeviceDisconnected;
 372
 373         uint8_t ErrorCode;
 374
 375         Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
 376         Pipe_Unfreeze();
 377
 378         if (!(Pipe_BytesInPipe()))
 379           return PIPE_READYWAIT_NoError;
 380
 381         bool BankFull = !(Pipe_IsReadWriteAllowed());
 382
 383         Pipe_ClearOUT();
 384
 385         if (BankFull)
 386         {
 387                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 388                   return ErrorCode;
 389
 390                 Pipe_ClearOUT();
 391         }
 392
 393         Pipe_Freeze();
 394
 395         return PIPE_READYWAIT_NoError;
 396 }
 397
 398 #if defined(FDEV_SETUP_STREAM)
 399 void AOA_Host_CreateStream(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 400                            FILE* const Stream)
 401 {
 402         *Stream = (FILE)FDEV_SETUP_STREAM(AOA_Host_putchar, AOA_Host_getchar, _FDEV_SETUP_RW);
 403         fdev_set_udata(Stream, AOAInterfaceInfo);
 404 }
 405
 406 void AOA_Host_CreateBlockingStream(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
 407                                    FILE* const Stream)
 408 {
 409         *Stream = (FILE)FDEV_SETUP_STREAM(AOA_Host_putchar, AOA_Host_getchar_Blocking, _FDEV_SETUP_RW);
 410         fdev_set_udata(Stream, AOAInterfaceInfo);
 411 }
 412
 413 static int AOA_Host_putchar(char c,
 414                             FILE* Stream)
 415 {
 416         return AOA_Host_SendByte((USB_ClassInfo_AOA_Host_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 417 }
 418
 419 static int AOA_Host_getchar(FILE* Stream)
 420 {
 421         int16_t ReceivedByte = AOA_Host_ReceiveByte((USB_ClassInfo_AOA_Host_t*)fdev_get_udata(Stream));
 422
 423         if (ReceivedByte < 0)
 424           return _FDEV_EOF;
 425
 426         return ReceivedByte;
 427 }
 428
 429 static int AOA_Host_getchar_Blocking(FILE* Stream)
 430 {
 431         int16_t ReceivedByte;
 432
 433         while ((ReceivedByte = AOA_Host_ReceiveByte((USB_ClassInfo_AOA_Host_t*)fdev_get_udata(Stream))) < 0)
 434         {
 435                 if (USB_HostState == HOST_STATE_Unattached)
 436                   return _FDEV_EOF;
 437
 438                 AOA_Host_USBTask((USB_ClassInfo_AOA_Host_t*)fdev_get_udata(Stream));
 439                 USB_USBTask();
 440         }
 441
 442         return ReceivedByte;
 443 }
 444 #endif
 445
 446 #endif
 447
 448