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