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         USB_ControlRequest = (USB_Request_Header_t)
 293                 {
 294                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 295                         .bRequest      = REQ_MassStorageReset,
 296                         .wValue        = 0,
 297                         .wIndex        = MSInterfaceInfo->State.InterfaceNumber,
 298                         .wLength       = 0,
 299                 };
 300
 301         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 302
 303         return USB_Host_SendControlRequest(NULL);
 304 }
 305
 306 uint8_t MS_Host_GetMaxLUN(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, uint8_t* const MaxLUNIndex)
 307 {
 308         uint8_t ErrorCode;
 309
 310         USB_ControlRequest = (USB_Request_Header_t)
 311                 {
 312                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 313                         .bRequest      = REQ_GetMaxLUN,
 314                         .wValue        = 0,
 315                         .wIndex        = MSInterfaceInfo->State.InterfaceNumber,
 316                         .wLength       = 1,
 317                 };
 318
 319         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 320
 321         if ((ErrorCode = USB_Host_SendControlRequest(MaxLUNIndex)) != HOST_SENDCONTROL_Successful)
 322           *MaxLUNIndex = 0;
 323
 324         return ErrorCode;
 325 }
 326
 327 uint8_t MS_Host_GetInquiryData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 328                                SCSI_Inquiry_Response_t* const InquiryData)
 329 {
 330         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 331           return HOST_SENDCONTROL_DeviceDisconnected;
 332
 333         uint8_t ErrorCode;
 334
 335         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 336                 {
 337                         .Signature          = CBW_SIGNATURE,
 338                         .DataTransferLength = sizeof(SCSI_Inquiry_Response_t),
 339                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 340                         .LUN                = LUNIndex,
 341                         .SCSICommandLength  = 6,
 342                         .SCSICommandData    =
 343                                 {
 344                                         SCSI_CMD_INQUIRY,
 345                                         0x00,                            // Reserved
 346                                         0x00,                            // Reserved
 347                                         0x00,                            // Reserved
 348                                         sizeof(SCSI_Inquiry_Response_t), // Allocation Length
 349                                         0x00                             // Unused (control)
 350                                 }
 351                 };
 352
 353         MS_CommandStatusWrapper_t SCSICommandStatus;
 354
 355         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, InquiryData)) != PIPE_RWSTREAM_NoError)
 356           return ErrorCode;
 357
 358         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 359           return ErrorCode;
 360
 361         return PIPE_RWSTREAM_NoError;
 362 }
 363
 364 uint8_t MS_Host_TestUnitReady(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex)
 365 {
 366         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 367           return HOST_SENDCONTROL_DeviceDisconnected;
 368
 369         uint8_t ErrorCode;
 370
 371         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 372                 {
 373                         .Signature          = CBW_SIGNATURE,
 374                         .DataTransferLength = 0,
 375                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 376                         .LUN                = LUNIndex,
 377                         .SCSICommandLength  = 6,
 378                         .SCSICommandData    =
 379                                 {
 380                                         SCSI_CMD_TEST_UNIT_READY,
 381                                         0x00,                   // Reserved
 382                                         0x00,                   // Reserved
 383                                         0x00,                   // Reserved
 384                                         0x00,                   // Reserved
 385                                         0x00                    // Unused (control)
 386                                 }
 387                 };
 388
 389         MS_CommandStatusWrapper_t SCSICommandStatus;
 390
 391         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
 392           return ErrorCode;
 393
 394         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 395           return ErrorCode;
 396
 397         return PIPE_RWSTREAM_NoError;
 398 }
 399
 400 uint8_t MS_Host_ReadDeviceCapacity(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 401                                    SCSI_Capacity_t* const DeviceCapacity)
 402 {
 403         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 404           return HOST_SENDCONTROL_DeviceDisconnected;
 405
 406         uint8_t ErrorCode;
 407
 408         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 409                 {
 410                         .Signature          = CBW_SIGNATURE,
 411                         .DataTransferLength = sizeof(SCSI_Capacity_t),
 412                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 413                         .LUN                = LUNIndex,
 414                         .SCSICommandLength  = 10,
 415                         .SCSICommandData    =
 416                                 {
 417                                         SCSI_CMD_READ_CAPACITY_10,
 418                                         0x00,                   // Reserved
 419                                         0x00,                   // MSB of Logical block address
 420                                         0x00,
 421                                         0x00,
 422                                         0x00,                   // LSB of Logical block address
 423                                         0x00,                   // Reserved
 424                                         0x00,                   // Reserved
 425                                         0x00,                   // Partial Medium Indicator
 426                                         0x00                    // Unused (control)
 427                                 }
 428                 };
 429
 430         MS_CommandStatusWrapper_t SCSICommandStatus;
 431
 432         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, DeviceCapacity)) != PIPE_RWSTREAM_NoError)
 433           return ErrorCode;
 434
 435         DeviceCapacity->Blocks    = SwapEndian_32(DeviceCapacity->Blocks);
 436         DeviceCapacity->BlockSize = SwapEndian_32(DeviceCapacity->BlockSize);
 437
 438         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 439           return ErrorCode;
 440
 441         return PIPE_RWSTREAM_NoError;
 442 }
 443
 444 uint8_t MS_Host_RequestSense(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 445                              SCSI_Request_Sense_Response_t* const SenseData)
 446 {
 447         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 448           return HOST_SENDCONTROL_DeviceDisconnected;
 449
 450         uint8_t ErrorCode;
 451
 452         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 453                 {
 454                         .Signature          = CBW_SIGNATURE,
 455                         .DataTransferLength = sizeof(SCSI_Request_Sense_Response_t),
 456                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 457                         .LUN                = LUNIndex,
 458                         .SCSICommandLength  = 6,
 459                         .SCSICommandData    =
 460                                 {
 461                                         SCSI_CMD_REQUEST_SENSE,
 462                                         0x00,                                  // Reserved
 463                                         0x00,                                  // Reserved
 464                                         0x00,                                  // Reserved
 465                                         sizeof(SCSI_Request_Sense_Response_t), // Allocation Length
 466                                         0x00                                   // Unused (control)
 467                                 }
 468                 };
 469
 470         MS_CommandStatusWrapper_t SCSICommandStatus;
 471
 472         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, SenseData)) != PIPE_RWSTREAM_NoError)
 473           return ErrorCode;
 474
 475         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 476           return ErrorCode;
 477
 478         return PIPE_RWSTREAM_NoError;
 479 }
 480
 481 uint8_t MS_Host_PreventAllowMediumRemoval(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex,
 482                                           const bool PreventRemoval)
 483 {
 484         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 485           return HOST_SENDCONTROL_DeviceDisconnected;
 486
 487         uint8_t ErrorCode;
 488
 489         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 490                 {
 491                         .Signature          = CBW_SIGNATURE,
 492                         .DataTransferLength = 0,
 493                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 494                         .LUN                = LUNIndex,
 495                         .SCSICommandLength  = 6,
 496                         .SCSICommandData    =
 497                                 {
 498                                         SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL,
 499                                         0x00,                   // Reserved
 500                                         0x00,                   // Reserved
 501                                         PreventRemoval,         // Prevent flag
 502                                         0x00,                   // Reserved
 503                                         0x00                    // Unused (control)
 504                                 }
 505                 };
 506
 507         MS_CommandStatusWrapper_t SCSICommandStatus;
 508
 509         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
 510           return ErrorCode;
 511
 512         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 513           return ErrorCode;
 514
 515         return PIPE_RWSTREAM_NoError;
 516 }
 517
 518 uint8_t MS_Host_ReadDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress,
 519                                  const uint8_t Blocks, const uint16_t BlockSize, void* BlockBuffer)
 520 {
 521         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 522           return HOST_SENDCONTROL_DeviceDisconnected;
 523
 524         uint8_t ErrorCode;
 525
 526         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 527                 {
 528                         .Signature          = CBW_SIGNATURE,
 529                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 530                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 531                         .LUN                = LUNIndex,
 532                         .SCSICommandLength  = 10,
 533                         .SCSICommandData    =
 534                                 {
 535                                         SCSI_CMD_READ_10,
 536                                         0x00,                   // Unused (control bits, all off)
 537                                         (BlockAddress >> 24),   // MSB of Block Address
 538                                         (BlockAddress >> 16),
 539                                         (BlockAddress >> 8),
 540                                         (BlockAddress & 0xFF),  // LSB of Block Address
 541                                         0x00,                   // Unused (reserved)
 542                                         0x00,                   // MSB of Total Blocks to Read
 543                                         Blocks,                 // LSB of Total Blocks to Read
 544                                         0x00                    // Unused (control)
 545                                 }
 546                 };
 547
 548         MS_CommandStatusWrapper_t SCSICommandStatus;
 549
 550         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, BlockBuffer)) != PIPE_RWSTREAM_NoError)
 551           return ErrorCode;
 552
 553         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 554           return ErrorCode;
 555
 556         return PIPE_RWSTREAM_NoError;
 557 }
 558
 559 uint8_t MS_Host_WriteDeviceBlocks(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo, const uint8_t LUNIndex, const uint32_t BlockAddress,
 560                                   const uint8_t Blocks, const uint16_t BlockSize, void* BlockBuffer)
 561 {
 562         if ((USB_HostState != HOST_STATE_Configured) || !(MSInterfaceInfo->State.IsActive))
 563           return HOST_SENDCONTROL_DeviceDisconnected;
 564
 565         uint8_t ErrorCode;
 566
 567         MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
 568                 {
 569                         .Signature          = CBW_SIGNATURE,
 570                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 571                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 572                         .LUN                = LUNIndex,
 573                         .SCSICommandLength  = 10,
 574                         .SCSICommandData    =
 575                                 {
 576                                         SCSI_CMD_WRITE_10,
 577                                         0x00,                   // Unused (control bits, all off)
 578                                         (BlockAddress >> 24),   // MSB of Block Address
 579                                         (BlockAddress >> 16),
 580                                         (BlockAddress >> 8),
 581                                         (BlockAddress & 0xFF),  // LSB of Block Address
 582                                         0x00,                   // Unused (reserved)
 583                                         0x00,                   // MSB of Total Blocks to Write
 584                                         Blocks,                 // LSB of Total Blocks to Write
 585                                         0x00                    // Unused (control)
 586                                 }
 587                 };
 588
 589         MS_CommandStatusWrapper_t SCSICommandStatus;
 590
 591         if ((ErrorCode = MS_Host_SendCommand(MSInterfaceInfo, &SCSICommandBlock, BlockBuffer)) != PIPE_RWSTREAM_NoError)
 592           return ErrorCode;
 593
 594         if ((ErrorCode = MS_Host_GetReturnedStatus(MSInterfaceInfo, &SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
 595           return ErrorCode;
 596
 597         return PIPE_RWSTREAM_NoError;
 598 }
 599
 600 #endif