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