/*
              LUFA Library
      Copyright (C) Dean Camera, 2010.
-              
+
   dean [at] fourwalledcubicle [dot] com
-      www.fourwalledcubicle.com
+           www.lufa-lib.org
 */
 
 /*
   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
 
-  Permission to use, copy, modify, distribute, and sell this 
+  Permission to use, copy, modify, distribute, and sell this
   software and its documentation for any purpose is hereby granted
-  without fee, provided that the above copyright notice appear in 
+  without fee, provided that the above copyright notice appear in
   all copies and that both that the copyright notice and this
-  permission notice and warranty disclaimer appear in supporting 
-  documentation, and that the name of the author not be used in 
-  advertising or publicity pertaining to distribution of the 
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
   software without specific, written prior permission.
 
   The author disclaim all warranties with regard to this
  *        larger value in the project makefile and passing it to the compiler
  *        via the -D switch.
  */
- 
+
 #define  INCLUDE_FROM_MASSSTORE_COMMANDS_C
 #include "MassStoreCommands.h"
 
  *
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
  */
-static uint8_t MassStore_SendCommand(CommandBlockWrapper_t* const SCSICommandBlock,
+static uint8_t MassStore_SendCommand(MS_CommandBlockWrapper_t* const SCSICommandBlock,
                                      void* BufferPtr)
 {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
        Pipe_Unfreeze();
 
        /* Write the CBW command to the OUT pipe */
-       if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)
+       if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(MS_CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
 
        /* Send the data in the OUT pipe to the attached device */
        Pipe_ClearOUT();
-       
+
        /* Wait until command has been sent */
        Pipe_WaitUntilReady();
 
        /* Freeze pipe after use */
        Pipe_Freeze();
-       
+
        /* Send data if any */
        if ((BufferPtr != NULL) &&
            ((ErrorCode = MassStore_SendReceiveData(SCSICommandBlock, BufferPtr)) != PIPE_READYWAIT_NoError))
                Pipe_Freeze();
                return ErrorCode;
        }
-               
+
        return ErrorCode;
 }
 
  */
 static uint8_t MassStore_WaitForDataReceived(void)
 {
-       uint16_t TimeoutMSRem = COMMAND_DATA_TIMEOUT_MS;
+       uint16_t TimeoutMSRem        = COMMAND_DATA_TIMEOUT_MS;
+       uint16_t PreviousFrameNumber = USB_Host_GetFrameNumber();
 
        /* Select the IN data pipe for data reception */
        Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
        /* Wait until data received in the IN pipe */
        while (!(Pipe_IsINReceived()))
        {
+               uint16_t CurrentFrameNumber = USB_Host_GetFrameNumber();
+
                /* Check to see if a new frame has been issued (1ms elapsed) */
-               if (USB_INT_HasOccurred(USB_INT_HSOFI))
+               if (CurrentFrameNumber != PreviousFrameNumber)
                {
-                       /* Clear the flag and decrement the timeout period counter */
-                       USB_INT_Clear(USB_INT_HSOFI);
+                       /* Save the new frame number and decrement the timeout period */
+                       PreviousFrameNumber = CurrentFrameNumber;
                        TimeoutMSRem--;
 
                        /* Check to see if the timeout period for the command has elapsed */
                        if (!(TimeoutMSRem))
                          return PIPE_RWSTREAM_Timeout;
                }
-       
+
                Pipe_Freeze();
                Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
                Pipe_Unfreeze();
 
                        return PIPE_RWSTREAM_PipeStalled;
                }
-               
+
                Pipe_Freeze();
                Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
                Pipe_Unfreeze();
 
                        return PIPE_RWSTREAM_PipeStalled;
                }
-                 
+
                /* Check to see if the device was disconnected, if so exit function */
                if (USB_HostState == HOST_STATE_Unattached)
                  return PIPE_RWSTREAM_DeviceDisconnected;
        };
-       
+
        Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
        Pipe_Freeze();
-               
+
        Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
        Pipe_Freeze();
 
  *
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
  */
-static uint8_t MassStore_SendReceiveData(CommandBlockWrapper_t* const SCSICommandBlock,
+static uint8_t MassStore_SendReceiveData(MS_CommandBlockWrapper_t* const SCSICommandBlock,
                                          void* BufferPtr)
 {
        uint8_t  ErrorCode = PIPE_RWSTREAM_NoError;
        uint16_t BytesRem  = SCSICommandBlock->DataTransferLength;
 
        /* Check the direction of the SCSI command data stage */
-       if (SCSICommandBlock->Flags & COMMAND_DIRECTION_DATA_IN)
+       if (SCSICommandBlock->Flags & MS_COMMAND_DIR_DATA_IN)
        {
                /* Wait until the device has replied with some data */
                if ((ErrorCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
                  return ErrorCode;
-       
+
                /* Select the IN data pipe for data reception */
                Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
                Pipe_Unfreeze();
-               
+
                /* Read in the block data from the pipe */
                if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)
                  return ErrorCode;
 
                /* Acknowledge the packet */
                Pipe_ClearOUT();
-               
+
                while (!(Pipe_IsOUTReady()))
                {
                        if (USB_HostState == HOST_STATE_Unattached)
                          return PIPE_RWSTREAM_DeviceDisconnected;
                }
        }
-       
+
        /* Freeze used pipe after use */
        Pipe_Freeze();
 
  *
  *  \return A value from the Pipe_Stream_RW_ErrorCodes_t enum, or MASS_STORE_SCSI_COMMAND_FAILED if the SCSI command fails
  */
-static uint8_t MassStore_GetReturnedStatus(CommandStatusWrapper_t* const SCSICommandStatus)
+static uint8_t MassStore_GetReturnedStatus(MS_CommandStatusWrapper_t* const SCSICommandStatus)
 {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Select the IN data pipe for data reception */
        Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
        Pipe_Unfreeze();
-       
+
        /* Load in the CSW from the attached device */
-       if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(CommandStatusWrapper_t))) != PIPE_RWSTREAM_NoError)
+       if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(MS_CommandStatusWrapper_t))) != PIPE_RWSTREAM_NoError)
          return ErrorCode;
-         
+
        /* Clear the data ready for next reception */
        Pipe_ClearIN();
-       
+
        /* Freeze the IN pipe after use */
        Pipe_Freeze();
-       
+
        /* Check to see if command failed */
-       if (SCSICommandStatus->Status != Command_Pass)
+       if (SCSICommandStatus->Status != MS_SCSI_COMMAND_Pass)
          ErrorCode = MASS_STORE_SCSI_COMMAND_FAILED;
-       
+
        return ErrorCode;
 }
 
        USB_ControlRequest = (USB_Request_Header_t)
                {
                        .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
-                       .bRequest      = REQ_MassStorageReset,
+                       .bRequest      = MS_REQ_MassStorageReset,
                        .wValue        = 0,
                        .wIndex        = 0,
                        .wLength       = 0,
                };
-       
+
        /* Select the control pipe for the request transfer */
        Pipe_SelectPipe(PIPE_CONTROLPIPE);
 
        USB_ControlRequest = (USB_Request_Header_t)
                {
                        .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
-                       .bRequest      = REQ_GetMaxLUN,
+                       .bRequest      = MS_REQ_GetMaxLUN,
                        .wValue        = 0,
                        .wIndex        = 0,
                        .wLength       = 1,
                };
-               
+
        /* Select the control pipe for the request transfer */
        Pipe_SelectPipe(PIPE_CONTROLPIPE);
 
        {
                /* Clear the pipe stall */
                Pipe_ClearStall();
-       
+
                /* Some faulty Mass Storage devices don't implement the GET_MAX_LUN request, so assume a single LUN */
                *MaxLUNIndex = 0;
-               
+
                /* Clear the error, and pretend the request executed correctly if the device STALLed it */
                ErrorCode = HOST_SENDCONTROL_Successful;
        }
-       
+
        return ErrorCode;
 }
 
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to issue INQUIRY command */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = sizeof(SCSI_Inquiry_Response_t),
-                       .Flags              = COMMAND_DIRECTION_DATA_IN,
+                       .Flags              = MS_COMMAND_DIR_DATA_IN,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 6,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, InquiryPtr)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to issue REQUEST SENSE command */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = sizeof(SCSI_Request_Sense_Response_t),
-                       .Flags              = COMMAND_DIRECTION_DATA_IN,
+                       .Flags              = MS_COMMAND_DIR_DATA_IN,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 6,
                        .SCSICommandData =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, SensePtr)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to read in the given blocks from the device */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = ((uint32_t)Blocks * BlockSize),
-                       .Flags              = COMMAND_DIRECTION_DATA_IN,
+                       .Flags              = MS_COMMAND_DIR_DATA_IN,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 10,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, BufferPtr)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to write the given blocks to the device */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = ((uint32_t)Blocks * BlockSize),
-                       .Flags              = COMMAND_DIRECTION_DATA_OUT,
+                       .Flags              = MS_COMMAND_DIR_DATA_OUT,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 10,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, BufferPtr)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
  */
 uint8_t MassStore_TestUnitReady(const uint8_t LUNIndex)
 {
-       uint8_t ErrorCode = PIPE_RWSTREAM_NoError;      
+       uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to issue TEST UNIT READY command */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = 0,
-                       .Flags              = COMMAND_DIRECTION_DATA_IN,
+                       .Flags              = MS_COMMAND_DIR_DATA_IN,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 6,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to issue READ CAPACITY command */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = sizeof(SCSI_Capacity_t),
-                       .Flags              = COMMAND_DIRECTION_DATA_IN,
+                       .Flags              = MS_COMMAND_DIR_DATA_IN,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 10,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, CapacityPtr)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-         
+
        /* Endian-correct the read data */
        CapacityPtr->Blocks    = SwapEndian_32(CapacityPtr->Blocks);
        CapacityPtr->BlockSize = SwapEndian_32(CapacityPtr->BlockSize);
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
        uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
 
        /* Create a CBW with a SCSI command to issue PREVENT ALLOW MEDIUM REMOVAL command */
-       CommandBlockWrapper_t SCSICommandBlock = (CommandBlockWrapper_t)
+       MS_CommandBlockWrapper_t SCSICommandBlock = (MS_CommandBlockWrapper_t)
                {
-                       .Signature          = CBW_SIGNATURE,
+                       .Signature          = MS_CBW_SIGNATURE,
                        .DataTransferLength = 0,
-                       .Flags              = COMMAND_DIRECTION_DATA_OUT,
+                       .Flags              = MS_COMMAND_DIR_DATA_OUT,
                        .LUN                = LUNIndex,
                        .SCSICommandLength  = 6,
                        .SCSICommandData    =
                                        0x00                    // Unused (control)
                                }
                };
-       
-       CommandStatusWrapper_t SCSICommandStatus;
+
+       MS_CommandStatusWrapper_t SCSICommandStatus;
 
        /* Send the command and any data to the attached device */
        if ((ErrorCode = MassStore_SendCommand(&SCSICommandBlock, NULL)) != PIPE_RWSTREAM_NoError)
                Pipe_Freeze();
                return ErrorCode;
        }
-       
+
        /* Retrieve status information from the attached device */
        if ((ErrorCode = MassStore_GetReturnedStatus(&SCSICommandStatus)) != PIPE_RWSTREAM_NoError)
        {
 
        return ErrorCode;
 }
+