}

/*************************************************************************
 * Function Name: ScsiMediaRemovalImp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: PREVENT ALLOW MEDIUM REMOVAL command implement
 *
 *************************************************************************/
inline
void ScsiMediaRemovalImp(void)
{
pSpc3MediaRemoval_t pMediaRemoval = (pSpc3MediaRemoval_t)Cbw.CBWCB;
  if (Cbw.dCBWDataTransferLength == 0)
  {
    if ((pMediaRemoval->Prevent == 0) || (pMediaRemoval->Prevent == 1))
    {
      // Clear condition code info
      ScsiCmdStatus(ScsiCommandNoKey);
      BotSendStatus();
    }
    else
    {
      ScsiCmdStatus(ScsiInvalidCbd);
      BotSendStatus();
    }
    return;
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  UsbBotRstInterface();
}

/*************************************************************************
 * Function Name: ScsiReadCapacity10Imp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: READ CAPACITY (10) command implement
 *
 *************************************************************************/
inline
void ScsiReadCapacity10Imp (void)
{
  if ((Cbw.bmCBWFlags.Dir == BotDataFormDevToHost) &&
      (Cbw.dCBWDataTransferLength >= sizeof(Sbc2ReadCapacity10Response_t)))
  {
    ScsiDrv[Lun].Message[0] = LunReadCapacity10ReqMsg;
    pScsiMessage[Lun] = ScsiDrv[Lun].Message;
    // Clear condition code info
    ScsiDrv[Lun].Status = ScsiCommandNoKey;
    return;
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  BotStatus.BotStatus = TRUE;
  BotInEpStall();
}

/*************************************************************************
 * Function Name: ScsiReadCapacityData
 * Parameters:  Int32U LogBlockAdd, Int32U BlockSize
 *
 * Return: none
 *
 * Description: Prepare Read capacity data for sending
 *
 *************************************************************************/
void ScsiReadCapacityData (Int32U LogBlockAdd, Int32U BlockSize)
{
pSbc2ReadCapacity10Response_t pReadCapacity = (pSbc2ReadCapacity10Response_t)&Cbw;

  // clear buffer
  memset(pReadCapacity,0,sizeof(Sbc2ReadCapacity10Response_t));

  pReadCapacity->LogicalBlockAddress[0] = (LogBlockAdd >> 24) & 0xFF;
  pReadCapacity->LogicalBlockAddress[1] = (LogBlockAdd >> 16) & 0xFF;
  pReadCapacity->LogicalBlockAddress[2] = (LogBlockAdd >> 8 ) & 0xFF;
  pReadCapacity->LogicalBlockAddress[3] = (LogBlockAdd >> 0 ) & 0xFF;

  pReadCapacity->BlockLength[0]         = (BlockSize   >> 24) & 0xFF;
  pReadCapacity->BlockLength[1]         = (BlockSize   >> 16) & 0xFF;
  pReadCapacity->BlockLength[2]         = (BlockSize   >> 8 ) & 0xFF;
  pReadCapacity->BlockLength[3]         = (BlockSize   >> 0 ) & 0xFF;

  BotSendDataInit((Int8U *)pReadCapacity,
                  MIN(Csw.dCSWDataResidue,sizeof(Sbc2ReadCapacity10Response_t)),
                  TRUE);
}

/*************************************************************************
 * Function Name: ScsiRead10Imp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: READ (10) command implement
 *
 *************************************************************************/
inline
void ScsiRead10Imp (void)
{
pSbc2Read10_t pRead = (pSbc2Read10_t)Cbw.CBWCB;
  if (Cbw.bmCBWFlags.Dir == BotDataFormDevToHost)
  {
    if(ScsiDrv[Lun].UnitSSStatus == UnitEjected)
    {
      ScsiCmdStatus(ScsiMediaNotPresent);
    }
    else
    {
      // Clear condition code info
      ScsiDrv[Lun].Status = ScsiCommandNoKey;
      ScsiDrv[Lun].Message[2] = ((Int32U)pRead->TransferLength[0] << 8) + pRead->TransferLength[1];
      if(ScsiDrv[Lun].Message[2] != 0)
      {
        ScsiDrv[Lun].Message[0] = LunRead10ReqMsg;
        ScsiDrv[Lun].Message[1] = ((Int32U)pRead->LogicalBockAddress[0] << 24) +\
                                  ((Int32U)pRead->LogicalBockAddress[1] << 16) +\
                                  ((Int32U)pRead->LogicalBockAddress[2] << 8 ) +\
                                  pRead->LogicalBockAddress[3];
        pScsiMessage[Lun] = ScsiDrv[Lun].Message;
      }
      else
      {
        BotSendStatus();
      }
      return;
    }
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  BotStatus.BotStatus = TRUE;
  BotInEpStall();
}

/*************************************************************************
 * Function Name: ScsiReadData
 * Parameters: const pInt8U pData, Int32U Size, Boolean DataComplete
 *
 * Return: none
 *
 * Description: Prepare Read data for sending
 *
 *************************************************************************/
void ScsiReadData(const pInt8U pData, Int32U Size, Boolean DataComplete)
{
  BotSendDataInit(pData,Size,DataComplete);
}

/*************************************************************************
 * Function Name: ScsiWrite10Imp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Write (10) command implement
 *
 *************************************************************************/
inline
void ScsiWrite10Imp (void)
{
pSbc2Write10_t pWrite = (pSbc2Write10_t)Cbw.CBWCB;
  if (Cbw.bmCBWFlags.Dir == BotDataFormHostToDev)
  {
    if(ScsiDrv[Lun].UnitSSStatus == UnitEjected)
    {
      ScsiCmdStatus(ScsiMediaNotPresent);
    }
    else
    {
      // Clear condition code info
      ScsiDrv[Lun].Status = ScsiCommandNoKey;
      ScsiDrv[Lun].Message[2] = ((Int32U)pWrite->TransferLength[0] << 8) + pWrite->TransferLength[1];
      if(ScsiDrv[Lun].Message[2] != 0)
      {
        ScsiDrv[Lun].Message[0] = LunWrite10ReqMsg;
        ScsiDrv[Lun].Message[1] = ((Int32U)pWrite->LogicalBockAddress[0] << 24) +\
                                  ((Int32U)pWrite->LogicalBockAddress[1] << 16) +\
                                  ((Int32U)pWrite->LogicalBockAddress[2] << 8 ) +\
                                  pWrite->LogicalBockAddress[3];
        pScsiMessage[Lun] = ScsiDrv[Lun].Message;
        BotState = BotEpDataOut;
        return;
      }
      else
      {
        BotSendStatus();
      }
      return;
    }
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  BotSendStatus();
  BotOutEpStall();
}

/*************************************************************************
 * Function Name: ScsiWriteData
 * Parameters:  pInt8U pData, Int32U Size, Boolean DataComplete
 *
 * Return: none
 *
 * Description: Prepare Write data for receiving
 *
 *************************************************************************/
void ScsiWriteData(pInt8U pData, Int32U Size, Boolean DataComplete)
{
  if(DataComplete)
  {
    BotSendStatus();
  }
  else
  {
    BotReceiveDataInit(pData,Size,DataComplete);
  }
}

/*************************************************************************
 * Function Name: ScsiVerify10Imp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: Verify (10) command implement
 *
 *************************************************************************/
void ScsiVerify10Imp (void)
{
pSbc2Verify10_t pVerify = (pSbc2Verify10_t)Cbw.CBWCB;
  if (Cbw.bmCBWFlags.Dir == BotDataFormHostToDev)
  {
    if(ScsiDrv[Lun].UnitSSStatus == UnitEjected)
    {
      ScsiCmdStatus(ScsiMediaNotPresent);
    }
    else
    {
      // Clear condition code info
      ScsiDrv[Lun].Status = ScsiCommandNoKey;
      ScsiDrv[Lun].Message[2] = ((Int32U)pVerify->TransferLength[0] << 8) + pVerify->TransferLength[1];
      if(ScsiDrv[Lun].Message[2] != 0)
      {
        ScsiDrv[Lun].Message[1] = ((Int32U)pVerify->LogicalBockAddress[0] << 24) +\
                                  ((Int32U)pVerify->LogicalBockAddress[1] << 16) +\
                                  ((Int32U)pVerify->LogicalBockAddress[2] << 8 ) +\
                                  pVerify->LogicalBockAddress[3];
        ScsiDrv[Lun].Message[0] = (pVerify->BYTCHK)?LunVerify10BytChkReqMsg:LunVerify10ReqMsg;
        pScsiMessage[Lun] = ScsiDrv[Lun].Message;
        BotState = BotEpDataOut;
        return;
      }
      else
      {
        BotSendStatus();
      }
      return;
    }
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  BotSendStatus();
  BotOutEpStall();
}

/*************************************************************************
 * Function Name: ScsiReadFormatCapcityImp
 * Parameters:  none
 *
 * Return: none
 *
 * Description: READ FORMAT CAPACITIES implement
 *
 *************************************************************************/
void ScsiReadFormatCapcityImp (void)
{
  if (Cbw.bmCBWFlags.Dir == BotDataFormDevToHost)
  {
    // Clear condition code info
    ScsiDrv[Lun].Status = ScsiCommandNoKey;
    ScsiDrv[Lun].Message[0] = LunReadFormatCapacityReqMsg;
    pScsiMessage[Lun] = ScsiDrv[Lun].Message;
    return;
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  BotStatus.BotStatus = TRUE;
  BotInEpStall();
}

/*************************************************************************
 * Function Name: ScsiReadFormatCapcityData
 * Parameters:  pInt8U pData, Int32U Size
 *
 * Return: none
 *
 * Description: Prepare Data of READ FORMAT CAPACITIES command request
 *
 *************************************************************************/
void ScsiReadFormatCapcityData (pInt8U pData, Int32U Size)

{
pMmc3ReadFormatCapacity_t pFormatCapacity = (pMmc3ReadFormatCapacity_t)Cbw.CBWCB;
Int32U AllocationLength = (pFormatCapacity->AllocationLenght[0]<<8) +\
                           pFormatCapacity->AllocationLenght[1];
  BotSendDataInit(pData,MIN(Size,AllocationLength),TRUE);
}

/*************************************************************************
 * Function Name: ScsiCmdStatus
 * Parameters:  ScsiStatusCode_t Status
 *
 * Return: none
 *
 * Description: Prepare Status data for sending
 *
 *************************************************************************/
void ScsiCmdStatus (ScsiStatusCode_t Status)
{
  ScsiDrv[Lun].Status = Status;
  switch (Status)
  {
  case ScsiCommandNoKey:
    break;
  case ScsiMediamNotReady:
  case ScsiInvalidCbd:
  case ScsiUnknowCommand:
  case ScsiMediaNotPresent:
  case ScsiMediaChanged:
  case ScsiMiscompare:
    BotStatus.CmdFault = TRUE;
    break;
  default:
    BotStatus.PhaseError = TRUE;
  }
}

/*************************************************************************
 * Function Name: ScsiCmdError
 * Parameters:  Int32U Status, Int32U Stall
 *
 * Return: none
 *
 * Description: Prepare Error data for sending
 *
 *************************************************************************/
void ScsiCmdError (Int32U Status, Int32U Stall)
{
  if(Stall & ScsiStallIn)
  {
    BotStatus.BotStatus = TRUE;
    BotInEpStall();
  }
  if (Stall & ScsiStallOut)
  {
    BotOutEpStall();
  }
  ScsiCmdStatus((ScsiStatusCode_t)Status);
  if(!(Stall & ScsiStallIn))
  {
    BotSendStatus();
  }
}

/*************************************************************************
 * Function Name: ScsiMediaStartStopImp
 * Parameters: none
 *
 * Return: none
 *
 * Description: START STOP UNIT command implement
 *
 *************************************************************************/
inline
void ScsiMediaStartStopImp (void)
{
pSpc3UnitStartStop_t pMediaStartStop = (pSpc3UnitStartStop_t)Cbw.CBWCB;
  if (Cbw.dCBWDataTransferLength == 0)
  {
    if (pMediaStartStop->PC == 0)
    {
      if(pMediaStartStop->LOEJ)
      {
        if(pMediaStartStop->START)
        {
          ScsiDrv[Lun].UnitSSStatus = UnitStarted;
        }
        else
        {
          ScsiDrv[Lun].UnitSSStatus = UnitEjected;
        }
      }
      // Clear condition code info
      ScsiCmdStatus(ScsiCommandNoKey);
      BotSendStatus();
    }
    else
    {
      ScsiCmdStatus(ScsiInvalidCbd);
      BotSendStatus();
    }
    return;
  }
  else
  {
    ScsiCmdStatus(ScsiFatalError);
  }
  UsbBotRstInterface();
}