1802 lines
52 KiB
C
1802 lines
52 KiB
C
/** * @file usb_storage.c
|
||
* @brief
|
||
* @author chenrixin@zh-jieli.com
|
||
* @version 1.00
|
||
* @date 2017-02-09
|
||
*/
|
||
|
||
#include "asm/includes.h"
|
||
#include "system/timer.h"
|
||
#include "device/ioctl_cmds.h"
|
||
#include "usb/host/usb_host.h"
|
||
#include "usb_ctrl_transfer.h"
|
||
#include "usb_bulk_transfer.h"
|
||
#include "device_drive.h"
|
||
#include "usb_storage.h"
|
||
#include "usb_config.h"
|
||
#include "app_config.h"
|
||
|
||
#if TCFG_UDISK_ENABLE
|
||
#define LOG_TAG_CONST USB
|
||
#define LOG_TAG "[USB]"
|
||
#define LOG_ERROR_ENABLE
|
||
#define LOG_DEBUG_ENABLE
|
||
#define LOG_INFO_ENABLE
|
||
/* #define LOG_DUMP_ENABLE */
|
||
#define LOG_CLI_ENABLE
|
||
#include "debug.h"
|
||
|
||
static int set_stor_power(struct usb_host_device *host_dev, u32 value);
|
||
static int get_stor_power(struct usb_host_device *host_dev, u32 value);
|
||
|
||
const struct interface_ctrl udisk_ops = {
|
||
.interface_class = USB_CLASS_MASS_STORAGE,
|
||
.set_power = set_stor_power,
|
||
.get_power = get_stor_power,
|
||
.ioctl = NULL,
|
||
};
|
||
|
||
|
||
static struct mass_storage mass_stor = {0};//SEC(.usb_h_udisk);
|
||
|
||
static const struct usb_interface_info udisk_inf = {
|
||
.ctrl = (struct interface_ctrl *) &udisk_ops,
|
||
.dev.disk = &mass_stor,
|
||
};
|
||
|
||
static struct device udisk_device ;//SEC(.usb_h_udisk);
|
||
static struct udisk_end_desc udisk_ep ;//SEC(.usb_h_udisk);
|
||
|
||
#define host_device2disk(host_dev) (udisk_inf.dev.disk)
|
||
|
||
/**
|
||
* @brief usb_stor_force_reset
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int usb_stor_force_reset(const usb_dev usb_id)
|
||
{
|
||
/* struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
const usb_dev usb_id = host_device2id(host_dev); */
|
||
log_error("============usb_stor_force_reset===============\n");
|
||
return usb_h_force_reset(usb_id);
|
||
}
|
||
static void usb_stor_set_curlun(struct mass_storage *disk, u32 i)
|
||
{
|
||
disk->curlun = i;
|
||
}
|
||
static int usb_stor_get_curlun(struct mass_storage *disk)
|
||
{
|
||
return disk->curlun;
|
||
}
|
||
static int usb_stor_txmaxp(struct mass_storage *disk)
|
||
{
|
||
#if HUSB_MODE
|
||
return udisk_ep.txmaxp;
|
||
#else
|
||
return 0x40;
|
||
#endif
|
||
}
|
||
static int usb_stor_rxmaxp(struct mass_storage *disk)
|
||
{
|
||
#if HUSB_MODE
|
||
return udisk_ep.rxmaxp;
|
||
#else
|
||
return 0x40;
|
||
#endif
|
||
}
|
||
#define UDISK_MUTEX_TIMEOUT 5000/10 //5s
|
||
static int usb_h_mutex_pend(struct usb_host_device *host_dev)
|
||
{
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
/* putchar('{'); */
|
||
/* putchar('^'); */
|
||
/* putchar('['); */
|
||
|
||
int r = os_mutex_pend(&disk->mutex, UDISK_MUTEX_TIMEOUT);
|
||
if (r) {
|
||
log_error("-----------------%d -------------------", r);
|
||
}
|
||
if (r == OS_TIMEOUT) {
|
||
return OS_TIMEOUT;
|
||
}
|
||
return r;
|
||
}
|
||
static int usb_h_mutex_post(struct usb_host_device *host_dev)
|
||
{
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
/* putchar(']'); */
|
||
/* putchar('^'); */
|
||
/* putchar('}'); */
|
||
|
||
int r = os_mutex_post(&disk->mutex);
|
||
return r;
|
||
}
|
||
static int set_stor_power(struct usb_host_device *host_dev, u32 value)
|
||
{
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
log_debug("%s() %d ", __func__, disk->dev_status);
|
||
if (disk == NULL || disk->dev_status == DEV_IDLE) {
|
||
return 0;
|
||
}
|
||
int r = usb_h_mutex_pend(host_dev);
|
||
|
||
if (disk->dev_status == DEV_READ || disk->dev_status == DEV_WRITE) {
|
||
if (value == -1) {
|
||
log_error("%s disk busy", __func__);
|
||
}
|
||
}
|
||
|
||
disk->dev_status = DEV_CLOSE;
|
||
|
||
log_debug("%s() %d ", __func__, disk->dev_status);
|
||
|
||
if (r == OS_TIMEOUT) {
|
||
return OS_TIMEOUT;
|
||
}
|
||
usb_h_mutex_post(host_dev);
|
||
return DEV_ERR_NONE;
|
||
}
|
||
|
||
static int get_stor_power(struct usb_host_device *host_dev, u32 value)
|
||
{
|
||
return DEV_ERR_NONE;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_init_cbw
|
||
*
|
||
* @param device
|
||
*/
|
||
static void usb_init_cbw(struct device *device, u32 dir, u32 opcode, u32 length)
|
||
{
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
|
||
memset(&disk->cbw, 0x00, sizeof(struct usb_scsi_cbw));
|
||
u32 curlun = usb_stor_get_curlun(disk);
|
||
disk->cbw.dCBWSignature = CBW_SIGNATURE;
|
||
disk->cbw.dCBWTag = rand32();
|
||
disk->cbw.bCBWLUN = curlun;
|
||
disk->cbw.lun = curlun << 5;
|
||
disk->cbw.bmCBWFlags = dir;
|
||
disk->cbw.operationCode = opcode;
|
||
disk->cbw.dCBWDataTransferLength = cpu_to_le32(length);
|
||
}
|
||
|
||
static int usb_stor_check_status(struct usb_host_device *host_dev)
|
||
{
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
|
||
if (!host_dev) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
}
|
||
if (!disk) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
}
|
||
if (disk->dev_status == DEV_IDLE) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
} else if (disk->dev_status == DEV_CLOSE) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int usb_stor_reset(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
int ret = DEV_ERR_NONE;
|
||
|
||
if (disk == NULL) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
}
|
||
//mass storage reset request
|
||
ret = set_msd_reset(host_dev);
|
||
return ret;
|
||
}
|
||
|
||
static int usb_stor_resume(struct device *device)
|
||
{
|
||
struct usb_device_descriptor device_desc;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
u8 devnum = host_dev->private_data.devnum;
|
||
int ret = DEV_ERR_NONE;
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
|
||
usb_h_resume(usb_id);
|
||
|
||
ret = usb_get_device_descriptor(host_dev, &device_desc);
|
||
if (ret == 0) {
|
||
return ret;
|
||
}
|
||
usb_h_force_reset(usb_id);
|
||
ret = set_address(host_dev, devnum);
|
||
if (ret) {
|
||
log_error("%s() @ %d %x\n", __func__, __LINE__, ret);
|
||
usb_sie_close(usb_id);
|
||
return -ret;
|
||
}
|
||
ret = usb_get_device_descriptor(host_dev, &device_desc);
|
||
if (ret) {
|
||
log_error("%s() @ %d %x\n", __func__, __LINE__, ret);
|
||
usb_sie_close(usb_id);
|
||
return -ret;
|
||
}
|
||
return ret;
|
||
}
|
||
/**
|
||
* @brief usb_stor_inquiry
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int _usb_stor_inquiry(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
int ret = DEV_ERR_NONE;
|
||
struct inquiry_data inquiry;
|
||
|
||
log_info("usb_stor_inquiry disk =%x", (u32)disk);
|
||
|
||
u32 total_lun = disk->lun;
|
||
u32 init_lun = 0;
|
||
|
||
for (int i = 0; i <= total_lun; i ++) {
|
||
usb_stor_set_curlun(disk, i);
|
||
usb_init_cbw(device, USB_DIR_IN, INQUIRY, sizeof(struct inquiry_data));
|
||
disk->cbw.bCBWLength = 0x06;
|
||
disk->cbw.lba[2] = sizeof(struct inquiry_data);
|
||
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&inquiry,
|
||
sizeof(struct inquiry_data));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct inquiry_data)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
/* printf_buf(&inquiry, sizeof(struct inquiry_data)); */
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
if (inquiry.PeripheralDeviceType) {
|
||
if (init_lun == i) {
|
||
if (init_lun < total_lun) {
|
||
init_lun++;
|
||
} else {
|
||
init_lun = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
usb_stor_set_curlun(disk, init_lun);
|
||
|
||
return DEV_ERR_NONE;
|
||
__exit:
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
|
||
static int usb_stor_inquiry(struct device *device)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
|
||
ret = _usb_stor_inquiry(device);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
/**
|
||
* @brief usb_stor_test_unit_ready
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int _usb_stor_test_unit_ready(struct device *device)
|
||
{
|
||
int ret = DEV_ERR_NONE;
|
||
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
|
||
usb_init_cbw(device, 0, TEST_UNIT_READY, 0);
|
||
disk->cbw.bCBWLength = 6;
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
return DEV_ERR_NONE;
|
||
__exit:
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
static int usb_stor_test_unit_ready(struct device *device)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_test_unit_ready(device);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_stor_mode_sense6
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*
|
||
* @brief disk write protect inquiry
|
||
*/
|
||
static int _usb_stor_mode_sense6(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
u8 *cdb;
|
||
int ret = DEV_ERR_NONE;
|
||
u8 data_buf[4];
|
||
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
usb_init_cbw(device, USB_DIR_IN, MODE_SENSE, 4);
|
||
disk->cbw.bCBWLUN = 6;
|
||
cdb = (u8 *)&disk->cbw.operationCode;
|
||
cdb[1] = 0; // PC | DBD
|
||
cdb[2] = 0x1c; //page code
|
||
cdb[3] = 0; //subpage code
|
||
cdb[4] = 192; //allocation length
|
||
cdb[5] = 0; //control;
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp, udisk_ep.target_epin,
|
||
data_buf,
|
||
sizeof(data_buf));
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
disk->read_only = data_buf[2] == 0x80 ? 1 : 0; //write protect
|
||
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_NONE;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
return DEV_ERR_NONE;
|
||
__exit:
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
static int usb_stor_mode_sense6(struct device *device)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_mode_sense6(device);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
|
||
}
|
||
/**
|
||
* @brief usb_stor_request_sense
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int _usb_stor_request_sense(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
int ret = DEV_ERR_NONE;
|
||
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
usb_init_cbw(device, USB_DIR_IN, REQUEST_SENSE, sizeof(struct request_sense_data));
|
||
disk->cbw.bCBWLength = 0xC;
|
||
disk->cbw.lba[2] = sizeof(struct request_sense_data);
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->sense,
|
||
sizeof(struct request_sense_data));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct request_sense_data)) {
|
||
ret = -DEV_ERR_NONE;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
/* printf_buf(&private_data->dev.disk->sense, sizeof(struct REQUEST_SENSE_DATA)); */
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
return DEV_ERR_NONE;
|
||
__exit:
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
static int usb_stor_request_sense(struct device *device)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_request_sense(device);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_stor_read_capacity
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int _usb_stor_read_capacity(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
int ret = DEV_ERR_NONE;
|
||
|
||
if (disk == NULL) {
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
}
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
u32 curlun = usb_stor_get_curlun(disk);
|
||
|
||
usb_init_cbw(device, USB_DIR_IN, READ_CAPACITY, 8);
|
||
disk->cbw.bCBWLength = 0xA;
|
||
disk->cbw.bmCBWFlags = USB_DIR_IN;
|
||
disk->cbw.operationCode = READ_CAPACITY;
|
||
disk->capacity[curlun].block_size = 0;
|
||
disk->capacity[curlun].block_num = 0;
|
||
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->capacity[curlun],
|
||
sizeof(struct read_capacity_data));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct read_capacity_data)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
disk->capacity[curlun].block_size = be32_to_cpu(disk->capacity[curlun].block_size);
|
||
disk->capacity[curlun].block_num = be32_to_cpu(disk->capacity[curlun].block_num) + 1;
|
||
log_info("block_size=%d", disk->capacity[curlun].block_size);
|
||
log_info("block_num=%d", disk->capacity[curlun].block_num);
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
return DEV_ERR_NONE;
|
||
__exit:
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
static int usb_stor_read_capacity(struct device *device)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_read_capacity(device);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
|
||
static int _usb_stro_read_cbw_request(struct device *device, u32 num_lba, u32 lba)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
u32 rx_len = num_lba * 512; //filesystem uses the fixed BLOCK_SIZE
|
||
u32 cur_lba = lba;
|
||
int ret = 0;
|
||
|
||
disk->dev_status = DEV_READ;
|
||
disk->suspend_cnt = 0;
|
||
usb_init_cbw(device, USB_DIR_IN, READ_10, rx_len);
|
||
disk->cbw.bCBWLength = 0xA;
|
||
|
||
cur_lba = cpu_to_be32(cur_lba);
|
||
memcpy(disk->cbw.lba, &cur_lba, sizeof(cur_lba));
|
||
|
||
disk->cbw.LengthH = HIBYTE(num_lba);
|
||
disk->cbw.LengthL = LOBYTE(num_lba);
|
||
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
if (disk->dev_status != DEV_CLOSE) {
|
||
disk->dev_status = DEV_OPEN;
|
||
}
|
||
log_error("%s---%d", __func__, __LINE__);
|
||
return ret;
|
||
}
|
||
return num_lba;
|
||
}
|
||
static int _usb_stro_read_csw(struct device *device)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
int ret = 0;
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d ret:%d\n", __func__, __LINE__, ret);
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static int _usb_stor_read_block_finish(struct device *device, u32 remain_len, u8 num_lba, void *pBuf)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
int ret = 0;
|
||
int len = num_lba * 512;
|
||
while (remain_len) {
|
||
//读完剩余的包,再开始下一次请求
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
pBuf,
|
||
len);
|
||
remain_len -= len;
|
||
if (remain_len == 0) {
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
static int _usb_stor_read_big_block(struct device *device, u32 disk_block_size, void *pBuf, u8 num_lba, u32 lba)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
int ret = 0;
|
||
u32 rx_len = num_lba * 512; //filesystem uses the fixed BLOCK_SIZE
|
||
u8 num_block = disk_block_size / 512; //8
|
||
u8 req_offset = lba % num_block; //计算block数据偏移量
|
||
u8 send_cbw = 0;
|
||
if ((req_offset == 0) || (lba <= disk->prev_lba) || ((lba - disk->prev_lba) > num_block) || (disk->remain_len == 0)) {
|
||
//sector 4k地址;或地址不连续时(地址小于上一次地址; 地址和上一次地址不属于同一个sector)
|
||
send_cbw = 1;
|
||
} else {
|
||
//地址连续
|
||
send_cbw = 0;
|
||
}
|
||
/* y_printf("lba===%d prev_lba=%d req_offset===%d cbw:%d %d %d\n", */
|
||
/* lba, disk->prev_lba, req_offset, send_cbw, disk_block_size,disk->remain_len); */
|
||
disk->prev_lba = lba;
|
||
lba = lba / num_block;
|
||
|
||
if (send_cbw) {
|
||
_usb_stor_read_block_finish(device, disk->remain_len, num_lba, pBuf); //确保读完剩余包 */
|
||
disk->remain_len = 0;
|
||
disk->dev_status = DEV_READ;
|
||
disk->suspend_cnt = 0;
|
||
usb_init_cbw(device, USB_DIR_IN, READ_10, disk_block_size / 512 * 512);
|
||
disk->cbw.bCBWLength = 0xA;
|
||
|
||
lba = cpu_to_be32(lba);
|
||
memcpy(disk->cbw.lba, &lba, sizeof(lba));
|
||
|
||
disk->cbw.LengthH = HIBYTE(num_lba);
|
||
disk->cbw.LengthL = LOBYTE(num_lba);
|
||
//cbw
|
||
//请求disk_block_size 大小数据
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
disk->remain_len = disk_block_size;
|
||
} else {
|
||
req_offset = 0; //地址连续时,读一次data
|
||
}
|
||
//data
|
||
do {
|
||
//循环读取,直到读取到偏移量所在的数据为止
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
pBuf,
|
||
rx_len);
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
disk->remain_len -= rx_len;
|
||
|
||
} while (req_offset--);
|
||
|
||
if (!disk->remain_len) { //读完data,需要读csw
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
}
|
||
|
||
disk->dev_status = DEV_OPEN;
|
||
return num_lba;
|
||
__exit:
|
||
if (disk->dev_status != DEV_CLOSE) {
|
||
disk->dev_status = DEV_OPEN;
|
||
}
|
||
log_error("%s---%d", __func__, __LINE__);
|
||
return 0;
|
||
}
|
||
|
||
int _usb_stor_async_wait_sem(struct usb_host_device *host_dev)
|
||
{
|
||
int ret = 0;
|
||
return ret;
|
||
}
|
||
|
||
#if UDISK_READ_AHEAD_ENABLE
|
||
static int _usb_stor_read_ahead_cbw(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
//log_info("func:%s,line:%d\n", __func__, __LINE__);
|
||
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 curlun = usb_stor_get_curlun(disk);
|
||
u8 read_block_num = UDISK_READ_AHEAD_BLOCK_NUM; //需要预读扇区数量
|
||
if (lba + read_block_num - 1 >= disk->capacity[curlun].block_num) {
|
||
read_block_num = disk->capacity[curlun].block_num - lba;
|
||
log_info("usb_read_ahead over capacity!!!%d,%d,%d\n", read_block_num, disk->capacity[curlun].block_num - 1, lba);
|
||
}
|
||
disk->remain_len = read_block_num * 512;
|
||
int ret = 0;
|
||
ret = _usb_stro_read_cbw_request(device, read_block_num, lba); //cbw
|
||
check_usb_read_ahead(ret);
|
||
|
||
return 0;
|
||
|
||
__exit:
|
||
return ret;
|
||
}
|
||
|
||
static int _usb_stor_read_ahead_data(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
//log_info("func:%s,line:%d\n", __func__, __LINE__);
|
||
|
||
if (num_lba == 0) {
|
||
return 0;
|
||
}
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
u32 rx_len = num_lba * 512;
|
||
int ret;
|
||
|
||
if (disk->remain_len != 0) {
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
pBuf,
|
||
rx_len);
|
||
check_usb_read_ahead(ret);
|
||
|
||
disk->remain_len -= rx_len;
|
||
disk->udisk_read_ahead_lba_last = lba + num_lba - 1;
|
||
}
|
||
|
||
if (disk->remain_len == 0) {
|
||
ret = _usb_stro_read_csw(device);
|
||
check_usb_read_ahead(ret);
|
||
}
|
||
|
||
return 0;
|
||
|
||
__exit:
|
||
return ret;
|
||
}
|
||
|
||
static int _usb_stor_read_ahead(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
//log_info("func:%s,line:%d\n", __func__, __LINE__);
|
||
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
|
||
int ret = 0;
|
||
if ((lba != disk->udisk_read_ahead_lba_last + 1) || disk->remain_len == 0) {
|
||
ret = _usb_stor_read_ahead_data(device, NULL, disk->remain_len / 512, lba); //预读中止，把上一次的剩下的读完
|
||
check_usb_read_ahead(ret);
|
||
|
||
ret = _usb_stor_read_ahead_cbw(device, pBuf, num_lba, lba);
|
||
check_usb_read_ahead(ret);
|
||
|
||
ret = _usb_stor_read_ahead_data(device, pBuf, num_lba, lba);
|
||
check_usb_read_ahead(ret);
|
||
} else {
|
||
ret = _usb_stor_read_ahead_data(device, pBuf, num_lba, lba);
|
||
check_usb_read_ahead(ret);
|
||
}
|
||
|
||
return num_lba; //read success
|
||
__exit:
|
||
return 0; //read error
|
||
}
|
||
#endif
|
||
|
||
/**
|
||
* @brief usb_stor_read 从U盘的lba扇区读取num_lba个扇区
|
||
*
|
||
* @param device 设备句柄
|
||
* @param pBuf 读buffer缓冲区，芯片所有memory都可以
|
||
* @param lba 需要读取的扇区地址
|
||
* @param num_lba 需要读取的扇区数量
|
||
*
|
||
* @return 负数表示失败
|
||
* 大于0的表示读取的字节数(Byte)
|
||
*/
|
||
static int _usb_stor_read(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
const u32 curlun = usb_stor_get_curlun(disk);
|
||
|
||
u8 read_retry = 0;
|
||
int ret;
|
||
u32 rx_cnt;
|
||
/* u32 rx_len = num_lba * disk->capacity[curlun].block_size; */
|
||
u32 rx_len = num_lba * 512; //filesystem uses the fixed BLOCK_SIZE
|
||
|
||
if (disk->capacity[curlun].block_size > 512) {
|
||
// 扇区大于512Byte
|
||
return _usb_stor_read_big_block(device, disk->capacity[curlun].block_size, pBuf, num_lba, lba);
|
||
}
|
||
|
||
if (lba + num_lba - 1 >= disk->capacity[curlun].block_num) {
|
||
return -DEV_ERR_OVER_CAPACITY;
|
||
}
|
||
|
||
#if UDISK_READ_AHEAD_ENABLE
|
||
if (disk->udisk_read_ahead_en) {
|
||
return _usb_stor_read_ahead(device, pBuf, num_lba, lba);
|
||
}
|
||
#endif
|
||
|
||
ret = _usb_stro_read_cbw_request(device, num_lba, lba);
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
pBuf,
|
||
rx_len);
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
disk->dev_status = DEV_OPEN;
|
||
return num_lba;
|
||
|
||
__exit:
|
||
if (disk->dev_status != DEV_CLOSE) {
|
||
disk->dev_status = DEV_OPEN;
|
||
}
|
||
log_error("%s---%d", __func__, __LINE__);
|
||
return 0;
|
||
}
|
||
static int usb_stor_read(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_read(device, pBuf, num_lba, lba);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_stor_write 写数据到U盘
|
||
*
|
||
* @param device
|
||
* @param pBuf 数据buffer
|
||
* @param lba 需要写入的扇区地址
|
||
* @param num_lba 需要写入的扇区数量
|
||
*
|
||
* @return 负数表示写入失败
|
||
* 正数为写入的字节数 (Byte)
|
||
*/
|
||
static int _usb_stor_write(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
u32 ret;
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
const u32 curlun = usb_stor_get_curlun(disk);
|
||
|
||
if (lba + num_lba - 1 >= disk->capacity[curlun].block_num) {
|
||
log_error("%s %d", __func__, __LINE__);
|
||
return -DEV_ERR_OVER_CAPACITY;
|
||
}
|
||
|
||
if (disk->capacity[curlun].block_size > 512) {
|
||
log_error(" %s disk bolock size %d not support write", __func__, disk->capacity[curlun].block_size);
|
||
return -DEV_ERR_NO_WRITE;
|
||
}
|
||
|
||
if (disk->read_only) {
|
||
log_error("%s %d", __func__, __LINE__);
|
||
return -DEV_ERR_NO_WRITE;
|
||
}
|
||
|
||
/* u32 tx_len = num_lba * disk->capacity[curlun].block_size; */
|
||
u32 tx_len = num_lba * 512; //filesystem uses the fixed BLOCK_SIZE
|
||
|
||
#if UDISK_READ_AHEAD_ENABLE
|
||
|
||
if (disk->remain_len) {
|
||
_usb_stor_read_ahead_data(device, NULL, disk->remain_len / 512, disk->udisk_read_ahead_lba_last + 1); //预读中止，把上一次的剩下的读完
|
||
disk->udisk_read_ahead_lba_last = -1;
|
||
}
|
||
|
||
#endif
|
||
|
||
disk->dev_status = DEV_WRITE;
|
||
disk->suspend_cnt = 0;
|
||
usb_init_cbw(device, USB_DIR_OUT, WRITE_10, tx_len);
|
||
|
||
disk->cbw.bCBWLength = 0xA;
|
||
|
||
lba = cpu_to_be32(lba);
|
||
memcpy(disk->cbw.lba, &lba, sizeof(lba));
|
||
|
||
|
||
disk->cbw.LengthH = HIBYTE(num_lba);
|
||
disk->cbw.LengthL = LOBYTE(num_lba);
|
||
|
||
//cbw
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
(u8 *)&disk->cbw,
|
||
sizeof(struct usb_scsi_cbw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//data
|
||
ret = usb_bulk_only_send(device,
|
||
udisk_ep.host_epout,
|
||
txmaxp,
|
||
udisk_ep.target_epout,
|
||
pBuf,
|
||
tx_len);
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
|
||
//csw
|
||
ret = usb_bulk_only_receive(device,
|
||
udisk_ep.host_epin,
|
||
rxmaxp,
|
||
udisk_ep.target_epin,
|
||
(u8 *)&disk->csw,
|
||
sizeof(struct usb_scsi_csw));
|
||
|
||
if (ret < DEV_ERR_NONE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
} else if (ret != sizeof(struct usb_scsi_csw)) {
|
||
ret = -DEV_ERR_UNKNOW;
|
||
goto __exit;
|
||
}
|
||
|
||
if (disk->csw.bCSWStatus) {
|
||
ret = usb_stor_request_sense(device);
|
||
if (ret) {
|
||
ret = -DEV_ERR_OFFLINE;
|
||
}
|
||
|
||
if (ret == -DEV_ERR_OFFLINE) {
|
||
log_error("%s:%d\n", __func__, __LINE__);
|
||
goto __exit;
|
||
}
|
||
log_info("usb_stor_sense =%x", disk->sense.SenseKey);
|
||
return 0;
|
||
}
|
||
|
||
disk->dev_status = DEV_OPEN;
|
||
return num_lba;//DEV_ERR_NONE;
|
||
|
||
__exit:
|
||
if (disk->dev_status != DEV_CLOSE) {
|
||
disk->dev_status = DEV_OPEN;
|
||
}
|
||
log_error("%s---%d\n", __func__, __LINE__);
|
||
/* usb_stor_force_reset(usb_id); */
|
||
return 0;
|
||
}
|
||
static int usb_stor_write(struct device *device, void *pBuf, u32 num_lba, u32 lba)
|
||
{
|
||
int ret;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
ret = usb_stor_check_status(host_dev);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
if (ret == OS_TIMEOUT) {
|
||
return -OS_TIMEOUT;
|
||
}
|
||
ret = _usb_stor_write(device, pBuf, num_lba, lba);
|
||
usb_h_mutex_post(host_dev);
|
||
return ret;
|
||
}
|
||
#if ENABLE_DISK_HOTPLUG
|
||
static void usb_stor_tick_handle(void *arg)
|
||
{
|
||
struct device *device = (struct device *)arg;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);//(device);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
|
||
int ret;
|
||
|
||
r_printf("A");
|
||
if (disk == NULL) {
|
||
return;
|
||
}
|
||
r_printf("B");
|
||
if (disk->dev_status == DEV_OPEN) {
|
||
r_printf("C");
|
||
ret = usb_stor_read_capacity(device);
|
||
r_printf("D");
|
||
}
|
||
|
||
#if 0
|
||
#if 1
|
||
disk->suspend_cnt++;
|
||
if ((disk->suspend_cnt > 6) && (disk->dev_status == DEV_OPEN)) {
|
||
usb_h_entry_suspend(usb_id);
|
||
disk->suspend_cnt = 0;
|
||
disk->dev_status = DEV_SUSPEND;
|
||
}
|
||
#else
|
||
ret = usb_stor_test_unit_ready(device);
|
||
if (ret < DEV_ERR_NONE) {
|
||
return ;
|
||
}
|
||
if (disk->csw.bCSWStatus) {
|
||
usb_stor_request_sense(device);
|
||
/* puts("request sense\n"); */
|
||
/* put_buf((u8 *)&disk->sense, sizeof(disk->sense)); */
|
||
if ((disk->sense.SenseKey & 0x0f) == NOT_READY) {
|
||
if (disk->sense.ASC == 0x3a && disk->sense.ASCQ == 0x00) {
|
||
disk->media_sta_cur = 0;
|
||
}
|
||
} else if ((disk->sense.SenseKey & 0x0f) == UNIT_ATTENTION) {
|
||
if (disk->sense.ASC == 0x28 && disk->sense.ASCQ == 0x00) {
|
||
disk->media_sta_cur = 1;
|
||
}
|
||
}
|
||
} else {
|
||
disk->media_sta_cur = 1;
|
||
}
|
||
|
||
if (disk->media_sta_cur != disk->media_sta_prev) {
|
||
if (disk->media_sta_cur) {
|
||
log_info("udisk media insert");
|
||
usb_stor_read_capacity(device);
|
||
usb_stor_mode_sense6(device);
|
||
} else {
|
||
log_info("udisk media eject");
|
||
}
|
||
}
|
||
disk->media_sta_prev = disk->media_sta_cur;
|
||
#endif
|
||
#endif
|
||
}
|
||
#endif
|
||
|
||
/**
|
||
* @brief usb_stor_init
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
int usb_stor_init(struct device *device)
|
||
{
|
||
log_debug("%s---%d\n", __func__, __LINE__);
|
||
int ret = DEV_ERR_NONE;
|
||
u32 state = 0;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
#if UDISK_READ_AHEAD_ENABLE
|
||
disk->udisk_read_ahead_lba_last = -1;
|
||
disk->remain_len = 0;
|
||
disk->udisk_read_ahead_en = 0;
|
||
#endif
|
||
log_error("%s() disk = %x", __func__, disk);
|
||
|
||
if (!host_dev_status(host_dev)) {
|
||
return -DEV_ERR_OFFLINE;
|
||
}
|
||
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
if (host_dev->private_data.status == 0) {
|
||
return -ENODEV;
|
||
}
|
||
|
||
if (!disk) {
|
||
log_error("%s not enough memory");
|
||
return -DEV_ERR_OUTOFMEMORY;
|
||
}
|
||
|
||
disk->dev_status = DEV_INIT;
|
||
|
||
const u32 txmaxp = usb_stor_txmaxp(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
u8 lun = 0;
|
||
ret = get_msd_max_lun(host_dev, &lun);
|
||
if (ret != DEV_ERR_NONE) {
|
||
/* disk->dev_status = DEV_IDLE; */
|
||
/* usb_stor_force_reset(usb_id); */
|
||
log_error("ret = %d\n", ret);
|
||
/* return ret; */
|
||
}
|
||
|
||
disk->lun = lun;
|
||
|
||
int retry = 5;
|
||
while (retry) {
|
||
retry --;
|
||
if (ret == -DEV_ERR_OFFLINE) {
|
||
log_error("disk offline");
|
||
break;
|
||
}
|
||
switch (state) {
|
||
case 0:
|
||
log_info("--- inquery ---");
|
||
ret = usb_stor_inquiry(device);
|
||
if (ret < DEV_ERR_NONE) {
|
||
os_time_dly(retry);
|
||
if (retry == 3) {
|
||
ret = -DEV_ERR_OFFLINE;
|
||
}
|
||
} else {
|
||
state++;
|
||
}
|
||
break;
|
||
|
||
case 1:
|
||
log_info("--- test unit ready ---");
|
||
ret = usb_stor_test_unit_ready(device);
|
||
if (ret < DEV_ERR_NONE) {
|
||
os_time_dly(50);
|
||
} else if (disk->csw.bCSWStatus) {
|
||
os_time_dly(50);
|
||
ret = usb_stor_request_sense(device);
|
||
if ((disk->sense.SenseKey & 0x0f) != NO_SENSE) {
|
||
if (disk->sense.SenseKey == NOT_READY) {
|
||
os_time_dly(30);
|
||
disk->curlun++;
|
||
if (disk->curlun > disk->lun) {
|
||
disk->curlun = 0;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
state++;
|
||
}
|
||
break;
|
||
|
||
case 2:
|
||
log_info("--- read capacity ---");
|
||
ret = usb_stor_read_capacity(device);
|
||
if (ret < DEV_ERR_NONE) {
|
||
os_time_dly(50);
|
||
} else if (disk->csw.bCSWStatus) {
|
||
os_time_dly(50);
|
||
ret = usb_stor_request_sense(device);
|
||
if ((disk->sense.SenseKey & 0x0f) != NO_SENSE) {
|
||
os_time_dly(30);
|
||
}
|
||
} else {
|
||
log_info("udisk mount succ");
|
||
state = 0xff;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
retry = 0;
|
||
break;
|
||
}
|
||
}
|
||
state = 0;
|
||
|
||
if (ret != DEV_ERR_NONE) {
|
||
disk->dev_status = DEV_IDLE;
|
||
/* usb_stor_force_reset(usb_id); */
|
||
log_error("ret = %d\n", ret);
|
||
} else {
|
||
/* disk->test_unit_ready_tick = sys_timer_add(device,usb_stor_tick_handle,200); */
|
||
#if ENABLE_DISK_HOTPLUG
|
||
disk->media_sta_cur = 1;
|
||
disk->media_sta_prev = 1;
|
||
#endif
|
||
}
|
||
disk->suspend_cnt = 0;
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_stor_ioctrl
|
||
*
|
||
* @param device
|
||
* @param cmd 支持下面的命令
|
||
* |命令|功能|
|
||
* |---|---|
|
||
* |IOCTL_GET_ID|U盘位于总线的地址0表示不在线|
|
||
* |IOCTL_GET_BLOCK_SIZE|获取扇区大小|
|
||
* |IOCTL_GET_CAPACITY|获取磁盘容量|
|
||
* |IOCTL_GET_MAX_LUN|获取最大磁盘数量<最大支持两个磁盘>|
|
||
* |IOCTL_GET_CUR_LUN|获取当前的磁盘号|
|
||
* |IOCTL_SET_CUR_LUN|设置当前的磁盘号|
|
||
* @param arg
|
||
*
|
||
* @return 0----成功
|
||
* 其他值---失败-
|
||
*/
|
||
static int usb_stor_ioctrl(struct device *device, u32 cmd, u32 arg)
|
||
{
|
||
int ret = DEV_ERR_NONE;
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
u32 devnum = host_dev->private_data.devnum;
|
||
u32 curlun = usb_stor_get_curlun(disk);
|
||
const u32 rxmaxp = usb_stor_rxmaxp(disk);
|
||
|
||
if (disk == NULL) {
|
||
return -ENOTTY;
|
||
}
|
||
|
||
switch (cmd) {
|
||
case IOCTL_GET_ID:
|
||
*(u32 *)arg = devnum;
|
||
break;
|
||
|
||
case IOCTL_GET_BLOCK_SIZE:
|
||
*(u32 *)arg = disk->capacity[curlun].block_size;
|
||
break;
|
||
|
||
case IOCTL_GET_BLOCK_NUMBER:
|
||
*(u32 *)arg = disk->capacity[curlun].block_num;
|
||
break;
|
||
|
||
case IOCTL_GET_CAPACITY:
|
||
*(u32 *)arg = disk->capacity[curlun].block_num;
|
||
break;
|
||
|
||
case IOCTL_GET_MAX_LUN:
|
||
*(u32 *)arg = disk->lun;
|
||
break;
|
||
|
||
case IOCTL_GET_CUR_LUN:
|
||
*(u32 *)arg = curlun;
|
||
break;
|
||
|
||
case IOCTL_SET_CUR_LUN:
|
||
if (arg > disk->lun) {
|
||
return -EINVAL;
|
||
}
|
||
usb_stor_set_curlun(disk, arg);
|
||
ret = usb_stor_read_capacity(device);
|
||
if (ret < 0) {
|
||
log_error("usb disk unit%d is not ready", curlun);
|
||
return -EFAULT;
|
||
} else if (disk->csw.bCSWStatus) {
|
||
usb_stor_request_sense(device);
|
||
if (disk->sense.SenseKey != NO_SENSE) {
|
||
log_error("usb disk unit%d is not ready", curlun);
|
||
}
|
||
return -EFAULT;
|
||
}
|
||
/* usb_stor_mode_sense6(device); */
|
||
break;
|
||
|
||
case IOCTL_CHECK_WRITE_PROTECT:
|
||
if (disk->read_only) {
|
||
*(u32 *)arg = 1;
|
||
} else {
|
||
*(u32 *)arg = 0;
|
||
}
|
||
break;
|
||
|
||
case IOCTL_GET_STATUS:
|
||
#if ENABLE_DISK_HOTPLUG
|
||
if (disk->media_sta_cur) {
|
||
#else
|
||
if (1) {
|
||
#endif
|
||
log_info("usb disk unit%d is online", curlun);
|
||
*(u32 *)arg = 1;
|
||
} else {
|
||
log_info("usb disk unit%d is offline", curlun);
|
||
*(u32 *)arg = 0;
|
||
}
|
||
break;
|
||
|
||
case IOCTL_SET_FORCE_RESET:
|
||
ret = usb_stor_force_reset(usb_id);
|
||
break;
|
||
case IOCTL_SET_ASYNC_MODE:
|
||
g_printf(">> UDISK IOCTL_SET_ASYNC_MODE %d\n", arg);
|
||
|
||
#if UDISK_READ_AHEAD_ENABLE
|
||
/* printf("last lba %d, remain_len %d\n", disk->udisk_read_ahead_lba_last, disk->remain_len); */
|
||
usb_h_mutex_pend(host_dev);
|
||
if (arg == 0) {
|
||
u32 lba = disk->udisk_read_ahead_lba_last + 1;
|
||
/* printf("remain_len %d, lba %d\n", disk->remain_len, lba); */
|
||
ret = _usb_stor_read_ahead_data(device, NULL, disk->remain_len / 512, lba); //预读中止，把上一次的剩下的读完
|
||
check_usb_read_ahead(ret);
|
||
}
|
||
disk->udisk_read_ahead_lba_last = -1;
|
||
disk->udisk_read_ahead_en = arg;
|
||
usb_h_mutex_post(host_dev);
|
||
#endif
|
||
break;
|
||
|
||
default:
|
||
return -ENOTTY;
|
||
}
|
||
|
||
return ret;
|
||
|
||
__exit:
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* @brief usb_msd_parser
|
||
*
|
||
* @param device
|
||
* @param pBuf
|
||
*
|
||
* @return
|
||
*/
|
||
int usb_msd_parser(struct usb_host_device *host_dev, u8 interface_num, const u8 *pBuf)
|
||
{
|
||
struct usb_interface_descriptor *interface = (struct usb_interface_descriptor *)pBuf;
|
||
pBuf += sizeof(struct usb_interface_descriptor);
|
||
int len = 0;
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
|
||
udisk_device.private_data = host_dev;
|
||
|
||
host_dev->interface_info[interface_num] = &udisk_inf;
|
||
|
||
for (int endnum = 0; endnum < interface->bNumEndpoints; endnum++) {
|
||
struct usb_endpoint_descriptor *end_desc = (struct usb_endpoint_descriptor *)pBuf;
|
||
|
||
if (end_desc->bDescriptorType != USB_DT_ENDPOINT ||
|
||
end_desc->bLength != USB_DT_ENDPOINT_SIZE) {
|
||
log_error("ep bDescriptorType = %d bLength = %d", end_desc->bDescriptorType, end_desc->bLength);
|
||
return -USB_DT_ENDPOINT;
|
||
}
|
||
|
||
len += USB_DT_ENDPOINT_SIZE;
|
||
pBuf += USB_DT_ENDPOINT_SIZE;
|
||
|
||
if ((end_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
|
||
if (end_desc->bEndpointAddress & USB_DIR_IN) {
|
||
udisk_ep.host_epin = usb_get_ep_num(usb_id, USB_DIR_IN, USB_ENDPOINT_XFER_BULK);
|
||
udisk_ep.target_epin = end_desc->bEndpointAddress & 0x0f;
|
||
#if HUSB_MODE
|
||
udisk_ep.rxmaxp = end_desc->wMaxPacketSize;
|
||
#endif
|
||
log_debug("D(%d)->H(%d)", udisk_ep.target_epin, udisk_ep.host_epin);
|
||
} else {
|
||
udisk_ep.host_epout = usb_get_ep_num(usb_id, USB_DIR_OUT, USB_ENDPOINT_XFER_BULK);
|
||
udisk_ep.target_epout = end_desc->bEndpointAddress & 0x0f;
|
||
#if HUSB_MODE
|
||
udisk_ep.txmaxp = end_desc->wMaxPacketSize;
|
||
#endif
|
||
log_debug("H(%d)->D(%d)", udisk_ep.host_epout, udisk_ep.target_epout);
|
||
}
|
||
}
|
||
}
|
||
u8 *ep_buffer = usb_h_get_ep_buffer(usb_id, udisk_ep.host_epin | USB_DIR_IN);
|
||
usb_h_ep_config(usb_id, udisk_ep.host_epin | USB_DIR_IN, USB_ENDPOINT_XFER_BULK, 0, 0, ep_buffer, 64);
|
||
|
||
|
||
ep_buffer = usb_h_get_ep_buffer(usb_id, udisk_ep.host_epout | USB_DIR_OUT);
|
||
usb_h_ep_config(usb_id, udisk_ep.host_epout | USB_DIR_OUT, USB_ENDPOINT_XFER_BULK, 0, 0, ep_buffer, 64);
|
||
return len;
|
||
}
|
||
/**
|
||
* @brief usb_stor_open
|
||
*
|
||
* @param node
|
||
* @param device
|
||
* @param arg
|
||
*
|
||
* @return
|
||
*/
|
||
static int usb_stor_open(const char *name, struct device **device, void *arg)
|
||
{
|
||
int ret;
|
||
*device = &udisk_device;
|
||
struct usb_host_device *host_dev = device_to_usbdev(*device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
const u32 curlun = usb_stor_get_curlun(disk);
|
||
log_debug("=====================usb_stor_open===================== %d", disk->dev_status);
|
||
if (disk->dev_status != DEV_IDLE) {
|
||
if (disk->dev_status == DEV_CLOSE) {
|
||
log_error("%s() fail, disconnect\n", __func__);
|
||
return -DEV_ERR_NOT_MOUNT;
|
||
} else {
|
||
return DEV_ERR_NONE;
|
||
}
|
||
}
|
||
memset(&disk->mutex, 0, sizeof(disk->mutex));
|
||
os_mutex_create(&disk->mutex);
|
||
disk->remain_len = 0;
|
||
disk->prev_lba = 0;
|
||
ret = usb_stor_init(*device);
|
||
if (ret) {
|
||
log_error("usb_stor_init err %d\n", ret);
|
||
return -ENODEV;
|
||
}
|
||
log_debug("device %x", (u32)*device);
|
||
|
||
|
||
usb_h_mutex_pend(host_dev);
|
||
if (*device) {
|
||
log_error("mass storage dev name %s", name);
|
||
disk->dev_status = DEV_OPEN;
|
||
usb_h_mutex_post(host_dev);
|
||
return DEV_ERR_NONE;
|
||
} else {
|
||
usb_h_mutex_post(host_dev);
|
||
return -ENODEV;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief usb_stor_close
|
||
*
|
||
* @param device
|
||
*
|
||
* @return
|
||
*/
|
||
static int usb_stor_close(struct device *device)
|
||
{
|
||
log_debug("%s---%d\n", __func__, __LINE__);
|
||
struct usb_host_device *host_dev = device_to_usbdev(device);
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
int ret;
|
||
if (disk->dev_status == DEV_IDLE) {
|
||
return 0;
|
||
}
|
||
log_info("=====================usb_stor_close=====================");
|
||
if (disk) {
|
||
log_info("=====================usb_stor_close===================== 333");
|
||
ret = usb_h_mutex_pend(host_dev);
|
||
|
||
const usb_dev usb_id = host_device2id(host_dev);
|
||
usb_clr_intr_rxe(usb_id, udisk_ep.host_epin);
|
||
|
||
disk->dev_status = DEV_IDLE;
|
||
|
||
if (ret != OS_ERR_NONE) {
|
||
log_error("disk close pend timeout!!!\n");
|
||
} else {
|
||
usb_h_mutex_post(host_dev);
|
||
}
|
||
log_info("=====================usb_stor_close===================== 1222 ");
|
||
|
||
os_mutex_del(&disk->mutex, 0);
|
||
memset(&disk->mutex, 0, sizeof(disk->mutex));
|
||
}
|
||
return DEV_ERR_NONE;
|
||
}
|
||
|
||
static bool usb_stor_online(const struct dev_node *node)
|
||
{
|
||
struct device *device = &udisk_device;
|
||
struct mass_storage *disk = udisk_inf.dev.disk;;
|
||
if (disk) {
|
||
return true;//disk->media_sta_cur ? true : false;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
const struct device_operations mass_storage_ops = {
|
||
.init = NULL,
|
||
.online = usb_stor_online,
|
||
.open = usb_stor_open,
|
||
.read = usb_stor_read,
|
||
.write = usb_stor_write,
|
||
.ioctl = usb_stor_ioctrl,
|
||
.close = usb_stor_close,
|
||
};
|
||
|
||
static u8 usb_stor_idle_query(void)
|
||
{
|
||
struct device *device = &udisk_device;
|
||
struct mass_storage *disk = host_device2disk(host_dev);
|
||
if (disk) {
|
||
return (disk->dev_status == DEV_IDLE) ? true : false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
REGISTER_LP_TARGET(usb_stor_lp_target) = {
|
||
.name = "udisk",
|
||
.is_idle = usb_stor_idle_query,
|
||
};
|
||
|
||
#if 0
|
||
u32 usb_host_mount(const usb_dev id, u32 retry, u32 reset_delay, u32 mount_timeout);
|
||
extern u8 msd_test_buf[32 * 1024];
|
||
void dump_usb_buf();
|
||
void usb_host_test()
|
||
{
|
||
___usb_test:
|
||
usb_host_mount(0, 3, 20, 200);
|
||
struct device *device;
|
||
usb_stor_open("udisk0", &device, NULL);
|
||
log_info("%s---%d\n", __func__, __LINE__);
|
||
u32 lba = 0;
|
||
while (1) {
|
||
|
||
u32 *p = (u32 *)msd_test_buf;
|
||
u32 numOflba = sizeof(msd_test_buf) / 512;
|
||
|
||
if ((usb_stor_read(device, p, numOflba, lba)) != numOflba) {
|
||
printf("read error %d", lba);
|
||
while (1);
|
||
}
|
||
#if 1
|
||
if (usb_stor_write(device, p, numOflba, lba) != numOflba) {
|
||
|
||
printf("write error %d", lba);
|
||
while (1);
|
||
}
|
||
|
||
if ((usb_stor_read(device, p, numOflba, lba)) != numOflba) {
|
||
printf("read error %d", lba);
|
||
while (1);
|
||
}
|
||
#endif
|
||
for (int i = 0; i < numOflba * 512 / 4; i++) {
|
||
if (p[i] != (i + lba * 0x80)) {
|
||
printf("@lba:%x offset %x %x != %x ", lba, i, p[i], i + lba * 0x80);
|
||
/* put_buf(p, numOflba * 512); */
|
||
/* while (1); */
|
||
}
|
||
}
|
||
wdt_clear();
|
||
|
||
lba += numOflba;
|
||
}
|
||
}
|
||
#endif
|
||
#endif
|