You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

368 lines
12 KiB

3 years ago
/*!
\file usbh_msc_core.c
\brief USB MSC(mass storage device) class driver
\version 2019-06-05, V1.0.0, firmware for GD32VF103
*/
/*
Copyright (c) 2019, GigaDevice Semiconductor Inc.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/
#include "usbh_pipe.h"
#include "usbh_transc.h"
#include "usbh_msc_core.h"
#include "usbh_msc_scsi.h"
#include "usbh_msc_bbb.h"
#define USBH_MSC_ERROR_RETRY_LIMIT 10
uint8_t msc_error_count = 0;
usbh_msc_machine msc_machine;
static void usbh_msc_itf_deinit (usb_core_driver *pudev, void *puhost);
static usbh_status usbh_msc_itf_init (usb_core_driver *pudev, void *puhost);
static usbh_status usbh_msc_handle (usb_core_driver *pudev, void *puhost);
static usbh_status usbh_msc_req (usb_core_driver *pudev, void *puhost);
static usbh_status usbh_msc_maxlun_get (usb_core_driver *pudev, usbh_host *puhost);
usbh_class_cb usbh_msc_cb =
{
usbh_msc_itf_init,
usbh_msc_itf_deinit,
usbh_msc_req,
usbh_msc_handle,
};
void usbh_msc_error_handle (uint8_t status);
/*!
\brief interface initialization for MSC class
\param[in] pudev: pointer to usb core instance
\param[in] puhost: pointer to usb host
\param[out] none
\retval operation status
*/
static usbh_status usbh_msc_itf_init (usb_core_driver *pudev, void *puhost)
{
usbh_host *pphost = puhost;
usb_desc_itf *itf_desc = &pphost->dev_prop.itf_desc[0];
if ((itf_desc->bInterfaceClass == MSC_CLASS) &&
(itf_desc->bInterfaceProtocol == MSC_PROTOCOL)) {
usb_desc_ep *ep_desc = &pphost->dev_prop.ep_desc[0][0];
if (ep_desc->bEndpointAddress & 0x80) {
msc_machine.msc_bulk_epin = ep_desc->bEndpointAddress;
msc_machine.msc_bulk_epinsize = ep_desc->wMaxPacketSize;
} else {
msc_machine.msc_bulk_epout = ep_desc->bEndpointAddress;
msc_machine.msc_bulk_epoutsize = ep_desc->wMaxPacketSize;
}
ep_desc = &pphost->dev_prop.ep_desc[0][1];
if (ep_desc->bEndpointAddress & 0x80) {
msc_machine.msc_bulk_epin = ep_desc->bEndpointAddress;
msc_machine.msc_bulk_epinsize = ep_desc->wMaxPacketSize;
} else {
msc_machine.msc_bulk_epout = ep_desc->bEndpointAddress;
msc_machine.msc_bulk_epoutsize = ep_desc->wMaxPacketSize;
}
msc_machine.hc_num_out = usbh_pipe_allocate(pudev, msc_machine.msc_bulk_epout);
msc_machine.hc_num_in = usbh_pipe_allocate(pudev, msc_machine.msc_bulk_epin);
/* open the new channels */
usbh_pipe_create (pudev,
&pphost->dev_prop,
msc_machine.hc_num_out,
USB_EPTYPE_BULK,
msc_machine.msc_bulk_epoutsize);
usbh_pipe_create (pudev,
&pphost->dev_prop,
msc_machine.hc_num_in,
USB_EPTYPE_BULK,
msc_machine.msc_bulk_epinsize);
} else {
pphost->usr_cb->dev_not_supported();
}
return USBH_OK;
}
/*!
\brief de-initialize interface by freeing host channels allocated to interface
\param[in] pudev: pointer to usb core instance
\param[in] puhost: pointer to usb host
\param[out] none
\retval operation status
*/
void usbh_msc_itf_deinit (usb_core_driver *pudev, void *puhost)
{
if (msc_machine.hc_num_out) {
usb_pipe_halt (pudev, msc_machine.hc_num_out);
usbh_pipe_free (pudev, msc_machine.hc_num_out);
msc_machine.hc_num_out = 0;
}
if (msc_machine.hc_num_in) {
usb_pipe_halt (pudev, msc_machine.hc_num_in);
usbh_pipe_free (pudev, msc_machine.hc_num_in);
msc_machine.hc_num_in = 0;
}
}
/*!
\brief initialize the MSC state machine
\param[in] pudev: pointer to usb core instance
\param[in] puhost: pointer to usb host
\param[out] none
\retval operation status
*/
static usbh_status usbh_msc_req (usb_core_driver *pudev, void *puhost)
{
usbh_status status = USBH_OK;
msc_botxfer_param.msc_state = USBH_MSC_BOT_INIT_STATE;
return status;
}
/*!
\brief MSC state machine handler
\param[in] pudev: pointer to usb core instance
\param[in] puhost: pointer to usb host
\param[out] none
\retval operation status
*/
static usbh_status usbh_msc_handle (usb_core_driver *pudev, void *puhost)
{
usbh_host *pphost = puhost;
usbh_status status = USBH_BUSY;
uint8_t msc_status = USBH_MSC_BUSY;
uint8_t app_status = 0;
static uint8_t max_lun_exceed = FALSE;
if (pudev->host.connect_status) {
switch (msc_botxfer_param.msc_state) {
case USBH_MSC_BOT_INIT_STATE:
usbh_msc_init(pudev);
msc_botxfer_param.msc_state = USBH_MSC_BOT_RESET;
break;
case USBH_MSC_BOT_RESET:
status = USBH_OK;
msc_botxfer_param.msc_state = USBH_MSC_GET_MAX_LUN;
break;
case USBH_MSC_GET_MAX_LUN:
/* issue Get_MaxLun request */
status = usbh_msc_maxlun_get (pudev, puhost);
if (status == USBH_OK) {
msc_machine.max_lun = *(msc_machine.buf);
/* if device has more that one logical unit then it is not supported */
if ((msc_machine.max_lun > 0) && (max_lun_exceed == FALSE)) {
max_lun_exceed = TRUE;
//pphost->usr_cb->dev_not_supported();
break;
}
msc_botxfer_param.msc_state = USBH_MSC_TEST_UNIT_READY;
}
if (status == USBH_NOT_SUPPORTED) {
/* if the command has failed, then we need to move to next state, after
STALL condition is cleared by Control-Transfer */
msc_botxfer_param.msc_state_bkp = USBH_MSC_TEST_UNIT_READY;
/* a clear feature should be issued here */
msc_botxfer_param.msc_state = USBH_MSC_CTRL_ERROR_STATE;
}
break;
case USBH_MSC_CTRL_ERROR_STATE:
/* issue clearfeature request */
status = usbh_clrfeature(pudev,
puhost,
0x00,
pphost->control.pipe_out_num);
if (status == USBH_OK) {
/* if GetMaxLun request not support, assume single LUN configuration */
msc_machine.max_lun = 0;
msc_botxfer_param.msc_state = msc_botxfer_param.msc_state_bkp;
}
break;
case USBH_MSC_TEST_UNIT_READY:
/* issue SCSI command TestUnitReady */
msc_status = usbh_msc_test_unitready(pudev);
if (msc_status == USBH_MSC_OK) {
msc_botxfer_param.msc_state = USBH_MSC_READ_CAPACITY10;
msc_error_count = 0;
status = USBH_OK;
} else {
usbh_msc_error_handle (msc_status);
}
break;
case USBH_MSC_READ_CAPACITY10:
/* issue READ_CAPACITY10 SCSI command */
msc_status = usbh_msc_read_capacity10(pudev);
if (msc_status == USBH_MSC_OK) {
msc_botxfer_param.msc_state = USBH_MSC_MODE_SENSE6;
msc_error_count = 0;
status = USBH_OK;
} else {
usbh_msc_error_handle (msc_status);
}
break;
case USBH_MSC_MODE_SENSE6:
/* issue ModeSense6 SCSI command for detecting if device is write-protected */
msc_status = usbh_msc_mode_sense6 (pudev);
if (msc_status == USBH_MSC_OK) {
msc_botxfer_param.msc_state = USBH_MSC_DEFAULT_APPLI_STATE;
msc_error_count = 0;
status = USBH_OK;
} else {
usbh_msc_error_handle (msc_status);
}
break;
case USBH_MSC_REQUEST_SENSE:
/* issue RequestSense SCSI command for retreiving error code */
msc_status = usbh_msc_request_sense (pudev);
if (msc_status == USBH_MSC_OK) {
msc_botxfer_param.msc_state = msc_botxfer_param.msc_state_bkp;
status = USBH_OK;
} else {
usbh_msc_error_handle (msc_status);
}
break;
case USBH_MSC_BOT_USB_TRANSFERS:
/* process the BOT state machine */
usbh_msc_botxfer(pudev , puhost);
break;
case USBH_MSC_DEFAULT_APPLI_STATE:
/* process application callback for MSC */
app_status = pphost->usr_cb->dev_user_app();
if (app_status == 0) {
msc_botxfer_param.msc_state = USBH_MSC_DEFAULT_APPLI_STATE;
} else if (app_status == 1) {
/* de-init requested from application layer */
status = USBH_APPLY_DEINIT;
}
break;
case USBH_MSC_UNRECOVERED_STATE:
status = USBH_UNRECOVERED_ERROR;
break;
default:
break;
}
}
return status;
}
/*!
\brief get max lun of the mass storage device
\param[in] pudev: pointer to usb core instance
\param[in] puhost: pointer to usb host
\param[out] none
\retval operation status
*/
static usbh_status usbh_msc_maxlun_get (usb_core_driver *pudev, usbh_host *puhost)
{
usbh_status status = USBH_BUSY;
if (puhost->control.ctl_state == CTL_IDLE) {
puhost->control.setup.req = (usb_req) {
.bmRequestType = USB_TRX_IN | USB_REQTYPE_CLASS | USB_RECPTYPE_ITF,
.bRequest = BBB_GET_MAX_LUN,
.wValue = 0,
.wIndex = 0,
.wLength = 1
};
usbh_ctlstate_config (puhost, msc_machine.buf, 1);
}
status = usbh_ctl_handler (pudev, puhost);
return status;
}
/*!
\brief handling errors occuring during the MSC state machine
\param[in] status: error status
\param[out] none
\retval operation status
*/
void usbh_msc_error_handle (uint8_t status)
{
if (status == USBH_MSC_FAIL) {
msc_error_count++;
if (msc_error_count < USBH_MSC_ERROR_RETRY_LIMIT) {
/* try msc level error recovery, issue the request sense to get drive error reason */
msc_botxfer_param.msc_state = USBH_MSC_REQUEST_SENSE;
msc_botxfer_param.cmd_state_machine = CMD_SEND_STATE;
} else {
/* error trials exceeded the limit, go to unrecovered state */
msc_botxfer_param.msc_state = USBH_MSC_UNRECOVERED_STATE;
}
} else if (status == USBH_MSC_PHASE_ERROR) {
/* phase error, go to unrecoovered state */
msc_botxfer_param.msc_state = USBH_MSC_UNRECOVERED_STATE;
} else if (status == USBH_MSC_BUSY) {
/* no change in state */
}
}