LUFA/Drivers/USB/Class/Host/MassStorage.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, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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_MS_CLASS_HOST_C
  35 #include "MassStorage.h"
  36
  37 uint8_t MS_Host_ConfigurePipes(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                                            void* DeviceConfigDescriptor)
  39 {
  40         uint8_t FoundEndpoints = 0;
  41
  42         memset(&MSInterfaceInfo->State, 0x00, sizeof(MSInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
  45           return MS_ENUMERROR_InvalidConfigDescriptor;
  46
  47         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  48                                       DComp_NextMSInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  49         {
  50                 return MS_ENUMERROR_NoMSInterfaceFound;
  51         }
  52
  53         MSInterfaceInfo->State.InterfaceNumber = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Interface_t)->InterfaceNumber;
  54
  55         while (FoundEndpoints != (MS_FOUND_DATAPIPE_IN | MS_FOUND_DATAPIPE_OUT))
  56         {
  57                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  58                                               DComp_NextMSInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  59                 {
  60                         return MS_ENUMERROR_EndpointsNotFound;
  61                 }
  62
  63                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
  64
  65                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  66                 {
  67                         Pipe_ConfigurePipe(MSInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
  68                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  69                                            MSInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  70                         MSInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
  71
  72                         FoundEndpoints |= MS_FOUND_DATAPIPE_IN;
  73                 }
  74                 else
  75                 {
  76                         Pipe_ConfigurePipe(MSInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
  77                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  78                                            MSInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  79                         MSInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
  80
  81                         FoundEndpoints |= MS_FOUND_DATAPIPE_OUT;
  82                 }
  83         }
  84
  85         MSInterfaceInfo->State.IsActive = true;
  86         return MS_ENUMERROR_NoError;
  87 }
  88
  89 static uint8_t DComp_NextMSInterface(void* const CurrentDescriptor)
  90 {
  91         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
  92         {
  93                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
  94                                                                                 USB_Descriptor_Interface_t);
  95
  96                 if ((CurrentInterface->Class    == MASS_STORE_CLASS)    &&
  97                     (CurrentInterface->SubClass == MASS_STORE_SUBCLASS) &&
  98                     (CurrentInterface->Protocol == MASS_STORE_PROTOCOL))
  99                 {
 100                         return DESCRIPTOR_SEARCH_Found;
 101                 }
 102         }
 103
 104         return DESCRIPTOR_SEARCH_NotFound;
 105 }
 106
 107 static uint8_t DComp_NextMSInterfaceEndpoint(void* const CurrentDescriptor)
 108 {
 109         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 110         {
 111                 USB_Descriptor_Endpoint_t* CurrentEndpoint = DESCRIPTOR_PCAST(CurrentDescriptor,
 112                                                                               USB_Descriptor_Endpoint_t);
 113
 114                 uint8_t EndpointType = (CurrentEndpoint->Attributes & EP_TYPE_MASK);
 115
 116                 if ((EndpointType == EP_TYPE_BULK) &&
 117                     (!(Pipe_IsEndpointBound(CurrentEndpoint->EndpointAddress))))
 118                 {
 119                         return DESCRIPTOR_SEARCH_Found;
 120                 }
 121         }
 122         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 123         {
 124                 return DESCRIPTOR_SEARCH_Fail;
 125         }
 126
 127         return DESCRIPTOR_SEARCH_NotFound;
 128 }
 129
 130 void MS_Host_USBTask(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
 131 {
 132
 133 }
 134
 135 static uint8_t MS_Host_SendCommand(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, MS_CommandBlockWrapper_t* const SCSICommandBlock,
 136                                    void* BufferPtr)
 137 {
 138         uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 139
 140         SCSICommandBlock->Tag = ++MSInterfaceInfo->State.TransactionTag;
 141
 142         if (MSInterfaceInfo->State.TransactionTag == 0xFFFFFFFF)
 143           MSInterfaceInfo->State.TransactionTag = 1;
 144
 145         Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
 146         Pipe_Unfreeze();
 147
 148         if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(MS_CommandBlockWrapper_t),
 149                                               NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 150           return ErrorCode;
 151
 152         Pipe_ClearOUT();
 153         Pipe_WaitUntilReady();
 154
 155         Pipe_Freeze();
 156
 157         if ((BufferPtr != NULL) &&
 158             ((ErrorCode = MS_Host_SendReceiveData(MSInterfaceInfo, SCSICommandBlock, BufferPtr)) != PIPE_RWSTREAM_NoError))
 159         {
 160                 Pipe_Freeze();
 161                 return ErrorCode;
 162         }
 163
 164         return ErrorCode;
 165 }
 166
 167 static uint8_t MS_Host_WaitForDataReceived(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
 168 {
 169         uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
 170
 171         Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
 172         Pipe_Unfreeze();
 173
 174         while (!(Pipe_IsINReceived()))
 175         {
 176                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 177                 {
 178                         USB_INT_Clear(USB_INT_HSOFI);
 179                         TimeoutMSRem--;
 180
 181                         if (!(TimeoutMSRem))
 182                           return PIPE_RWSTREAM_Timeout;
 183                 }
 184
 185                 Pipe_Freeze();
 186                 Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
 187                 Pipe_Unfreeze();
 188
 189                 if (Pipe_IsStalled())
 190                 {
 191                         USB_Host_ClearPipeStall(MSInterfaceInfo->Config.DataOUTPipeNumber);
 192
 193                         return PIPE_RWSTREAM_PipeStalled;
 194                 }
 195
 196                 Pipe_Freeze();
 197                 Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
 198                 Pipe_Unfreeze();
 199
 200                 if (Pipe_IsStalled())
 201                 {
 202                         USB_Host_ClearPipeStall(MSInterfaceInfo->Config.DataINPipeNumber);
 203
 204                         return PIPE_RWSTREAM_PipeStalled;
 205                 }
 206
 207                 if (USB_HostState == HOST_STATE_Unattached)
 208                   return PIPE_RWSTREAM_DeviceDisconnected;
 209         };
 210
 211         Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
 212         Pipe_Freeze();
 213
 214         Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
 215         Pipe_Freeze();
 216
 217         return PIPE_RWSTREAM_NoError;
 218 }
 219
 220 static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
 221                                        MS_CommandBlockWrapper_t* const SCSICommandBlock, void* BufferPtr)
 222 {
 223         uint8_t  ErrorCode = PIPE_RWSTREAM_NoError;
 224         uint16_t BytesRem  = SCSICommandBlock->DataTransferLength;
 225
 226         if (SCSICommandBlock->Flags & COMMAND_DIRECTION_DATA_IN)
 227         {
 228                 if ((ErrorCode = MS_Host_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)
 229                 {
 230                         Pipe_Freeze();
 231                         return ErrorCode;
 232                 }
 233
 234                 Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
 235                 Pipe_Unfreeze();
 236
 237                 if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 238                   return ErrorCode;
 239
 240                 Pipe_ClearIN();
 241         }
 242         else
 243         {
 244                 Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
 245                 Pipe_Unfreeze();
 246
 247                 if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 248                   return ErrorCode;
 249
 250                 Pipe_ClearOUT();
 251
 252                 while (!(Pipe_IsOUTReady()))
 253                 {
 254                         if (USB_HostState == HOST_STATE_Unattached)
 255                           return PIPE_RWSTREAM_DeviceDisconnected;
 256                 }
 257         }
 258
 259         Pipe_Freeze();
 260
 261         return ErrorCode;
 262 }
 263
 264 static uint8_t MS_Host_GetReturnedStatus(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
 265                                          MS_CommandStatusWrapper_t* const SCSICommandStatus)
 266 {
 267         uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 268
 269         if ((ErrorCode = MS_Host_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)
 270           return ErrorCode;
 271
 272         Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
 273         Pipe_Unfreeze();
 274
 275         if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(MS_CommandStatusWrapper_t),
 276                                              NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 277         {
 278                 return ErrorCode;
 279         }
 280
 281         Pipe_ClearIN();
 282         Pipe_Freeze();
 283
 284         if (SCSICommandStatus->Status != SCSI_Command_Pass)
 285           ErrorCode = MS_ERROR_LOGICAL_CMD_FAILED;
 286
 287         return ErrorCode;
 288 }
 289
 290 uint8_t MS_Host_ResetMSInterface(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo)
 291 {
 292         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 293           return HOST_SENDCONTROL_DeviceDisconnect;
 294
 295         USB_ControlRequest = (USB_Request_Header_t)
 296                 {
 297                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 298                         .bRequest      = REQ_MassStorageReset,
 299                         .wValue        = 0,
 300                         .wIndex        = MSInterfaceInfo->State.InterfaceNumber,
 301                         .wLength       = 0,
 302                 };
 303
 304         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 305
 306         return USB_Host_SendControlRequest(NULL);
 307 }
 308
 309 uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint8_t* const MaxLUNIndex)
 310 {
 311         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 312           return HOST_SENDCONTROL_DeviceDisconnect;
 313
 314         uint8_t ErrorCode;
 315
 316         USB_ControlRequest = (USB_Request_Header_t)
 317                 {
 318                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 319                         .bRequest      = REQ_GetMaxLUN,
 320                         .wValue        = 0,
 321                         .wIndex        = MSInterfaceInfo->State.InterfaceNumber,
 322                         .wLength       = 1,
 323                 };
 324
 325         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 326
 327         if ((ErrorCode = USB_Host_SendControlRequest(MaxLUNIndex)) != HOST_SENDCONTROL_Successful)
 328           *MaxLUNIndex = 0;
 329
 330         return ErrorCode;
 331 }
 332
 333 uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 334                                SCSI_Inquiry_Response_t* const InquiryData)
 335 {
 336         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 337           return HOST_SENDCONTROL_DeviceDisconnect;
 338
 339         uint8_t ErrorCode;
 340
 341         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 342                 {
 343                         .Signature          = CBW_SIGNATURE,
 344                         .DataTransferLength = sizeof(SCSI_Inquiry_Response_t),
 345                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 346                         .LUN                = LUNIndex,
 347                         .SCSICommandLength  = 6,
 348                         .SCSICommandData    =
 349                                 {
 350                                         SCSI_CMD_INQUIRY,
 351                                         0x00,                            // Reserved
 352                                         0x00,                            // Reserved
 353                                         0x00,                            // Reserved
 354                                         sizeof(SCSI_Inquiry_Response_t), // Allocation Length
 355                                         0x00                             // Unused (control)
 356                                 }
 357                 };
 358
 359         MS_CommandStatusWrapper_t SCSICommandStatus;
 360
 361         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, InquiryData)) != PIPE_RWSTREAM_NoError)
 362           return ErrorCode;
 363
 364         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 365           return ErrorCode;
 366
 367         return PIPE_RWSTREAM_NoError;
 368 }
 369
 370 uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex)
 371 {
 372         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 373           return HOST_SENDCONTROL_DeviceDisconnect;
 374
 375         uint8_t ErrorCode;
 376
 377         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 378                 {
 379                         .Signature          = CBW_SIGNATURE,
 380                         .DataTransferLength = 0,
 381                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 382                         .LUN                = LUNIndex,
 383                         .SCSICommandLength  = 6,
 384                         .SCSICommandData    =
 385                                 {
 386                                         SCSI_CMD_TEST_UNIT_READY,
 387                                         0x00,                   // Reserved
 388                                         0x00,                   // Reserved
 389                                         0x00,                   // Reserved
 390                                         0x00,                   // Reserved
 391                                         0x00                    // Unused (control)
 392                                 }
 393                 };
 394
 395         MS_CommandStatusWrapper_t SCSICommandStatus;
 396
 397         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
 398           return ErrorCode;
 399
 400         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 401           return ErrorCode;
 402
 403         return PIPE_RWSTREAM_NoError;
 404 }
 405
 406 uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 407                                    SCSI_Capacity_t* const DeviceCapacity)
 408 {
 409         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 410           return HOST_SENDCONTROL_DeviceDisconnect;
 411
 412         uint8_t ErrorCode;
 413
 414         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 415                 {
 416                         .Signature          = CBW_SIGNATURE,
 417                         .DataTransferLength = sizeof(SCSI_Capacity_t),
 418                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 419                         .LUN                = LUNIndex,
 420                         .SCSICommandLength  = 10,
 421                         .SCSICommandData    =
 422                                 {
 423                                         SCSI_CMD_READ_CAPACITY_10,
 424                                         0x00,                   // Reserved
 425                                         0x00,                   // MSB of Logical block address
 426                                         0x00,
 427                                         0x00,
 428                                         0x00,                   // LSB of Logical block address
 429                                         0x00,                   // Reserved
 430                                         0x00,                   // Reserved
 431                                         0x00,                   // Partial Medium Indicator
 432                                         0x00                    // Unused (control)
 433                                 }
 434                 };
 435
 436         MS_CommandStatusWrapper_t SCSICommandStatus;
 437
 438         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, DeviceCapacity)) != PIPE_RWSTREAM_NoError)
 439           return ErrorCode;
 440
 441         DeviceCapacity->Blocks    = SwapEndian_32(DeviceCapacity->Blocks);
 442         DeviceCapacity->BlockSize = SwapEndian_32(DeviceCapacity->BlockSize);
 443
 444         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 445           return ErrorCode;
 446
 447         return PIPE_RWSTREAM_NoError;
 448 }
 449
 450 uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 451                              SCSI_Request_Sense_Response_t* const SenseData)
 452 {
 453         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 454           return HOST_SENDCONTROL_DeviceDisconnect;
 455
 456         uint8_t ErrorCode;
 457
 458         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 459                 {
 460                         .Signature          = CBW_SIGNATURE,
 461                         .DataTransferLength = sizeof(SCSI_Request_Sense_Response_t),
 462                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 463                         .LUN                = LUNIndex,
 464                         .SCSICommandLength  = 6,
 465                         .SCSICommandData    =
 466                                 {
 467                                         SCSI_CMD_REQUEST_SENSE,
 468                                         0x00,                                  // Reserved
 469                                         0x00,                                  // Reserved
 470                                         0x00,                                  // Reserved
 471                                         sizeof(SCSI_Request_Sense_Response_t), // Allocation Length
 472                                         0x00                                   // Unused (control)
 473                                 }
 474                 };
 475
 476         MS_CommandStatusWrapper_t SCSICommandStatus;
 477
 478         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, SenseData)) != PIPE_RWSTREAM_NoError)
 479           return ErrorCode;
 480
 481         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 482           return ErrorCode;
 483
 484         return PIPE_RWSTREAM_NoError;
 485 }
 486
 487 uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 488                                           const bool PreventRemoval)
 489 {
 490         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 491           return HOST_SENDCONTROL_DeviceDisconnect;
 492
 493         uint8_t ErrorCode;
 494
 495         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 496                 {
 497                         .Signature          = CBW_SIGNATURE,
 498                         .DataTransferLength = 0,
 499                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 500                         .LUN                = LUNIndex,
 501                         .SCSICommandLength  = 6,
 502                         .SCSICommandData    =
 503                                 {
 504                                         SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL,
 505                                         0x00,                   // Reserved
 506                                         0x00,                   // Reserved
 507                                         PreventRemoval,         // Prevent flag
 508                                         0x00,                   // Reserved
 509                                         0x00                    // Unused (control)
 510                                 }
 511                 };
 512
 513         MS_CommandStatusWrapper_t SCSICommandStatus;
 514
 515         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
 516           return ErrorCode;
 517
 518         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 519           return ErrorCode;
 520
 521         return PIPE_RWSTREAM_NoError;
 522 }
 523
 524 uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress,
 525                                  const uint8_t Blocks, const uint16_t BlockSize, void* BlockBuffer)
 526 {
 527         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 528           return HOST_SENDCONTROL_DeviceDisconnect;
 529
 530         uint8_t ErrorCode;
 531
 532         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 533                 {
 534                         .Signature          = CBW_SIGNATURE,
 535                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 536                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 537                         .LUN                = LUNIndex,
 538                         .SCSICommandLength  = 10,
 539                         .SCSICommandData    =
 540                                 {
 541                                         SCSI_CMD_READ_10,
 542                                         0x00,                   // Unused (control bits, all off)
 543                                         (BlockAddress >> 24),   // MSB of Block Address
 544                                         (BlockAddress >> 16),
 545                                         (BlockAddress >> 8),
 546                                         (BlockAddress & 0xFF),  // LSB of Block Address
 547                                         0x00,                   // Unused (reserved)
 548                                         0x00,                   // MSB of Total Blocks to Read
 549                                         Blocks,                 // LSB of Total Blocks to Read
 550                                         0x00                    // Unused (control)
 551                                 }
 552                 };
 553
 554         MS_CommandStatusWrapper_t SCSICommandStatus;
 555
 556         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, BlockBuffer)) != PIPE_RWSTREAM_NoError)
 557           return ErrorCode;
 558
 559         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 560           return ErrorCode;
 561
 562         return PIPE_RWSTREAM_NoError;
 563 }
 564
 565 uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress,
 566                                   const uint8_t Blocks, const uint16_t BlockSize, void* BlockBuffer)
 567 {
 568         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 569           return HOST_SENDCONTROL_DeviceDisconnect;
 570
 571         uint8_t ErrorCode;
 572
 573         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 574                 {
 575                         .Signature          = CBW_SIGNATURE,
 576                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 577                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 578                         .LUN                = LUNIndex,
 579                         .SCSICommandLength  = 10,
 580                         .SCSICommandData    =
 581                                 {
 582                                         SCSI_CMD_WRITE_10,
 583                                         0x00,                   // Unused (control bits, all off)
 584                                         (BlockAddress >> 24),   // MSB of Block Address
 585                                         (BlockAddress >> 16),
 586                                         (BlockAddress >> 8),
 587                                         (BlockAddress & 0xFF),  // LSB of Block Address
 588                                         0x00,                   // Unused (reserved)
 589                                         0x00,                   // MSB of Total Blocks to Write
 590                                         Blocks,                 // LSB of Total Blocks to Write
 591                                         0x00                    // Unused (control)
 592                                 }
 593                 };
 594
 595         MS_CommandStatusWrapper_t SCSICommandStatus;
 596
 597         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, BlockBuffer)) != PIPE_RWSTREAM_NoError)
 598           return ErrorCode;
 599
 600         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 601           return ErrorCode;
 602
 603         return PIPE_RWSTREAM_NoError;
 604 }
 605
 606 #endif