USBH_MSC_CORE_Private_Functions

Collaboration diagram for USBH_MSC_CORE_Private_Functions:

Functions
uint8_t	USBH_MSC_IsReady (USBH_HandleTypeDef *phost)
	USBH_MSC_IsReady The function check if the MSC function is ready. More...
int8_t	USBH_MSC_GetMaxLUN (USBH_HandleTypeDef *phost)
	USBH_MSC_GetMaxLUN The function return the Max LUN supported. More...
uint8_t	USBH_MSC_UnitIsReady (USBH_HandleTypeDef *phost, uint8_t lun)
	USBH_MSC_UnitIsReady The function check whether a LUN is ready. More...
USBH_StatusTypeDef	USBH_MSC_GetLUNInfo (USBH_HandleTypeDef *phost, uint8_t lun, MSC_LUNTypeDef *info)
	USBH_MSC_GetLUNInfo The function return a LUN information. More...
USBH_StatusTypeDef	USBH_MSC_Read (USBH_HandleTypeDef *phost, uint8_t lun, uint32_t address, uint8_t *pbuf, uint32_t length)
	USBH_MSC_Read The function performs a Read operation. More...
USBH_StatusTypeDef	USBH_MSC_Write (USBH_HandleTypeDef *phost, uint8_t lun, uint32_t address, uint8_t *pbuf, uint32_t length)
	USBH_MSC_Write The function performs a Write operation. More...
static USBH_StatusTypeDef	USBH_MSC_InterfaceInit (USBH_HandleTypeDef *phost)
	USBH_MSC_InterfaceInit The function init the MSC class. More...
static USBH_StatusTypeDef	USBH_MSC_InterfaceDeInit (USBH_HandleTypeDef *phost)
	USBH_MSC_InterfaceDeInit The function DeInit the Pipes used for the MSC class. More...
static USBH_StatusTypeDef	USBH_MSC_ClassRequest (USBH_HandleTypeDef *phost)
	USBH_MSC_ClassRequest The function is responsible for handling Standard requests for MSC class. More...
static USBH_StatusTypeDef	USBH_MSC_Process (USBH_HandleTypeDef *phost)
	USBH_MSC_Process The function is for managing state machine for MSC data transfers. More...
static USBH_StatusTypeDef	USBH_MSC_SOFProcess (USBH_HandleTypeDef *phost)
	USBH_MSC_SOFProcess The function is for SOF state. More...
static USBH_StatusTypeDef	USBH_MSC_RdWrProcess (USBH_HandleTypeDef *phost, uint8_t lun)
	USBH_MSC_RdWrProcess The function is for managing state machine for MSC I/O Process. More...

Detailed Description

Function Documentation

USBH_MSC_IsReady()

uint8_t USBH_MSC_IsReady

(

USBH_HandleTypeDef *

phost

)

USBH_MSC_IsReady The function check if the MSC function is ready.

Parameters

phost

Host handle

Return values

USBH

Status

{
    MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if(phost->gState == HOST_CLASS)
  {
    return (MSC_Handle->state == MSC_IDLE);
  }
  else
  {
    return 0;
  }
}

USBH_MSC_GetMaxLUN()

int8_t USBH_MSC_GetMaxLUN

(

USBH_HandleTypeDef *

phost

)

USBH_MSC_GetMaxLUN The function return the Max LUN supported.

Parameters

phost

Host handle

Return values

logical

Unit Number supported

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if ((phost->gState == HOST_CLASS) && (MSC_Handle->state == MSC_IDLE))
  {
    return  MSC_Handle->max_lun;
  }
  return 0xFF;
}

Here is the call graph for this function:

USBH_MSC_UnitIsReady()

uint8_t USBH_MSC_UnitIsReady	(	USBH_HandleTypeDef *	phost,
		uint8_t	lun
	)

USBH_MSC_UnitIsReady The function check whether a LUN is ready.

Parameters

phost	Host handle
lun	logical Unit Number

Return values

Lun	status (0: not ready / 1: ready)

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if(phost->gState == HOST_CLASS)
  {
    return (MSC_Handle->unit[lun].error == MSC_OK);
  }
  else
  {
    return 0;
  }
}

Here is the caller graph for this function:

USBH_MSC_GetLUNInfo()

USBH_StatusTypeDef USBH_MSC_GetLUNInfo	(	USBH_HandleTypeDef *	phost,
		uint8_t	lun,
		MSC_LUNTypeDef *	info
	)

USBH_MSC_GetLUNInfo The function return a LUN information.

Parameters

phost	Host handle
lun	logical Unit Number

Return values

USBH

Status

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
  if(phost->gState == HOST_CLASS)
  {
    USBH_memcpy(info,&MSC_Handle->unit[lun], sizeof(MSC_LUNTypeDef));
    return USBH_OK;
  }
  else
  {
    return USBH_FAIL;
  }
}

Here is the caller graph for this function:

USBH_MSC_Read()

USBH_StatusTypeDef USBH_MSC_Read	(	USBH_HandleTypeDef *	phost,
		uint8_t	lun,
		uint32_t	address,
		uint8_t *	pbuf,
		uint32_t	length
	)

USBH_MSC_Read The function performs a Read operation.

Parameters

phost	Host handle
lun	logical Unit Number
address	sector address
pbuf	pointer to data
length	number of sector to read

Return values

USBH

Status

{
  uint32_t timeout;
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if ((phost->device.is_connected == 0) ||
      (phost->gState != HOST_CLASS) ||
      (MSC_Handle->unit[lun].state != MSC_IDLE))
  {
    return  USBH_FAIL;
  }
  MSC_Handle->state = MSC_READ;
  MSC_Handle->unit[lun].state = MSC_READ;
  MSC_Handle->rw_lun = lun;
  USBH_MSC_SCSI_Read(phost,
                     lun,
                     address,
                     pbuf,
                     length);
 
  timeout = phost->Timer;
 
  while (USBH_MSC_RdWrProcess(phost, lun) == USBH_BUSY)
  {
    if(((phost->Timer - timeout) > (10000 * length)) || (phost->device.is_connected == 0))
    {
      MSC_Handle->state = MSC_IDLE;
      return USBH_FAIL;
    }
  }
  MSC_Handle->state = MSC_IDLE;
  return USBH_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

USBH_MSC_Write()

USBH_StatusTypeDef USBH_MSC_Write	(	USBH_HandleTypeDef *	phost,
		uint8_t	lun,
		uint32_t	address,
		uint8_t *	pbuf,
		uint32_t	length
	)

USBH_MSC_Write The function performs a Write operation.

Parameters

phost	Host handle
lun	logical Unit Number
address	sector address
pbuf	pointer to data
length	number of sector to write

Return values

USBH

Status

{
  uint32_t timeout;
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if ((phost->device.is_connected == 0) ||
      (phost->gState != HOST_CLASS) ||
      (MSC_Handle->unit[lun].state != MSC_IDLE))
  {
    return  USBH_FAIL;
  }
  MSC_Handle->state = MSC_WRITE;
  MSC_Handle->unit[lun].state = MSC_WRITE;
  MSC_Handle->rw_lun = lun;
  USBH_MSC_SCSI_Write(phost,
                     lun,
                     address,
                     pbuf,
                     length);
 
  timeout = phost->Timer;
  while (USBH_MSC_RdWrProcess(phost, lun) == USBH_BUSY)
  {
    if(((phost->Timer - timeout) >  (10000 * length)) || (phost->device.is_connected == 0))
    {
      MSC_Handle->state = MSC_IDLE;
      return USBH_FAIL;
    }
  }
  MSC_Handle->state = MSC_IDLE;
  return USBH_OK;
}

Here is the call graph for this function:

USBH_MSC_InterfaceInit()

static USBH_StatusTypeDef USBH_MSC_InterfaceInit ( USBH_HandleTypeDef *  phost )

static

USBH_MSC_InterfaceInit The function init the MSC class.

Parameters

phost

Host handle

Return values

USBH

Status

{
  uint8_t interface = 0;
  USBH_StatusTypeDef status = USBH_FAIL ;
  MSC_HandleTypeDef *MSC_Handle;
 
  interface = USBH_FindInterface(phost, phost->pActiveClass->ClassCode, MSC_TRANSPARENT, MSC_BOT);
 
  if(interface == 0xFF) /* Not Valid Interface */
  {
    USBH_DbgLog ("Cannot Find the interface for %s class.", phost->pActiveClass->Name);
    status = USBH_FAIL;
  }
  else
  {
    USBH_SelectInterface (phost, interface);
 
    phost->pActiveClass->pData = (MSC_HandleTypeDef *)USBH_malloc (sizeof(MSC_HandleTypeDef));
    MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
    if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress & 0x80)
    {
      MSC_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress);
      MSC_Handle->InEpSize  = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
    }
    else
    {
      MSC_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress);
      MSC_Handle->OutEpSize  = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
    }
 
    if(phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress & 0x80)
    {
      MSC_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress);
      MSC_Handle->InEpSize  = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].wMaxPacketSize;
    }
    else
    {
      MSC_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].bEndpointAddress);
      MSC_Handle->OutEpSize  = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[1].wMaxPacketSize;
    }
 
    MSC_Handle->current_lun = 0;
    MSC_Handle->rw_lun = 0;
    MSC_Handle->state = MSC_INIT;
    MSC_Handle->error = MSC_OK;
    MSC_Handle->req_state = MSC_REQ_IDLE;
    MSC_Handle->OutPipe = USBH_AllocPipe(phost, MSC_Handle->OutEp);
    MSC_Handle->InPipe = USBH_AllocPipe(phost, MSC_Handle->InEp);
 
    USBH_MSC_BOT_Init(phost);
 
    /* De-Initialize LUNs information */
    USBH_memset(MSC_Handle->unit, 0, sizeof(MSC_Handle->unit));
 
    /* Open the new channels */
    USBH_OpenPipe  (phost,
                    MSC_Handle->OutPipe,
                    MSC_Handle->OutEp,
                    phost->device.address,
                    phost->device.speed,
                    USB_EP_TYPE_BULK,
                    MSC_Handle->OutEpSize);
 
    USBH_OpenPipe  (phost,
                    MSC_Handle->InPipe,
                    MSC_Handle->InEp,
                    phost->device.address,
                    phost->device.speed,
                    USB_EP_TYPE_BULK,
                    MSC_Handle->InEpSize);
 
 
    USBH_LL_SetToggle  (phost, MSC_Handle->InPipe,0);
    USBH_LL_SetToggle  (phost, MSC_Handle->OutPipe,0);
    status = USBH_OK;
  }
  return status;
}

Here is the call graph for this function:

USBH_MSC_InterfaceDeInit()

USBH_StatusTypeDef USBH_MSC_InterfaceDeInit ( USBH_HandleTypeDef *  phost )

static

USBH_MSC_InterfaceDeInit The function DeInit the Pipes used for the MSC class.

Parameters

phost

Host handle

Return values

USBH

Status

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
 
  if ( MSC_Handle->OutPipe)
  {
    USBH_ClosePipe(phost, MSC_Handle->OutPipe);
    USBH_FreePipe  (phost, MSC_Handle->OutPipe);
    MSC_Handle->OutPipe = 0;     /* Reset the Channel as Free */
  }
 
  if ( MSC_Handle->InPipe)
  {
    USBH_ClosePipe(phost, MSC_Handle->InPipe);
    USBH_FreePipe  (phost, MSC_Handle->InPipe);
    MSC_Handle->InPipe = 0;     /* Reset the Channel as Free */
  }
 
  if(phost->pActiveClass->pData)
  {
    USBH_free (phost->pActiveClass->pData);
    phost->pActiveClass->pData = 0;
  }
 
  return USBH_OK;
}

Here is the call graph for this function:

USBH_MSC_ClassRequest()

static USBH_StatusTypeDef USBH_MSC_ClassRequest ( USBH_HandleTypeDef *  phost )

static

USBH_MSC_ClassRequest The function is responsible for handling Standard requests for MSC class.

Parameters

phost

Host handle

Return values

USBH

Status

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
  USBH_StatusTypeDef status = USBH_BUSY;
  uint8_t i;
 
  /* Switch MSC REQ state machine */
  switch (MSC_Handle->req_state)
  {
  case MSC_REQ_IDLE:
  case MSC_REQ_GET_MAX_LUN:
    /* Issue GetMaxLUN request */
    status = USBH_MSC_BOT_REQ_GetMaxLUN(phost, (uint8_t *)&MSC_Handle->max_lun);
 
    /* When devices do not support the GetMaxLun request, this should
       be considred as only one logical unit is supported */
    if(status == USBH_NOT_SUPPORTED)
    {
      MSC_Handle->max_lun = 0;
      status = USBH_OK;
    }
 
    if(status == USBH_OK)
    {
      MSC_Handle->max_lun = (uint8_t )(MSC_Handle->max_lun) + 1;
      USBH_UsrLog ("Number of supported LUN: %lu", (int32_t)(MSC_Handle->max_lun));
 
      for(i = 0; i < MSC_Handle->max_lun; i++)
      {
        MSC_Handle->unit[i].prev_ready_state = USBH_FAIL;
        MSC_Handle->unit[i].state_changed = 0;
      }
    }
    break;
 
  case MSC_REQ_ERROR :
    /* a Clear Feature should be issued here */
    if(USBH_ClrFeature(phost, 0x00) == USBH_OK)
    {
      MSC_Handle->req_state = MSC_Handle->prev_req_state;
    }
    break;
 
  default:
    break;
  }
 
  return status;
}

Here is the call graph for this function:

USBH_MSC_Process()

static USBH_StatusTypeDef USBH_MSC_Process ( USBH_HandleTypeDef *  phost )

static

USBH_MSC_Process The function is for managing state machine for MSC data transfers.

Parameters

phost

Host handle

Return values

USBH

Status

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
  USBH_StatusTypeDef error = USBH_BUSY ;
  USBH_StatusTypeDef scsi_status = USBH_BUSY ;
  USBH_StatusTypeDef ready_status = USBH_BUSY ;
 
  switch (MSC_Handle->state)
  {
  case MSC_INIT:
 
    if(MSC_Handle->current_lun < MSC_Handle->max_lun)
    {
 
      MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_NOT_READY;
      /* Switch MSC REQ state machine */
      switch (MSC_Handle->unit[MSC_Handle->current_lun].state)
      {
      case MSC_INIT:
        USBH_UsrLog ("LUN #%d: ", MSC_Handle->current_lun);
        MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_READ_INQUIRY;
        MSC_Handle->timer = phost->Timer;
 
      case MSC_READ_INQUIRY:
        scsi_status = USBH_MSC_SCSI_Inquiry(phost, MSC_Handle->current_lun, &MSC_Handle->unit[MSC_Handle->current_lun].inquiry);
 
        if( scsi_status == USBH_OK)
        {
          USBH_UsrLog ("Inquiry Vendor  : %s", MSC_Handle->unit[MSC_Handle->current_lun].inquiry.vendor_id);
          USBH_UsrLog ("Inquiry Product : %s", MSC_Handle->unit[MSC_Handle->current_lun].inquiry.product_id);
          USBH_UsrLog ("Inquiry Version : %s", MSC_Handle->unit[MSC_Handle->current_lun].inquiry.revision_id);
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_TEST_UNIT_READY;
        }
        if( scsi_status == USBH_FAIL)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_REQUEST_SENSE;
        }
        else if(scsi_status == USBH_UNRECOVERED_ERROR)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_ERROR;
        }
        break;
 
      case MSC_TEST_UNIT_READY:
        ready_status = USBH_MSC_SCSI_TestUnitReady(phost, MSC_Handle->current_lun);
 
        if( ready_status == USBH_OK)
        {
          if( MSC_Handle->unit[MSC_Handle->current_lun].prev_ready_state != USBH_OK)
          {
            MSC_Handle->unit[MSC_Handle->current_lun].state_changed = 1;
            USBH_UsrLog ("MSC Device ready");
          }
          else
          {
            MSC_Handle->unit[MSC_Handle->current_lun].state_changed = 0;
          }
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_READ_CAPACITY10;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_OK;
          MSC_Handle->unit[MSC_Handle->current_lun].prev_ready_state = USBH_OK;
        }
        if( ready_status == USBH_FAIL)
        {
          /* Media not ready, so try to check again during 10s */
          if( MSC_Handle->unit[MSC_Handle->current_lun].prev_ready_state != USBH_FAIL)
          {
            MSC_Handle->unit[MSC_Handle->current_lun].state_changed = 1;
            USBH_UsrLog ("MSC Device NOT ready");
          }
          else
          {
            MSC_Handle->unit[MSC_Handle->current_lun].state_changed = 0;
          }
            MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_REQUEST_SENSE;
            MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_NOT_READY;
            MSC_Handle->unit[MSC_Handle->current_lun].prev_ready_state = USBH_FAIL;
        }
        else if(ready_status == USBH_UNRECOVERED_ERROR)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_ERROR;
        }
        break;
 
      case MSC_READ_CAPACITY10:
        scsi_status = USBH_MSC_SCSI_ReadCapacity(phost,MSC_Handle->current_lun, &MSC_Handle->unit[MSC_Handle->current_lun].capacity) ;
 
        if(scsi_status == USBH_OK)
        {
          if(MSC_Handle->unit[MSC_Handle->current_lun].state_changed == 1)
          {
            USBH_UsrLog ("MSC Device capacity : %lu Bytes", \
              (int32_t)(MSC_Handle->unit[MSC_Handle->current_lun].capacity.block_nbr * MSC_Handle->unit[MSC_Handle->current_lun].capacity.block_size));
            USBH_UsrLog ("Block number : %lu", (int32_t)(MSC_Handle->unit[MSC_Handle->current_lun].capacity.block_nbr));
            USBH_UsrLog ("Block Size   : %lu", (int32_t)(MSC_Handle->unit[MSC_Handle->current_lun].capacity.block_size));
          }
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_OK;
          MSC_Handle->current_lun++;
        }
        else if( scsi_status == USBH_FAIL)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_REQUEST_SENSE;
        }
        else if(scsi_status == USBH_UNRECOVERED_ERROR)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_ERROR;
        }
        break;
 
      case MSC_REQUEST_SENSE:
        scsi_status = USBH_MSC_SCSI_RequestSense(phost,  MSC_Handle->current_lun, &MSC_Handle->unit[MSC_Handle->current_lun].sense);
 
        if( scsi_status == USBH_OK)
        {
          if((MSC_Handle->unit[MSC_Handle->current_lun].sense.key == SCSI_SENSE_KEY_UNIT_ATTENTION) ||
             (MSC_Handle->unit[MSC_Handle->current_lun].sense.key == SCSI_SENSE_KEY_NOT_READY) )
          {
 
            if((phost->Timer - MSC_Handle->timer) < 10000)
            {
              MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_TEST_UNIT_READY;
              break;
            }
          }
 
          USBH_UsrLog ("Sense Key  : %x", MSC_Handle->unit[MSC_Handle->current_lun].sense.key);
          USBH_UsrLog ("Additional Sense Code : %x", MSC_Handle->unit[MSC_Handle->current_lun].sense.asc);
          USBH_UsrLog ("Additional Sense Code Qualifier: %x", MSC_Handle->unit[MSC_Handle->current_lun].sense.ascq);
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->current_lun++;
        }
        if( scsi_status == USBH_FAIL)
        {
          USBH_UsrLog ("MSC Device NOT ready");
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_UNRECOVERED_ERROR;
        }
        else if(scsi_status == USBH_UNRECOVERED_ERROR)
        {
          MSC_Handle->unit[MSC_Handle->current_lun].state = MSC_IDLE;
          MSC_Handle->unit[MSC_Handle->current_lun].error = MSC_ERROR;
        }
        break;
 
      case MSC_UNRECOVERED_ERROR:
        MSC_Handle->current_lun++;
        break;
 
      default:
        break;
      }
 
#if (USBH_USE_OS == 1)
    osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
    }
    else
    {
      MSC_Handle->current_lun = 0;
    MSC_Handle->state = MSC_IDLE;
#if (USBH_USE_OS == 1)
    osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
    phost->pUser(phost, HOST_USER_CLASS_ACTIVE);
    }
    break;
 
  case MSC_IDLE:
    error = USBH_OK;
    break;
 
  default:
    break;
  }
  return error;
}

Here is the call graph for this function:

USBH_MSC_SOFProcess()

static USBH_StatusTypeDef USBH_MSC_SOFProcess ( USBH_HandleTypeDef *  phost )

static

USBH_MSC_SOFProcess The function is for SOF state.

Parameters

phost

Host handle

Return values

USBH

Status

{
 
  return USBH_OK;
}

USBH_MSC_RdWrProcess()

static USBH_StatusTypeDef USBH_MSC_RdWrProcess ( USBH_HandleTypeDef *  phost, uint8_t  lun  )

static

USBH_MSC_RdWrProcess The function is for managing state machine for MSC I/O Process.

Parameters

phost	Host handle
lun	logical Unit Number

Return values

USBH

Status

{
  MSC_HandleTypeDef *MSC_Handle =  (MSC_HandleTypeDef *) phost->pActiveClass->pData;
  USBH_StatusTypeDef error = USBH_BUSY ;
  USBH_StatusTypeDef scsi_status = USBH_BUSY ;
 
  /* Switch MSC REQ state machine */
  switch (MSC_Handle->unit[lun].state)
  {
 
  case MSC_READ:
    scsi_status = USBH_MSC_SCSI_Read(phost,lun, 0, NULL, 0) ;
 
    if(scsi_status == USBH_OK)
    {
      MSC_Handle->unit[lun].state = MSC_IDLE;
      error = USBH_OK;
    }
    else if( scsi_status == USBH_FAIL)
    {
      MSC_Handle->unit[lun].state = MSC_REQUEST_SENSE;
    }
    else if(scsi_status == USBH_UNRECOVERED_ERROR)
    {
      MSC_Handle->unit[lun].state = MSC_UNRECOVERED_ERROR;
          error = USBH_FAIL;
    }
#if (USBH_USE_OS == 1)
    osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
    break;
 
  case MSC_WRITE:
    scsi_status = USBH_MSC_SCSI_Write(phost,lun, 0, NULL, 0) ;
 
    if(scsi_status == USBH_OK)
    {
        MSC_Handle->unit[lun].state = MSC_IDLE;
        error = USBH_OK;
    }
    else if( scsi_status == USBH_FAIL)
    {
      MSC_Handle->unit[lun].state = MSC_REQUEST_SENSE;
    }
    else if(scsi_status == USBH_UNRECOVERED_ERROR)
    {
      MSC_Handle->unit[lun].state = MSC_UNRECOVERED_ERROR;
          error = USBH_FAIL;
    }
#if (USBH_USE_OS == 1)
    osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
    break;
 
  case MSC_REQUEST_SENSE:
    scsi_status = USBH_MSC_SCSI_RequestSense(phost, lun, &MSC_Handle->unit[lun].sense);
 
    if( scsi_status == USBH_OK)
    {
      USBH_UsrLog ("Sense Key  : %x", MSC_Handle->unit[lun].sense.key);
      USBH_UsrLog ("Additional Sense Code : %x", MSC_Handle->unit[lun].sense.asc);
      USBH_UsrLog ("Additional Sense Code Qualifier: %x", MSC_Handle->unit[lun].sense.ascq);
      MSC_Handle->unit[lun].state = MSC_IDLE;
      MSC_Handle->unit[lun].error = MSC_ERROR;
 
      error = USBH_FAIL;
    }
    if( scsi_status == USBH_FAIL)
    {
      USBH_UsrLog ("MSC Device NOT ready");
    }
    else if(scsi_status == USBH_UNRECOVERED_ERROR)
    {
      MSC_Handle->unit[lun].state = MSC_UNRECOVERED_ERROR;
          error = USBH_FAIL;
    }
#if (USBH_USE_OS == 1)
    osMessagePut ( phost->os_event, USBH_CLASS_EVENT, 0);
#endif
    break;
 
  default:
    break;
 
  }
  return error;
}

Here is the call graph for this function:

Here is the caller graph for this function: