usbd_msc_bot.c

Go to the documentation of this file.

/* Includes ------------------------------------------------------------------*/
#include "usbd_msc_bot.h"
#include "usbd_msc_scsi.h"
#include "usbd_ioreq.h"
#include "usbd_msc_mem.h"

uint16_t             MSC_BOT_DataLen;
uint8_t              MSC_BOT_State;
uint8_t              MSC_BOT_Status;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  #if defined ( __ICCARM__ ) 
    #pragma data_alignment=4   
  #endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN uint8_t              MSC_BOT_Data[MSC_MEDIA_PACKET] __ALIGN_END ;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  #if defined ( __ICCARM__ ) 
    #pragma data_alignment=4   
  #endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN MSC_BOT_CBW_TypeDef  MSC_BOT_cbw __ALIGN_END ;

#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
  #if defined ( __ICCARM__ ) 
    #pragma data_alignment=4   
  #endif
#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
__ALIGN_BEGIN MSC_BOT_CSW_TypeDef  MSC_BOT_csw __ALIGN_END ;
static void MSC_BOT_CBW_Decode (USB_OTG_CORE_HANDLE  *pdev);

static void MSC_BOT_SendData (USB_OTG_CORE_HANDLE  *pdev, 
                              uint8_t* pbuf, 
                              uint16_t len);

static void MSC_BOT_Abort(USB_OTG_CORE_HANDLE  *pdev);
void MSC_BOT_Init (USB_OTG_CORE_HANDLE  *pdev)
{
  MSC_BOT_State = BOT_IDLE;
  MSC_BOT_Status = BOT_STATE_NORMAL;
  USBD_STORAGE_fops->Init(0);
  
  DCD_EP_Flush(pdev, MSC_OUT_EP);
  DCD_EP_Flush(pdev, MSC_IN_EP);
  /* Prapare EP to Receive First BOT Cmd */
  DCD_EP_PrepareRx (pdev,
                    MSC_OUT_EP,
                    (uint8_t *)&MSC_BOT_cbw,
                    BOT_CBW_LENGTH);    
}

void MSC_BOT_Reset (USB_OTG_CORE_HANDLE  *pdev)
{
  MSC_BOT_State = BOT_IDLE;
  MSC_BOT_Status = BOT_STATE_RECOVERY;
  /* Prapare EP to Receive First BOT Cmd */
  DCD_EP_PrepareRx (pdev,
                    MSC_OUT_EP,
                    (uint8_t *)&MSC_BOT_cbw,
                    BOT_CBW_LENGTH);    
}

void MSC_BOT_DeInit (USB_OTG_CORE_HANDLE  *pdev)
{
  MSC_BOT_State = BOT_IDLE;
}

void MSC_BOT_DataIn (USB_OTG_CORE_HANDLE  *pdev, 
                     uint8_t epnum)
{
  
  switch (MSC_BOT_State)
  {
  case BOT_DATA_IN:
    if(SCSI_ProcessCmd(pdev,
                        MSC_BOT_cbw.bLUN,
                        &MSC_BOT_cbw.CB[0]) < 0)
    {
      MSC_BOT_SendCSW (pdev, CSW_CMD_FAILED);
    }
    break;
    
  case BOT_SEND_DATA:
  case BOT_LAST_DATA_IN:
    MSC_BOT_SendCSW (pdev, CSW_CMD_PASSED);
    
    break;
    
  default:
    break;
  }
}
void MSC_BOT_DataOut (USB_OTG_CORE_HANDLE  *pdev, 
                      uint8_t epnum)
{
  switch (MSC_BOT_State)
  {
  case BOT_IDLE:
    MSC_BOT_CBW_Decode(pdev);
    break;
    
  case BOT_DATA_OUT:
    
    if(SCSI_ProcessCmd(pdev,
                        MSC_BOT_cbw.bLUN,
                        &MSC_BOT_cbw.CB[0]) < 0)
    {
      MSC_BOT_SendCSW (pdev, CSW_CMD_FAILED);
    }

    break;
    
  default:
    break;
  }
  
}

static void  MSC_BOT_CBW_Decode (USB_OTG_CORE_HANDLE  *pdev)
{

  MSC_BOT_csw.dTag = MSC_BOT_cbw.dTag;
  MSC_BOT_csw.dDataResidue = MSC_BOT_cbw.dDataLength;
  
  if ((USBD_GetRxCount (pdev ,MSC_OUT_EP) != BOT_CBW_LENGTH) ||
      (MSC_BOT_cbw.dSignature != BOT_CBW_SIGNATURE)||
        (MSC_BOT_cbw.bLUN > 1) || 
          (MSC_BOT_cbw.bCBLength < 1) || 
            (MSC_BOT_cbw.bCBLength > 16))
  {
    
    SCSI_SenseCode(MSC_BOT_cbw.bLUN, 
                   ILLEGAL_REQUEST, 
                   INVALID_CDB);
     MSC_BOT_Status = BOT_STATE_ERROR;   
     MSC_BOT_Abort(pdev);
     return;
  }

    if(SCSI_ProcessCmd(pdev,  MSC_BOT_cbw.bLUN,
                              &MSC_BOT_cbw.CB[0]) < 0){
          MSC_BOT_Abort(pdev);
      
          return;
    }

    // MSC_BOT_CBW_finish(); moved out to SCSI task

}


void  MSC_BOT_CBW_finish (USB_OTG_CORE_HANDLE  *pdev){
    /*Burst xfer handled internally*/    
    if ((MSC_BOT_State != BOT_DATA_IN) && 
             (MSC_BOT_State != BOT_DATA_OUT) && 
             (MSC_BOT_State != BOT_LAST_DATA_IN))  // idle or BOT_SEND_DATA
    {
      if (MSC_BOT_DataLen > 0)  {
        MSC_BOT_SendData(pdev,
                         MSC_BOT_Data, 
                         MSC_BOT_DataLen);
        MSC_BOT_DataLen=0;
      } else if (MSC_BOT_DataLen == 0) {
        MSC_BOT_SendCSW (pdev,
                         CSW_CMD_PASSED);
      }
    }
}


static void  MSC_BOT_SendData(USB_OTG_CORE_HANDLE  *pdev,
                              uint8_t* buf, 
                              uint16_t len)
{
  
  len = MIN (MSC_BOT_cbw.dDataLength, len);
  MSC_BOT_csw.dDataResidue -= len;
  MSC_BOT_csw.bStatus = CSW_CMD_PASSED;
  MSC_BOT_State = BOT_SEND_DATA;
  
  DCD_EP_Tx (pdev, MSC_IN_EP, buf, len);  
}

void  MSC_BOT_SendCSW (USB_OTG_CORE_HANDLE  *pdev,
                              uint8_t CSW_Status)
{
  MSC_BOT_csw.dSignature = BOT_CSW_SIGNATURE;
  MSC_BOT_csw.bStatus = CSW_Status;
  MSC_BOT_State = BOT_IDLE;
  
  DCD_EP_Tx (pdev, 
             MSC_IN_EP, 
             (uint8_t *)&MSC_BOT_csw, 
             BOT_CSW_LENGTH);
  
  /* Prapare EP to Receive next Cmd */
  DCD_EP_PrepareRx (pdev,
                    MSC_OUT_EP,
                    (uint8_t *)&MSC_BOT_cbw, 
                    BOT_CBW_LENGTH);  
  
}

static void  MSC_BOT_Abort (USB_OTG_CORE_HANDLE  *pdev)
{

  if ((MSC_BOT_cbw.bmFlags == 0) && 
      (MSC_BOT_cbw.dDataLength != 0) &&
      (MSC_BOT_Status == BOT_STATE_NORMAL) )
  {
    DCD_EP_Stall(pdev, MSC_OUT_EP );
  }
  DCD_EP_Stall(pdev, MSC_IN_EP);
  
  if(MSC_BOT_Status == BOT_STATE_ERROR)
  {
    DCD_EP_PrepareRx (pdev,
                      MSC_OUT_EP,
                      (uint8_t *)&MSC_BOT_cbw, 
                      BOT_CBW_LENGTH);    
  }
}

void  MSC_BOT_CplClrFeature (USB_OTG_CORE_HANDLE  *pdev, uint8_t epnum)
{
  if(MSC_BOT_Status == BOT_STATE_ERROR )/* Bad CBW Signature */
  {
    DCD_EP_Stall(pdev, MSC_IN_EP);
    MSC_BOT_Status = BOT_STATE_NORMAL;    
  }
  else if(((epnum & 0x80) == 0x80) && ( MSC_BOT_Status != BOT_STATE_RECOVERY))
  {
    MSC_BOT_SendCSW (pdev, CSW_CMD_FAILED);
  }
  
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/