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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  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_SI_CLASS_HOST_C
  35 #include "StillImage.h"
  36
  37 uint8_t SImage_Host_ConfigurePipes(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                    void* DeviceConfigDescriptor)
  39 {
  40         uint8_t  FoundEndpoints = 0;
  41
  42         memset(&SIInterfaceInfo->State, 0x00, sizeof(SIInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
  45           return SI_ENUMERROR_InvalidConfigDescriptor;
  46
  47         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  48                                       DComp_SI_Host_NextSIInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  49         {
  50                 return SI_ENUMERROR_NoSIInterfaceFound;
  51         }
  52
  53         while (FoundEndpoints != (SI_FOUND_EVENTS_IN | SI_FOUND_DATAPIPE_IN | SI_FOUND_DATAPIPE_OUT))
  54         {
  55                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  56                                               DComp_SI_Host_NextSIInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  57                 {
  58                         return SI_ENUMERROR_EndpointsNotFound;
  59                 }
  60
  61                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
  62
  63                 if ((EndpointData->Attributes & EP_TYPE_MASK) == EP_TYPE_INTERRUPT)
  64                 {
  65                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  66                         {
  67                                 Pipe_ConfigurePipe(SIInterfaceInfo->Config.EventsPipeNumber, EP_TYPE_INTERRUPT, PIPE_TOKEN_IN,
  68                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
  69                                                                    SIInterfaceInfo->Config.EventsPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  70                                 SIInterfaceInfo->State.EventsPipeSize = EndpointData->EndpointSize;
  71
  72                                 Pipe_SetInterruptPeriod(EndpointData->PollingIntervalMS);
  73
  74                                 FoundEndpoints |= SI_FOUND_EVENTS_IN;
  75                         }
  76                 }
  77                 else
  78                 {
  79                         if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  80                         {
  81                                 Pipe_ConfigurePipe(SIInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
  82                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
  83                                                                    SIInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  84                                 SIInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
  85
  86                                 FoundEndpoints |= SI_FOUND_DATAPIPE_IN;
  87                         }
  88                         else
  89                         {
  90                                 Pipe_ConfigurePipe(SIInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
  91                                                                    EndpointData->EndpointAddress, EndpointData->EndpointSize,
  92                                                                    SIInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  93                                 SIInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
  94
  95                                 FoundEndpoints |= SI_FOUND_DATAPIPE_OUT;
  96                         }
  97                 }
  98         }
  99
 100         SIInterfaceInfo->State.IsActive = true;
 101         return SI_ENUMERROR_NoError;
 102 }
 103
 104 uint8_t DComp_SI_Host_NextSIInterface(void* const CurrentDescriptor)
 105 {
 106         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 107         {
 108                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 109                                                                                 USB_Descriptor_Interface_t);
 110
 111                 if ((CurrentInterface->Class    == STILL_IMAGE_CLASS)    &&
 112                     (CurrentInterface->SubClass == STILL_IMAGE_SUBCLASS) &&
 113                     (CurrentInterface->Protocol == STILL_IMAGE_PROTOCOL))
 114                 {
 115                         return DESCRIPTOR_SEARCH_Found;
 116                 }
 117         }
 118
 119         return DESCRIPTOR_SEARCH_NotFound;
 120 }
 121
 122 uint8_t DComp_SI_Host_NextSIInterfaceEndpoint(void* const CurrentDescriptor)
 123 {
 124         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 125         {
 126                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 127                                                                               USB_Descriptor_Endpoint_t);
 128
 129                 uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
 130
 131                 if (((EndpointType == EP_TYPE_BULK) || (EndpointType == EP_TYPE_INTERRUPT)) &&
 132                     (!(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress))))
 133                 {
 134                         return DESCRIPTOR_SEARCH_Found;
 135                 }
 136         }
 137         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 138         {
 139                 return DESCRIPTOR_SEARCH_Fail;
 140         }
 141
 142         return DESCRIPTOR_SEARCH_NotFound;
 143 }
 144
 145 void SImage_Host_USBTask(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 146 {
 147         (void)SIInterfaceInfo;
 148 }
 149
 150 uint8_t SImage_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader)
 151 {
 152         uint8_t ErrorCode;
 153
 154         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 155           return PIPE_RWSTREAM_DeviceDisconnected;
 156
 157         PIMAHeader->TransactionID = SIInterfaceInfo->State.TransactionID++;
 158
 159         Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
 160         Pipe_Unfreeze();
 161
 162         if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 163           return ErrorCode;
 164
 165         uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 166
 167         if (ParamBytes)
 168         {
 169                 if ((ErrorCode = Pipe_Write_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 170                   return ErrorCode;
 171         }
 172
 173         Pipe_ClearOUT();
 174         Pipe_Freeze();
 175
 176         return PIPE_RWSTREAM_NoError;
 177 }
 178
 179 uint8_t SImage_Host_ReceiveBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader)
 180 {
 181         uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
 182
 183         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 184           return PIPE_RWSTREAM_DeviceDisconnected;
 185
 186         Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
 187         Pipe_Unfreeze();
 188
 189         while (!(Pipe_IsReadWriteAllowed()))
 190         {
 191                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 192                 {
 193                         USB_INT_Clear(USB_INT_HSOFI);
 194                         TimeoutMSRem--;
 195
 196                         if (!(TimeoutMSRem))
 197                         {
 198                                 return PIPE_RWSTREAM_Timeout;
 199                         }
 200                 }
 201
 202                 Pipe_Freeze();
 203                 Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
 204                 Pipe_Unfreeze();
 205
 206                 if (Pipe_IsStalled())
 207                 {
 208                         USB_Host_ClearPipeStall(SIInterfaceInfo->Config.DataOUTPipeNumber);
 209                         return PIPE_RWSTREAM_PipeStalled;
 210                 }
 211
 212                 Pipe_Freeze();
 213                 Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
 214                 Pipe_Unfreeze();
 215
 216                 if (Pipe_IsStalled())
 217                 {
 218                         USB_Host_ClearPipeStall(SIInterfaceInfo->Config.DataINPipeNumber);
 219                         return PIPE_RWSTREAM_PipeStalled;
 220                 }
 221
 222                 if (USB_HostState == HOST_STATE_Unattached)
 223                   return PIPE_RWSTREAM_DeviceDisconnected;
 224         }
 225
 226         Pipe_Read_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK);
 227
 228         if (PIMAHeader->Type == CType_ResponseBlock)
 229         {
 230                 uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
 231
 232                 if (ParamBytes)
 233                   Pipe_Read_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK);
 234
 235                 Pipe_ClearIN();
 236         }
 237
 238         Pipe_Freeze();
 239
 240         return PIPE_RWSTREAM_NoError;
 241 }
 242
 243 uint8_t SImage_Host_SendData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, const uint16_t Bytes)
 244 {
 245         uint8_t ErrorCode;
 246
 247         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 248           return PIPE_RWSTREAM_DeviceDisconnected;
 249
 250         Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
 251         Pipe_Unfreeze();
 252
 253         ErrorCode = Pipe_Write_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
 254
 255         Pipe_ClearOUT();
 256         Pipe_Freeze();
 257
 258         return ErrorCode;
 259 }
 260
 261 uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, const uint16_t Bytes)
 262 {
 263         uint8_t ErrorCode;
 264
 265         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 266           return PIPE_RWSTREAM_DeviceDisconnected;
 267
 268         Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
 269         Pipe_Unfreeze();
 270
 271         ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
 272
 273         Pipe_Freeze();
 274
 275         return ErrorCode;
 276 }
 277
 278 bool SImage_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* SIInterfaceInfo)
 279 {
 280         bool IsEventReceived = false;
 281
 282         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 283           return false;
 284
 285         Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
 286         Pipe_Unfreeze();
 287
 288         if (Pipe_BytesInPipe())
 289           IsEventReceived = true;
 290
 291         Pipe_Freeze();
 292
 293         return IsEventReceived;
 294 }
 295
 296 uint8_t SImage_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader)
 297 {
 298         uint8_t ErrorCode;
 299
 300         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 301           return PIPE_RWSTREAM_DeviceDisconnected;
 302
 303         Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
 304         Pipe_Unfreeze();
 305
 306         ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(SI_PIMA_Container_t), NO_STREAM_CALLBACK);
 307
 308         Pipe_ClearIN();
 309         Pipe_Freeze();
 310
 311         return ErrorCode;
 312 }
 313
 314 uint8_t SImage_Host_OpenSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 315 {
 316         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 317           return HOST_SENDCONTROL_DeviceDisconnected;
 318
 319         uint8_t ErrorCode;
 320
 321         SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
 322                                                         {
 323                                                                 .DataLength    = PIMA_COMMAND_SIZE(0),
 324                                                                 .Type          = CType_CommandBlock,
 325                                                                 .Code          = 0x1002,
 326                                                                 .Params        = {},
 327                                                         };
 328
 329         if ((ErrorCode = SImage_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 330           return ErrorCode;
 331
 332         if ((ErrorCode = SImage_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 333           return ErrorCode;
 334
 335         if ((PIMABlock.Type != CType_ResponseBlock) || (PIMABlock.Code != 0x2001))
 336           return SI_ERROR_LOGICAL_CMD_FAILED;
 337
 338         SIInterfaceInfo->State.TransactionID = 0;
 339         SIInterfaceInfo->State.IsSessionOpen = true;
 340
 341         return PIPE_RWSTREAM_NoError;
 342 }
 343
 344 uint8_t SImage_Host_CloseSession(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 345 {
 346         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 347           return HOST_SENDCONTROL_DeviceDisconnected;
 348
 349         uint8_t ErrorCode;
 350
 351         SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
 352                                                         {
 353                                                                 .DataLength    = PIMA_COMMAND_SIZE(0),
 354                                                                 .Type          = CType_CommandBlock,
 355                                                                 .Code          = 0x1003,
 356                                                                 .Params        = {},
 357                                                         };
 358
 359         if ((ErrorCode = SImage_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 360           return ErrorCode;
 361
 362         if ((ErrorCode = SImage_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 363           return ErrorCode;
 364
 365         SIInterfaceInfo->State.IsSessionOpen = false;
 366
 367         if ((PIMABlock.Type != CType_ResponseBlock) || (PIMABlock.Code != 0x2001))
 368           return SI_ERROR_LOGICAL_CMD_FAILED;
 369
 370         return PIPE_RWSTREAM_NoError;
 371 }
 372
 373 uint8_t SImage_Host_SendCommand(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, const uint16_t Operation,
 374                                 const uint8_t TotalParams, uint32_t* Params)
 375 {
 376         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 377           return HOST_SENDCONTROL_DeviceDisconnected;
 378
 379         uint8_t ErrorCode;
 380
 381         SI_PIMA_Container_t PIMABlock = (SI_PIMA_Container_t)
 382                                                         {
 383                                                                 .DataLength    = PIMA_COMMAND_SIZE(TotalParams),
 384                                                                 .Type          = CType_CommandBlock,
 385                                                                 .Code          = Operation,
 386                                                         };
 387
 388         memcpy(&PIMABlock.Params, Params, sizeof(uint32_t) * TotalParams);
 389
 390         if ((ErrorCode = SImage_Host_SendBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 391           return ErrorCode;
 392
 393         return PIPE_RWSTREAM_NoError;
 394 }
 395
 396 uint8_t SImage_Host_ReceiveResponse(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
 397 {
 398         uint8_t ErrorCode;
 399         SI_PIMA_Container_t PIMABlock;
 400
 401         if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
 402           return HOST_SENDCONTROL_DeviceDisconnected;
 403
 404         if ((ErrorCode = SImage_Host_ReceiveBlockHeader(SIInterfaceInfo, &PIMABlock)) != PIPE_RWSTREAM_NoError)
 405           return ErrorCode;
 406
 407         if ((PIMABlock.Type != CType_ResponseBlock) || (PIMABlock.Code != 0x2001))
 408           return SI_ERROR_LOGICAL_CMD_FAILED;
 409
 410         return PIPE_RWSTREAM_NoError;
 411 }
 412
 413 #endif