Demos/Host/LowLevel/MassStorageHost/Lib/MassStoreCommands.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 /** \file
  32  *
  33  *  Mass Storage Device commands, to issue MSD commands to the device for
  34  *  reading device status, capacity, and other characteristics. This file
  35  *  also contains block read and write functions, so that device blocks
  36  *  can be read and written. In general, these functions would be chained
  37  *  to a FAT library to give file-level access to an attached device's contents.
  38  *
  39  *  \note Many Mass Storage devices on the market are non-compliant to the
  40  *        specifications and thus can prove difficult to interface with. It
  41  *        may be necessary to retry the functions in the module several times
  42  *        after they have returned and error to successfully send the command
  43  *        to the device. Some devices may also need to have the stream function
  44  *        timeout period extended beyond 100ms (some badly designed devices exceeding
  45  *        1.5 seconds occasionally) by defining USB_STREAM_TIMEOUT_MS to a
  46  *        larger value in the project makefile and passing it to the compiler
  47  *        via the -D switch.
  48  */
  49
  50 #define  INCLUDE_FROM_MASSSTORE_COMMANDS_C
  51 #include "MassStoreCommands.h"
  52
  53 /* Globals: */
  54 /** Current CBW to send to the device. This is automatically filled by the routines
  55  *  in this file and is not externally accessible.
  56  */
  57 static CommandBlockWrapper_t  SCSICommandBlock;
  58
  59 /** Current CSW received from the device. This is automatically filled by the routines
  60  *  in this file and is externally accessible so that the return codes may be checked.
  61  */
  62 CommandStatusWrapper_t        SCSICommandStatus;
  63
  64 /** Current Tag value used in issued CBWs to the device. This is automatically incremented
  65  *  by the routines in this file, and is not externally accessible.
  66  */
  67 static uint32_t               MassStore_Tag = 1;
  68
  69
  70 /** Routine to send the current CBW to the device, and increment the Tag value as needed.
  71  *
  72  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
  73  */
  74 static uint8_t MassStore_SendCommand(void)
  75 {
  76         uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
  77
  78         /* Each transmission should have a unique tag value, excluding values 0 and 0xFFFFFFFF */
  79         if (++MassStore_Tag == 0xFFFFFFFF)
  80           MassStore_Tag = 1;
  81
  82         /* Select the OUT data pipe for CBW transmission */
  83         Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
  84         Pipe_Unfreeze();
  85
  86         /* Write the CBW command to the OUT pipe */
  87         if ((ErrorCode = Pipe_Write_Stream_LE(&SCSICommandBlock, sizeof(CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)
  88           return ErrorCode;
  89
  90         /* Send the data in the OUT pipe to the attached device */
  91         Pipe_ClearOUT();
  92
  93         while(!(Pipe_IsOUTReady()));
  94
  95         /* Freeze pipe after use */
  96         Pipe_Freeze();
  97
  98         return PIPE_RWSTREAM_NoError;
  99 }
 100
 101 /** Waits until the attached device is ready to accept data following a CBW, checking
 102  *  to ensure that the device has not stalled the transaction.
 103  *
 104  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 105  */
 106 static uint8_t MassStore_WaitForDataReceived(void)
 107 {
 108         uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
 109
 110         /* Select the IN data pipe for data reception */
 111         Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
 112         Pipe_Unfreeze();
 113
 114         /* Wait until data received in the IN pipe */
 115         while (!(Pipe_IsINReceived()))
 116         {
 117                 /* Check to see if a new frame has been issued (1ms elapsed) */
 118                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 119                 {
 120                         /* Clear the flag and decrement the timeout period counter */
 121                         USB_INT_Clear(USB_INT_HSOFI);
 122                         TimeoutMSRem--;
 123
 124                         /* Check to see if the timeout period for the command has elapsed */
 125                         if (!(TimeoutMSRem))
 126                           return PIPE_RWSTREAM_Timeout;
 127                 }
 128
 129                 Pipe_Freeze();
 130                 Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
 131                 Pipe_Unfreeze();
 132
 133                 /* Check if pipe stalled (command failed by device) */
 134                 if (Pipe_IsStalled())
 135                 {
 136                         /* Clear the stall condition on the OUT pipe */
 137                         MassStore_ClearPipeStall(MASS_STORE_DATA_OUT_PIPE);
 138
 139                         return PIPE_RWSTREAM_PipeStalled;
 140                 }
 141
 142                 Pipe_Freeze();
 143                 Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
 144                 Pipe_Unfreeze();
 145
 146                 /* Check if pipe stalled (command failed by device) */
 147                 if (Pipe_IsStalled())
 148                 {
 149                         /* Clear the stall condition on the IN pipe */
 150                         MassStore_ClearPipeStall(MASS_STORE_DATA_IN_PIPE);
 151
 152                         return PIPE_RWSTREAM_PipeStalled;
 153                 }
 154
 155                 /* Check to see if the device was disconnected, if so exit function */
 156                 if (!(USB_IsConnected))
 157                   return PIPE_RWSTREAM_DeviceDisconnected;
 158         };
 159
 160         Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
 161         Pipe_Freeze();
 162
 163         Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
 164         Pipe_Freeze();
 165
 166         return PIPE_RWSTREAM_NoError;
 167 }
 168
 169 /** Sends or receives the transaction's data stage to or from the attached device, reading or
 170  *  writing to the nominated buffer.
 171  *
 172  *  \param  BufferPtr  Pointer to the data buffer to read from or write to
 173  *
 174  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 175  */
 176 static uint8_t MassStore_SendReceiveData(void* BufferPtr)
 177 {
 178         uint8_t  ErrorCode = PIPE_RWSTREAM_NoError;
 179         uint16_t BytesRem  = SCSICommandBlock.Header.DataTransferLength;
 180
 181         /* Check the direction of the SCSI command data stage */
 182         if (SCSICommandBlock.Header.Flags & COMMAND_DIRECTION_DATA_IN)
 183         {
 184                 /* Select the IN data pipe for data reception */
 185                 Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
 186                 Pipe_Unfreeze();
 187
 188                 /* Read in the block data from the pipe */
 189                 if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)
 190                   return ErrorCode;
 191
 192                 /* Acknowledge the packet */
 193                 Pipe_ClearIN();
 194         }
 195         else
 196         {
 197                 /* Select the OUT data pipe for data transmission */
 198                 Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
 199                 Pipe_Unfreeze();
 200
 201                 /* Write the block data to the pipe */
 202                 if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)
 203                   return ErrorCode;
 204
 205                 /* Acknowledge the packet */
 206                 Pipe_ClearOUT();
 207
 208                 while (!(Pipe_IsOUTReady()));
 209         }
 210
 211         /* Freeze used pipe after use */
 212         Pipe_Freeze();
 213
 214         return PIPE_RWSTREAM_NoError;
 215 }
 216
 217 /** Routine to receive the current CSW from the device.
 218  *
 219  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 220  */
 221 static uint8_t MassStore_GetReturnedStatus(void)
 222 {
 223         uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 224
 225         /* If an error in the command ocurred, abort */
 226         if ((ErrorCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
 227           return ErrorCode;
 228
 229         /* Select the IN data pipe for data reception */
 230         Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
 231         Pipe_Unfreeze();
 232
 233         /* Load in the CSW from the attached device */
 234         if ((ErrorCode = Pipe_Read_Stream_LE(&SCSICommandStatus, sizeof(CommandStatusWrapper_t))) != PIPE_RWSTREAM_NoError)
 235           return ErrorCode;
 236
 237         /* Clear the data ready for next reception */
 238         Pipe_ClearIN();
 239
 240         /* Freeze the IN pipe after use */
 241         Pipe_Freeze();
 242
 243         return PIPE_RWSTREAM_NoError;
 244 }
 245
 246 /** Clears the stall condition in the attached device on the nominated endpoint number.
 247  *
 248  *  \param EndpointNum  Endpoint number in the attached device whose stall condition is to be cleared
 249  *
 250  *  \return A value from the USB_Host_SendControlErrorCodes_t enum
 251  */
 252 uint8_t MassStore_ClearPipeStall(const uint8_t EndpointNum)
 253 {
 254         USB_ControlRequest = (USB_Request_Header_t)
 255                 {
 256                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT),
 257                         .bRequest      = REQ_ClearFeature,
 258                         .wValue        = FEATURE_ENDPOINT_HALT,
 259                         .wIndex        = EndpointNum,
 260                         .wLength       = 0,
 261                 };
 262
 263         /* Select the control pipe for the request transfer */
 264         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 265
 266         return USB_Host_SendControlRequest(NULL);
 267 }
 268
 269 /** Issues a Mass Storage class specific request to reset the attached device's Mass Storage interface,
 270  *  readying the device for the next CBW.
 271  *
 272  *  \return A value from the USB_Host_SendControlErrorCodes_t enum
 273  */
 274 uint8_t MassStore_MassStorageReset(void)
 275 {
 276         USB_ControlRequest = (USB_Request_Header_t)
 277                 {
 278                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 279                         .bRequest      = REQ_MassStorageReset,
 280                         .wValue        = 0,
 281                         .wIndex        = 0,
 282                         .wLength       = 0,
 283                 };
 284
 285         /* Select the control pipe for the request transfer */
 286         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 287
 288         return USB_Host_SendControlRequest(NULL);
 289 }
 290
 291 /** Issues a Mass Storage class specific request to determine the index of the highest numbered Logical
 292  *  Unit in the attached device.
 293  *
 294  *  \param MaxLUNIndex  Pointer to the location that the maximum LUN index value should be stored
 295  *
 296  *  \return A value from the USB_Host_SendControlErrorCodes_t enum
 297  */
 298 uint8_t MassStore_GetMaxLUN(uint8_t* const MaxLUNIndex)
 299 {
 300         uint8_t ErrorCode;
 301
 302         USB_ControlRequest = (USB_Request_Header_t)
 303                 {
 304                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 305                         .bRequest      = REQ_GetMaxLUN,
 306                         .wValue        = 0,
 307                         .wIndex        = 0,
 308                         .wLength       = 1,
 309                 };
 310
 311         /* Select the control pipe for the request transfer */
 312         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 313
 314         if ((ErrorCode = USB_Host_SendControlRequest(MaxLUNIndex)) == HOST_SENDCONTROL_SetupStalled)
 315         {
 316                 /* Clear the pipe stall */
 317                 Pipe_ClearStall();
 318
 319                 /* Some faulty Mass Storage devices don't implement the GET_MAX_LUN request, so assume a single LUN */
 320                 *MaxLUNIndex = 0;
 321         }
 322
 323         return ErrorCode;
 324 }
 325
 326 /** Issues a SCSI Request Sense command to the attached device, to determine the current SCSI sense information. This
 327  *  gives error codes for the last issued SCSI command to the device.
 328  *
 329  *  \param LUNIndex  Index of the LUN inside the device the command is being addressed to
 330  *  \param SensePtr  Pointer to the sense data structure where the sense data from the device is to be stored
 331  *
 332  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 333  */
 334 uint8_t MassStore_RequestSense(const uint8_t LUNIndex, const SCSI_Request_Sense_Response_t* const SensePtr)
 335 {
 336         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 337
 338         /* Create a CBW with a SCSI command to issue REQUEST SENSE command */
 339         SCSICommandBlock = (CommandBlockWrapper_t)
 340                 {
 341                         .Header =
 342                                 {
 343                                         .Signature          = CBW_SIGNATURE,
 344                                         .Tag                = MassStore_Tag,
 345                                         .DataTransferLength = sizeof(SCSI_Request_Sense_Response_t),
 346                                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 347                                         .LUN                = LUNIndex,
 348                                         .SCSICommandLength  = 6
 349                                 },
 350
 351                         .SCSICommandData =
 352                                 {
 353                                         SCSI_CMD_REQUEST_SENSE,
 354                                         0x00,                   // Reserved
 355                                         0x00,                   // Reserved
 356                                         0x00,                   // Reserved
 357                                         sizeof(SCSI_Request_Sense_Response_t), // Allocation Length
 358                                         0x00                    // Unused (control)
 359                                 }
 360                 };
 361
 362         /* Send SCSI command to the attached device */
 363         MassStore_SendCommand();
 364
 365         /* Wait until data received from the device */
 366         if ((ReturnCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
 367         {
 368                 Pipe_Freeze();
 369                 return ReturnCode;
 370         }
 371
 372         /* Read the returned sense data into the buffer */
 373         if ((ReturnCode = MassStore_SendReceiveData((uint8_t*)SensePtr)) != PIPE_RWSTREAM_NoError)
 374         {
 375                 Pipe_Freeze();
 376                 return ReturnCode;
 377         }
 378
 379         /* Read in the returned CSW from the device */
 380         if ((ReturnCode = MassStore_GetReturnedStatus()) != PIPE_RWSTREAM_NoError)
 381         {
 382                 Pipe_Freeze();
 383                 return ReturnCode;
 384         }
 385
 386         return PIPE_RWSTREAM_NoError;
 387 }
 388
 389 /** Issues a SCSI Device Block Read command to the attached device, to read in one or more data blocks from the
 390  *  storage medium into a buffer.
 391  *
 392  *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to
 393  *  \param BlockAddress  Start block address to read from
 394  *  \param Blocks        Number of blocks to read from the device
 395  *  \param BlockSize     Size in bytes of each block to read
 396  *  \param BufferPtr     Pointer to the buffer where the read data is to be written to
 397  *
 398  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 399  */
 400 uint8_t MassStore_ReadDeviceBlock(const uint8_t LUNIndex, const uint32_t BlockAddress,
 401                                   const uint8_t Blocks, const uint16_t BlockSize, void* BufferPtr)
 402 {
 403         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 404
 405         /* Create a CBW with a SCSI command to read in the given blocks from the device */
 406         SCSICommandBlock = (CommandBlockWrapper_t)
 407                 {
 408                         .Header =
 409                                 {
 410                                         .Signature          = CBW_SIGNATURE,
 411                                         .Tag                = MassStore_Tag,
 412                                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 413                                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 414                                         .LUN                = LUNIndex,
 415                                         .SCSICommandLength  = 10
 416                                 },
 417
 418                         .SCSICommandData =
 419                                 {
 420                                         SCSI_CMD_READ_10,
 421                                         0x00,                   // Unused (control bits, all off)
 422                                         (BlockAddress >> 24),   // MSB of Block Address
 423                                         (BlockAddress >> 16),
 424                                         (BlockAddress >> 8),
 425                                         (BlockAddress & 0xFF),  // LSB of Block Address
 426                                         0x00,                   // Unused (reserved)
 427                                         0x00,                   // MSB of Total Blocks to Read
 428                                         Blocks,                 // LSB of Total Blocks to Read
 429                                         0x00                    // Unused (control)
 430                                 }
 431                 };
 432
 433         /* Send SCSI command to the attached device */
 434         MassStore_SendCommand();
 435
 436         /* Wait until data received from the device */
 437         if ((ReturnCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
 438         {
 439                 Pipe_Freeze();
 440                 return ReturnCode;
 441         }
 442
 443         /* Read the returned block data into the buffer */
 444         if ((ReturnCode = MassStore_SendReceiveData(BufferPtr)) != PIPE_RWSTREAM_NoError)
 445         {
 446                 Pipe_Freeze();
 447                 return ReturnCode;
 448         }
 449
 450         /* Read in the returned CSW from the device */
 451         if ((ReturnCode = MassStore_GetReturnedStatus()) != PIPE_RWSTREAM_NoError)
 452         {
 453                 Pipe_Freeze();
 454                 return ReturnCode;
 455         }
 456
 457         return PIPE_RWSTREAM_NoError;
 458 }
 459
 460 /** Issues a SCSI Device Block Write command to the attached device, to write one or more data blocks to the
 461  *  storage medium from a buffer.
 462  *
 463  *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to
 464  *  \param BlockAddress  Start block address to write to
 465  *  \param Blocks        Number of blocks to write to in the device
 466  *  \param BlockSize     Size in bytes of each block to write
 467  *  \param BufferPtr     Pointer to the buffer where the write data is to be sourced from
 468  *
 469  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 470  */
 471 uint8_t MassStore_WriteDeviceBlock(const uint8_t LUNIndex, const uint32_t BlockAddress,
 472                                    const uint8_t Blocks, const uint16_t BlockSize, void* BufferPtr)
 473 {
 474         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 475
 476         /* Create a CBW with a SCSI command to write the given blocks to the device */
 477         SCSICommandBlock = (CommandBlockWrapper_t)
 478                 {
 479                         .Header =
 480                                 {
 481                                         .Signature          = CBW_SIGNATURE,
 482                                         .Tag                = MassStore_Tag,
 483                                         .DataTransferLength = ((uint32_t)Blocks * BlockSize),
 484                                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 485                                         .LUN                = LUNIndex,
 486                                         .SCSICommandLength  = 10
 487                                 },
 488
 489                         .SCSICommandData =
 490                                 {
 491                                         SCSI_CMD_WRITE_10,
 492                                         0x00,                   // Unused (control bits, all off)
 493                                         (BlockAddress >> 24),   // MSB of Block Address
 494                                         (BlockAddress >> 16),
 495                                         (BlockAddress >> 8),
 496                                         (BlockAddress & 0xFF),  // LSB of Block Address
 497                                         0x00,                   // Unused (reserved)
 498                                         0x00,                   // MSB of Total Blocks to Write
 499                                         Blocks,                 // LSB of Total Blocks to Write
 500                                         0x00                    // Unused (control)
 501                                 }
 502                 };
 503
 504         /* Send SCSI command to the attached device */
 505         MassStore_SendCommand();
 506
 507         /* Write the data to the device from the buffer */
 508         if ((ReturnCode = MassStore_SendReceiveData(BufferPtr)) != PIPE_RWSTREAM_NoError)
 509         {
 510                 Pipe_Freeze();
 511                 return ReturnCode;
 512         }
 513
 514         /* Read in the returned CSW from the device */
 515         if ((ReturnCode = MassStore_GetReturnedStatus()) != PIPE_RWSTREAM_NoError)
 516         {
 517                 Pipe_Freeze();
 518                 return ReturnCode;
 519         }
 520
 521         return PIPE_RWSTREAM_NoError;
 522 }
 523
 524 /** Issues a SCSI Device Test Unit Ready command to the attached device, to determine if the device is ready to accept
 525  *  other commands.
 526  *
 527  *  \param LUNIndex      Index of the LUN inside the device the command is being addressed to
 528  *
 529  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 530  */
 531 uint8_t MassStore_TestUnitReady(const uint8_t LUNIndex)
 532 {
 533         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 534
 535         /* Create a CBW with a SCSI command to issue TEST UNIT READY command */
 536         SCSICommandBlock = (CommandBlockWrapper_t)
 537                 {
 538                         .Header =
 539                                 {
 540                                         .Signature          = CBW_SIGNATURE,
 541                                         .Tag                = MassStore_Tag,
 542                                         .DataTransferLength = 0,
 543                                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 544                                         .LUN                = LUNIndex,
 545                                         .SCSICommandLength  = 6
 546                                 },
 547
 548                         .SCSICommandData =
 549                                 {
 550                                         SCSI_CMD_TEST_UNIT_READY,
 551                                         0x00,                   // Reserved
 552                                         0x00,                   // Reserved
 553                                         0x00,                   // Reserved
 554                                         0x00,                   // Reserved
 555                                         0x00                    // Unused (control)
 556                                 }
 557                 };
 558
 559         /* Send SCSI command to the attached device */
 560         MassStore_SendCommand();
 561
 562         /* Read in the returned CSW from the device */
 563         if ((ReturnCode = MassStore_GetReturnedStatus()) != PIPE_RWSTREAM_NoError)
 564         {
 565                 Pipe_Freeze();
 566                 return ReturnCode;
 567         }
 568
 569         return PIPE_RWSTREAM_NoError;
 570 }
 571
 572 /** Issues a SCSI Device Read Capacity command to the attached device, to determine the capacity of the
 573  *  given Logical Unit within the device.
 574  *
 575  *  \param LUNIndex     Index of the LUN inside the device the command is being addressed to
 576  *  \param CapacityPtr  Device capacity structure where the capacity data is to be stored
 577  *
 578  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 579  */
 580 uint8_t MassStore_ReadCapacity(const uint8_t LUNIndex, SCSI_Capacity_t* const CapacityPtr)
 581 {
 582         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 583
 584         /* Create a CBW with a SCSI command to issue READ CAPACITY command */
 585         SCSICommandBlock = (CommandBlockWrapper_t)
 586                 {
 587                         .Header =
 588                                 {
 589                                         .Signature          = CBW_SIGNATURE,
 590                                         .Tag                = MassStore_Tag,
 591                                         .DataTransferLength = sizeof(SCSI_Capacity_t),
 592                                         .Flags              = COMMAND_DIRECTION_DATA_IN,
 593                                         .LUN                = LUNIndex,
 594                                         .SCSICommandLength  = 10
 595                                 },
 596
 597                         .SCSICommandData =
 598                                 {
 599                                         SCSI_CMD_READ_CAPACITY_10,
 600                                         0x00,                   // Reserved
 601                                         0x00,                   // MSB of Logical block address
 602                                         0x00,
 603                                         0x00,
 604                                         0x00,                   // LSB of Logical block address
 605                                         0x00,                   // Reserved
 606                                         0x00,                   // Reserved
 607                                         0x00,                   // Partial Medium Indicator
 608                                         0x00                    // Unused (control)
 609                                 }
 610                 };
 611
 612         /* Send SCSI command to the attached device */
 613         MassStore_SendCommand();
 614
 615         /* Wait until data received from the device */
 616         if ((ReturnCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
 617         {
 618                 Pipe_Freeze();
 619                 return ReturnCode;
 620         }
 621
 622         /* Read the returned capacity data into the buffer */
 623         if ((ReturnCode = MassStore_SendReceiveData(CapacityPtr)) != PIPE_RWSTREAM_NoError)
 624         {
 625                 Pipe_Freeze();
 626                 return ReturnCode;
 627         }
 628
 629         /* Endian-correct the read data */
 630         CapacityPtr->Blocks    = SwapEndian_32(CapacityPtr->Blocks);
 631         CapacityPtr->BlockSize = SwapEndian_32(CapacityPtr->BlockSize);
 632
 633         /* Read in the returned CSW from the device */
 634         if ((ReturnCode = MassStore_GetReturnedStatus()) != PIPE_RWSTREAM_NoError)
 635         {
 636                 Pipe_Freeze();
 637                 return ReturnCode;
 638         }
 639
 640         return PIPE_RWSTREAM_NoError;
 641 }
 642
 643 /** Issues a SCSI Device Prevent/Allow Medium Removal command to the attached device, to lock the physical media from
 644  *  being removed. This is a legacy command for SCSI disks with removable storage (such as ZIP disks), but should still
 645  *  be issued before the first read or write command is sent.
 646  *
 647  *  \param LUNIndex        Index of the LUN inside the device the command is being addressed to
 648  *  \param PreventRemoval  Whether or not the LUN media should be locked to prevent removal or not
 649  *
 650  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
 651  */
 652 uint8_t MassStore_PreventAllowMediumRemoval(const uint8_t LUNIndex, const bool PreventRemoval)
 653 {
 654         uint8_t ReturnCode = PIPE_RWSTREAM_NoError;
 655
 656         /* Create a CBW with a SCSI command to issue PREVENT ALLOW MEDIUM REMOVAL command */
 657         SCSICommandBlock = (CommandBlockWrapper_t)
 658                 {
 659                         .Header =
 660                                 {
 661                                         .Signature          = CBW_SIGNATURE,
 662                                         .Tag                = MassStore_Tag,
 663                                         .DataTransferLength = 0,
 664                                         .Flags              = COMMAND_DIRECTION_DATA_OUT,
 665                                         .LUN                = LUNIndex,
 666                                         .SCSICommandLength  = 6
 667                                 },
 668
 669                         .SCSICommandData =
 670                                 {
 671                                         SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL,
 672                                         0x00,                   // Reserved
 673                                         0x00,                   // Reserved
 674                                         PreventRemoval,         // Prevent flag
 675                                         0x00,                   // Reserved
 676                                         0x00                    // Unused (control)
 677                                 }
 678                 };
 679
 680         /* Send SCSI command to the attached device */
 681         MassStore_SendCommand();
 682
 683         /* Read in the returned CSW from the device */
 684         if ((ReturnCode = MassStore_GetReturnedStatus()))
 685         {
 686                 Pipe_Freeze();
 687                 return ReturnCode;
 688         }
 689
 690         return PIPE_RWSTREAM_NoError;
 691 }