mirror of
https://github.com/qemu/qemu.git
synced 2024-12-05 17:53:36 +08:00
0b06d099b0
Signed-off-by: Gonglei <arei.gonglei@huawei.com> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
961 lines
28 KiB
C
961 lines
28 KiB
C
/*
|
|
* UAS (USB Attached SCSI) emulation
|
|
*
|
|
* Copyright Red Hat, Inc. 2012
|
|
*
|
|
* Author: Gerd Hoffmann <kraxel@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu-common.h"
|
|
#include "qemu/option.h"
|
|
#include "qemu/config-file.h"
|
|
#include "trace.h"
|
|
#include "qemu/error-report.h"
|
|
|
|
#include "hw/usb.h"
|
|
#include "hw/usb/desc.h"
|
|
#include "hw/scsi/scsi.h"
|
|
#include "block/scsi.h"
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
#define UAS_UI_COMMAND 0x01
|
|
#define UAS_UI_SENSE 0x03
|
|
#define UAS_UI_RESPONSE 0x04
|
|
#define UAS_UI_TASK_MGMT 0x05
|
|
#define UAS_UI_READ_READY 0x06
|
|
#define UAS_UI_WRITE_READY 0x07
|
|
|
|
#define UAS_RC_TMF_COMPLETE 0x00
|
|
#define UAS_RC_INVALID_INFO_UNIT 0x02
|
|
#define UAS_RC_TMF_NOT_SUPPORTED 0x04
|
|
#define UAS_RC_TMF_FAILED 0x05
|
|
#define UAS_RC_TMF_SUCCEEDED 0x08
|
|
#define UAS_RC_INCORRECT_LUN 0x09
|
|
#define UAS_RC_OVERLAPPED_TAG 0x0a
|
|
|
|
#define UAS_TMF_ABORT_TASK 0x01
|
|
#define UAS_TMF_ABORT_TASK_SET 0x02
|
|
#define UAS_TMF_CLEAR_TASK_SET 0x04
|
|
#define UAS_TMF_LOGICAL_UNIT_RESET 0x08
|
|
#define UAS_TMF_I_T_NEXUS_RESET 0x10
|
|
#define UAS_TMF_CLEAR_ACA 0x40
|
|
#define UAS_TMF_QUERY_TASK 0x80
|
|
#define UAS_TMF_QUERY_TASK_SET 0x81
|
|
#define UAS_TMF_QUERY_ASYNC_EVENT 0x82
|
|
|
|
#define UAS_PIPE_ID_COMMAND 0x01
|
|
#define UAS_PIPE_ID_STATUS 0x02
|
|
#define UAS_PIPE_ID_DATA_IN 0x03
|
|
#define UAS_PIPE_ID_DATA_OUT 0x04
|
|
|
|
typedef struct {
|
|
uint8_t id;
|
|
uint8_t reserved;
|
|
uint16_t tag;
|
|
} QEMU_PACKED uas_iu_header;
|
|
|
|
typedef struct {
|
|
uint8_t prio_taskattr; /* 6:3 priority, 2:0 task attribute */
|
|
uint8_t reserved_1;
|
|
uint8_t add_cdb_length; /* 7:2 additional adb length (dwords) */
|
|
uint8_t reserved_2;
|
|
uint64_t lun;
|
|
uint8_t cdb[16];
|
|
uint8_t add_cdb[];
|
|
} QEMU_PACKED uas_iu_command;
|
|
|
|
typedef struct {
|
|
uint16_t status_qualifier;
|
|
uint8_t status;
|
|
uint8_t reserved[7];
|
|
uint16_t sense_length;
|
|
uint8_t sense_data[18];
|
|
} QEMU_PACKED uas_iu_sense;
|
|
|
|
typedef struct {
|
|
uint8_t add_response_info[3];
|
|
uint8_t response_code;
|
|
} QEMU_PACKED uas_iu_response;
|
|
|
|
typedef struct {
|
|
uint8_t function;
|
|
uint8_t reserved;
|
|
uint16_t task_tag;
|
|
uint64_t lun;
|
|
} QEMU_PACKED uas_iu_task_mgmt;
|
|
|
|
typedef struct {
|
|
uas_iu_header hdr;
|
|
union {
|
|
uas_iu_command command;
|
|
uas_iu_sense sense;
|
|
uas_iu_task_mgmt task;
|
|
uas_iu_response response;
|
|
};
|
|
} QEMU_PACKED uas_iu;
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
#define UAS_STREAM_BM_ATTR 4
|
|
#define UAS_MAX_STREAMS (1 << UAS_STREAM_BM_ATTR)
|
|
|
|
typedef struct UASDevice UASDevice;
|
|
typedef struct UASRequest UASRequest;
|
|
typedef struct UASStatus UASStatus;
|
|
|
|
struct UASDevice {
|
|
USBDevice dev;
|
|
SCSIBus bus;
|
|
QEMUBH *status_bh;
|
|
QTAILQ_HEAD(, UASStatus) results;
|
|
QTAILQ_HEAD(, UASRequest) requests;
|
|
|
|
/* properties */
|
|
uint32_t requestlog;
|
|
|
|
/* usb 2.0 only */
|
|
USBPacket *status2;
|
|
UASRequest *datain2;
|
|
UASRequest *dataout2;
|
|
|
|
/* usb 3.0 only */
|
|
USBPacket *data3[UAS_MAX_STREAMS + 1];
|
|
USBPacket *status3[UAS_MAX_STREAMS + 1];
|
|
};
|
|
|
|
#define TYPE_USB_UAS "usb-uas"
|
|
#define USB_UAS(obj) OBJECT_CHECK(UASDevice, (obj), TYPE_USB_UAS)
|
|
|
|
struct UASRequest {
|
|
uint16_t tag;
|
|
uint64_t lun;
|
|
UASDevice *uas;
|
|
SCSIDevice *dev;
|
|
SCSIRequest *req;
|
|
USBPacket *data;
|
|
bool data_async;
|
|
bool active;
|
|
bool complete;
|
|
uint32_t buf_off;
|
|
uint32_t buf_size;
|
|
uint32_t data_off;
|
|
uint32_t data_size;
|
|
QTAILQ_ENTRY(UASRequest) next;
|
|
};
|
|
|
|
struct UASStatus {
|
|
uint32_t stream;
|
|
uas_iu status;
|
|
uint32_t length;
|
|
QTAILQ_ENTRY(UASStatus) next;
|
|
};
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
enum {
|
|
STR_MANUFACTURER = 1,
|
|
STR_PRODUCT,
|
|
STR_SERIALNUMBER,
|
|
STR_CONFIG_HIGH,
|
|
STR_CONFIG_SUPER,
|
|
};
|
|
|
|
static const USBDescStrings desc_strings = {
|
|
[STR_MANUFACTURER] = "QEMU",
|
|
[STR_PRODUCT] = "USB Attached SCSI HBA",
|
|
[STR_SERIALNUMBER] = "27842",
|
|
[STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
|
|
[STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
|
|
};
|
|
|
|
static const USBDescIface desc_iface_high = {
|
|
.bInterfaceNumber = 0,
|
|
.bNumEndpoints = 4,
|
|
.bInterfaceClass = USB_CLASS_MASS_STORAGE,
|
|
.bInterfaceSubClass = 0x06, /* SCSI */
|
|
.bInterfaceProtocol = 0x62, /* UAS */
|
|
.eps = (USBDescEndpoint[]) {
|
|
{
|
|
.bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 512,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_COMMAND,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_STATUS,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 512,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_STATUS,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 512,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_DATA_IN,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 512,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_DATA_OUT,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},
|
|
}
|
|
};
|
|
|
|
static const USBDescIface desc_iface_super = {
|
|
.bInterfaceNumber = 0,
|
|
.bNumEndpoints = 4,
|
|
.bInterfaceClass = USB_CLASS_MASS_STORAGE,
|
|
.bInterfaceSubClass = 0x06, /* SCSI */
|
|
.bInterfaceProtocol = 0x62, /* UAS */
|
|
.eps = (USBDescEndpoint[]) {
|
|
{
|
|
.bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 1024,
|
|
.bMaxBurst = 15,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_COMMAND,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_STATUS,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 1024,
|
|
.bMaxBurst = 15,
|
|
.bmAttributes_super = UAS_STREAM_BM_ATTR,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_STATUS,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 1024,
|
|
.bMaxBurst = 15,
|
|
.bmAttributes_super = UAS_STREAM_BM_ATTR,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_DATA_IN,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},{
|
|
.bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = 1024,
|
|
.bMaxBurst = 15,
|
|
.bmAttributes_super = UAS_STREAM_BM_ATTR,
|
|
.extra = (uint8_t[]) {
|
|
0x04, /* u8 bLength */
|
|
0x24, /* u8 bDescriptorType */
|
|
UAS_PIPE_ID_DATA_OUT,
|
|
0x00, /* u8 bReserved */
|
|
},
|
|
},
|
|
}
|
|
};
|
|
|
|
static const USBDescDevice desc_device_high = {
|
|
.bcdUSB = 0x0200,
|
|
.bMaxPacketSize0 = 64,
|
|
.bNumConfigurations = 1,
|
|
.confs = (USBDescConfig[]) {
|
|
{
|
|
.bNumInterfaces = 1,
|
|
.bConfigurationValue = 1,
|
|
.iConfiguration = STR_CONFIG_HIGH,
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
|
|
.nif = 1,
|
|
.ifs = &desc_iface_high,
|
|
},
|
|
},
|
|
};
|
|
|
|
static const USBDescDevice desc_device_super = {
|
|
.bcdUSB = 0x0300,
|
|
.bMaxPacketSize0 = 64,
|
|
.bNumConfigurations = 1,
|
|
.confs = (USBDescConfig[]) {
|
|
{
|
|
.bNumInterfaces = 1,
|
|
.bConfigurationValue = 1,
|
|
.iConfiguration = STR_CONFIG_SUPER,
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
|
|
.nif = 1,
|
|
.ifs = &desc_iface_super,
|
|
},
|
|
},
|
|
};
|
|
|
|
static const USBDesc desc = {
|
|
.id = {
|
|
.idVendor = 0x46f4, /* CRC16() of "QEMU" */
|
|
.idProduct = 0x0003,
|
|
.bcdDevice = 0,
|
|
.iManufacturer = STR_MANUFACTURER,
|
|
.iProduct = STR_PRODUCT,
|
|
.iSerialNumber = STR_SERIALNUMBER,
|
|
},
|
|
.high = &desc_device_high,
|
|
.super = &desc_device_super,
|
|
.str = desc_strings,
|
|
};
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static bool uas_using_streams(UASDevice *uas)
|
|
{
|
|
return uas->dev.speed == USB_SPEED_SUPER;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static UASStatus *usb_uas_alloc_status(UASDevice *uas, uint8_t id, uint16_t tag)
|
|
{
|
|
UASStatus *st = g_new0(UASStatus, 1);
|
|
|
|
st->status.hdr.id = id;
|
|
st->status.hdr.tag = cpu_to_be16(tag);
|
|
st->length = sizeof(uas_iu_header);
|
|
if (uas_using_streams(uas)) {
|
|
st->stream = tag;
|
|
}
|
|
return st;
|
|
}
|
|
|
|
static void usb_uas_send_status_bh(void *opaque)
|
|
{
|
|
UASDevice *uas = opaque;
|
|
UASStatus *st;
|
|
USBPacket *p;
|
|
|
|
while ((st = QTAILQ_FIRST(&uas->results)) != NULL) {
|
|
if (uas_using_streams(uas)) {
|
|
p = uas->status3[st->stream];
|
|
uas->status3[st->stream] = NULL;
|
|
} else {
|
|
p = uas->status2;
|
|
uas->status2 = NULL;
|
|
}
|
|
if (p == NULL) {
|
|
break;
|
|
}
|
|
|
|
usb_packet_copy(p, &st->status, st->length);
|
|
QTAILQ_REMOVE(&uas->results, st, next);
|
|
g_free(st);
|
|
|
|
p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
|
|
usb_packet_complete(&uas->dev, p);
|
|
}
|
|
}
|
|
|
|
static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
|
|
{
|
|
USBPacket *p = uas_using_streams(uas) ?
|
|
uas->status3[st->stream] : uas->status2;
|
|
|
|
st->length += length;
|
|
QTAILQ_INSERT_TAIL(&uas->results, st, next);
|
|
if (p) {
|
|
/*
|
|
* Just schedule bh make sure any in-flight data transaction
|
|
* is finished before completing (sending) the status packet.
|
|
*/
|
|
qemu_bh_schedule(uas->status_bh);
|
|
} else {
|
|
USBEndpoint *ep = usb_ep_get(&uas->dev, USB_TOKEN_IN,
|
|
UAS_PIPE_ID_STATUS);
|
|
usb_wakeup(ep, st->stream);
|
|
}
|
|
}
|
|
|
|
static void usb_uas_queue_response(UASDevice *uas, uint16_t tag, uint8_t code)
|
|
{
|
|
UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_RESPONSE, tag);
|
|
|
|
trace_usb_uas_response(uas->dev.addr, tag, code);
|
|
st->status.response.response_code = code;
|
|
usb_uas_queue_status(uas, st, sizeof(uas_iu_response));
|
|
}
|
|
|
|
static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
|
|
{
|
|
UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_SENSE, req->tag);
|
|
int len, slen = 0;
|
|
|
|
trace_usb_uas_sense(req->uas->dev.addr, req->tag, status);
|
|
st->status.sense.status = status;
|
|
st->status.sense.status_qualifier = cpu_to_be16(0);
|
|
if (status != GOOD) {
|
|
slen = scsi_req_get_sense(req->req, st->status.sense.sense_data,
|
|
sizeof(st->status.sense.sense_data));
|
|
st->status.sense.sense_length = cpu_to_be16(slen);
|
|
}
|
|
len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
|
|
usb_uas_queue_status(req->uas, st, len);
|
|
}
|
|
|
|
static void usb_uas_queue_fake_sense(UASDevice *uas, uint16_t tag,
|
|
struct SCSISense sense)
|
|
{
|
|
UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_SENSE, tag);
|
|
int len, slen = 0;
|
|
|
|
st->status.sense.status = CHECK_CONDITION;
|
|
st->status.sense.status_qualifier = cpu_to_be16(0);
|
|
st->status.sense.sense_data[0] = 0x70;
|
|
st->status.sense.sense_data[2] = sense.key;
|
|
st->status.sense.sense_data[7] = 10;
|
|
st->status.sense.sense_data[12] = sense.asc;
|
|
st->status.sense.sense_data[13] = sense.ascq;
|
|
slen = 18;
|
|
len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
|
|
usb_uas_queue_status(uas, st, len);
|
|
}
|
|
|
|
static void usb_uas_queue_read_ready(UASRequest *req)
|
|
{
|
|
UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_READ_READY,
|
|
req->tag);
|
|
|
|
trace_usb_uas_read_ready(req->uas->dev.addr, req->tag);
|
|
usb_uas_queue_status(req->uas, st, 0);
|
|
}
|
|
|
|
static void usb_uas_queue_write_ready(UASRequest *req)
|
|
{
|
|
UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_WRITE_READY,
|
|
req->tag);
|
|
|
|
trace_usb_uas_write_ready(req->uas->dev.addr, req->tag);
|
|
usb_uas_queue_status(req->uas, st, 0);
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static int usb_uas_get_lun(uint64_t lun64)
|
|
{
|
|
return (lun64 >> 48) & 0xff;
|
|
}
|
|
|
|
static SCSIDevice *usb_uas_get_dev(UASDevice *uas, uint64_t lun64)
|
|
{
|
|
if ((lun64 >> 56) != 0x00) {
|
|
return NULL;
|
|
}
|
|
return scsi_device_find(&uas->bus, 0, 0, usb_uas_get_lun(lun64));
|
|
}
|
|
|
|
static void usb_uas_complete_data_packet(UASRequest *req)
|
|
{
|
|
USBPacket *p;
|
|
|
|
if (!req->data_async) {
|
|
return;
|
|
}
|
|
p = req->data;
|
|
req->data = NULL;
|
|
req->data_async = false;
|
|
p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
|
|
usb_packet_complete(&req->uas->dev, p);
|
|
}
|
|
|
|
static void usb_uas_copy_data(UASRequest *req)
|
|
{
|
|
uint32_t length;
|
|
|
|
length = MIN(req->buf_size - req->buf_off,
|
|
req->data->iov.size - req->data->actual_length);
|
|
trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
|
|
req->data->actual_length, req->data->iov.size,
|
|
req->buf_off, req->buf_size);
|
|
usb_packet_copy(req->data, scsi_req_get_buf(req->req) + req->buf_off,
|
|
length);
|
|
req->buf_off += length;
|
|
req->data_off += length;
|
|
|
|
if (req->data->actual_length == req->data->iov.size) {
|
|
usb_uas_complete_data_packet(req);
|
|
}
|
|
if (req->buf_size && req->buf_off == req->buf_size) {
|
|
req->buf_off = 0;
|
|
req->buf_size = 0;
|
|
scsi_req_continue(req->req);
|
|
}
|
|
}
|
|
|
|
static void usb_uas_start_next_transfer(UASDevice *uas)
|
|
{
|
|
UASRequest *req;
|
|
|
|
if (uas_using_streams(uas)) {
|
|
return;
|
|
}
|
|
|
|
QTAILQ_FOREACH(req, &uas->requests, next) {
|
|
if (req->active || req->complete) {
|
|
continue;
|
|
}
|
|
if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain2 == NULL) {
|
|
uas->datain2 = req;
|
|
usb_uas_queue_read_ready(req);
|
|
req->active = true;
|
|
return;
|
|
}
|
|
if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout2 == NULL) {
|
|
uas->dataout2 = req;
|
|
usb_uas_queue_write_ready(req);
|
|
req->active = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_iu *iu)
|
|
{
|
|
UASRequest *req;
|
|
|
|
req = g_new0(UASRequest, 1);
|
|
req->uas = uas;
|
|
req->tag = be16_to_cpu(iu->hdr.tag);
|
|
req->lun = be64_to_cpu(iu->command.lun);
|
|
req->dev = usb_uas_get_dev(req->uas, req->lun);
|
|
return req;
|
|
}
|
|
|
|
static void usb_uas_scsi_free_request(SCSIBus *bus, void *priv)
|
|
{
|
|
UASRequest *req = priv;
|
|
UASDevice *uas = req->uas;
|
|
|
|
if (req == uas->datain2) {
|
|
uas->datain2 = NULL;
|
|
}
|
|
if (req == uas->dataout2) {
|
|
uas->dataout2 = NULL;
|
|
}
|
|
QTAILQ_REMOVE(&uas->requests, req, next);
|
|
g_free(req);
|
|
usb_uas_start_next_transfer(uas);
|
|
}
|
|
|
|
static UASRequest *usb_uas_find_request(UASDevice *uas, uint16_t tag)
|
|
{
|
|
UASRequest *req;
|
|
|
|
QTAILQ_FOREACH(req, &uas->requests, next) {
|
|
if (req->tag == tag) {
|
|
return req;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
|
|
{
|
|
UASRequest *req = r->hba_private;
|
|
|
|
trace_usb_uas_scsi_data(req->uas->dev.addr, req->tag, len);
|
|
req->buf_off = 0;
|
|
req->buf_size = len;
|
|
if (req->data) {
|
|
usb_uas_copy_data(req);
|
|
} else {
|
|
usb_uas_start_next_transfer(req->uas);
|
|
}
|
|
}
|
|
|
|
static void usb_uas_scsi_command_complete(SCSIRequest *r,
|
|
uint32_t status, size_t resid)
|
|
{
|
|
UASRequest *req = r->hba_private;
|
|
|
|
trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, status, resid);
|
|
req->complete = true;
|
|
if (req->data) {
|
|
usb_uas_complete_data_packet(req);
|
|
}
|
|
usb_uas_queue_sense(req, status);
|
|
scsi_req_unref(req->req);
|
|
}
|
|
|
|
static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
|
|
{
|
|
UASRequest *req = r->hba_private;
|
|
|
|
/* FIXME: queue notification to status pipe? */
|
|
scsi_req_unref(req->req);
|
|
}
|
|
|
|
static const struct SCSIBusInfo usb_uas_scsi_info = {
|
|
.tcq = true,
|
|
.max_target = 0,
|
|
.max_lun = 255,
|
|
|
|
.transfer_data = usb_uas_scsi_transfer_data,
|
|
.complete = usb_uas_scsi_command_complete,
|
|
.cancel = usb_uas_scsi_request_cancelled,
|
|
.free_request = usb_uas_scsi_free_request,
|
|
};
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static void usb_uas_handle_reset(USBDevice *dev)
|
|
{
|
|
UASDevice *uas = USB_UAS(dev);
|
|
UASRequest *req, *nreq;
|
|
UASStatus *st, *nst;
|
|
|
|
trace_usb_uas_reset(dev->addr);
|
|
QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
|
|
scsi_req_cancel(req->req);
|
|
}
|
|
QTAILQ_FOREACH_SAFE(st, &uas->results, next, nst) {
|
|
QTAILQ_REMOVE(&uas->results, st, next);
|
|
g_free(st);
|
|
}
|
|
}
|
|
|
|
static void usb_uas_handle_control(USBDevice *dev, USBPacket *p,
|
|
int request, int value, int index, int length, uint8_t *data)
|
|
{
|
|
int ret;
|
|
|
|
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
if (ret >= 0) {
|
|
return;
|
|
}
|
|
error_report("%s: unhandled control request", __func__);
|
|
p->status = USB_RET_STALL;
|
|
}
|
|
|
|
static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
|
|
{
|
|
UASDevice *uas = USB_UAS(dev);
|
|
UASRequest *req, *nreq;
|
|
int i;
|
|
|
|
if (uas->status2 == p) {
|
|
uas->status2 = NULL;
|
|
qemu_bh_cancel(uas->status_bh);
|
|
return;
|
|
}
|
|
if (uas_using_streams(uas)) {
|
|
for (i = 0; i <= UAS_MAX_STREAMS; i++) {
|
|
if (uas->status3[i] == p) {
|
|
uas->status3[i] = NULL;
|
|
return;
|
|
}
|
|
if (uas->data3[i] == p) {
|
|
uas->data3[i] = NULL;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
|
|
if (req->data == p) {
|
|
req->data = NULL;
|
|
return;
|
|
}
|
|
}
|
|
assert(!"canceled usb packet not found");
|
|
}
|
|
|
|
static void usb_uas_command(UASDevice *uas, uas_iu *iu)
|
|
{
|
|
UASRequest *req;
|
|
uint32_t len;
|
|
uint16_t tag = be16_to_cpu(iu->hdr.tag);
|
|
|
|
if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
|
|
goto invalid_tag;
|
|
}
|
|
req = usb_uas_find_request(uas, tag);
|
|
if (req) {
|
|
goto overlapped_tag;
|
|
}
|
|
req = usb_uas_alloc_request(uas, iu);
|
|
if (req->dev == NULL) {
|
|
goto bad_target;
|
|
}
|
|
|
|
trace_usb_uas_command(uas->dev.addr, req->tag,
|
|
usb_uas_get_lun(req->lun),
|
|
req->lun >> 32, req->lun & 0xffffffff);
|
|
QTAILQ_INSERT_TAIL(&uas->requests, req, next);
|
|
if (uas_using_streams(uas) && uas->data3[req->tag] != NULL) {
|
|
req->data = uas->data3[req->tag];
|
|
req->data_async = true;
|
|
uas->data3[req->tag] = NULL;
|
|
}
|
|
|
|
req->req = scsi_req_new(req->dev, req->tag,
|
|
usb_uas_get_lun(req->lun),
|
|
iu->command.cdb, req);
|
|
if (uas->requestlog) {
|
|
scsi_req_print(req->req);
|
|
}
|
|
len = scsi_req_enqueue(req->req);
|
|
if (len) {
|
|
req->data_size = len;
|
|
scsi_req_continue(req->req);
|
|
}
|
|
return;
|
|
|
|
invalid_tag:
|
|
usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_TAG);
|
|
return;
|
|
|
|
overlapped_tag:
|
|
usb_uas_queue_fake_sense(uas, tag, sense_code_OVERLAPPED_COMMANDS);
|
|
return;
|
|
|
|
bad_target:
|
|
usb_uas_queue_fake_sense(uas, tag, sense_code_LUN_NOT_SUPPORTED);
|
|
g_free(req);
|
|
}
|
|
|
|
static void usb_uas_task(UASDevice *uas, uas_iu *iu)
|
|
{
|
|
uint16_t tag = be16_to_cpu(iu->hdr.tag);
|
|
uint64_t lun64 = be64_to_cpu(iu->task.lun);
|
|
SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
|
|
int lun = usb_uas_get_lun(lun64);
|
|
UASRequest *req;
|
|
uint16_t task_tag;
|
|
|
|
if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
|
|
goto invalid_tag;
|
|
}
|
|
req = usb_uas_find_request(uas, be16_to_cpu(iu->hdr.tag));
|
|
if (req) {
|
|
goto overlapped_tag;
|
|
}
|
|
if (dev == NULL) {
|
|
goto incorrect_lun;
|
|
}
|
|
|
|
switch (iu->task.function) {
|
|
case UAS_TMF_ABORT_TASK:
|
|
task_tag = be16_to_cpu(iu->task.task_tag);
|
|
trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
|
|
req = usb_uas_find_request(uas, task_tag);
|
|
if (req && req->dev == dev) {
|
|
scsi_req_cancel(req->req);
|
|
}
|
|
usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
|
|
break;
|
|
|
|
case UAS_TMF_LOGICAL_UNIT_RESET:
|
|
trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
|
|
qdev_reset_all(&dev->qdev);
|
|
usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
|
|
break;
|
|
|
|
default:
|
|
trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, iu->task.function);
|
|
usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED);
|
|
break;
|
|
}
|
|
return;
|
|
|
|
invalid_tag:
|
|
usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT);
|
|
return;
|
|
|
|
overlapped_tag:
|
|
usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG);
|
|
return;
|
|
|
|
incorrect_lun:
|
|
usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN);
|
|
}
|
|
|
|
static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
|
|
{
|
|
UASDevice *uas = USB_UAS(dev);
|
|
uas_iu iu;
|
|
UASStatus *st;
|
|
UASRequest *req;
|
|
int length;
|
|
|
|
switch (p->ep->nr) {
|
|
case UAS_PIPE_ID_COMMAND:
|
|
length = MIN(sizeof(iu), p->iov.size);
|
|
usb_packet_copy(p, &iu, length);
|
|
switch (iu.hdr.id) {
|
|
case UAS_UI_COMMAND:
|
|
usb_uas_command(uas, &iu);
|
|
break;
|
|
case UAS_UI_TASK_MGMT:
|
|
usb_uas_task(uas, &iu);
|
|
break;
|
|
default:
|
|
error_report("%s: unknown command iu: id 0x%x",
|
|
__func__, iu.hdr.id);
|
|
p->status = USB_RET_STALL;
|
|
break;
|
|
}
|
|
break;
|
|
case UAS_PIPE_ID_STATUS:
|
|
if (p->stream) {
|
|
QTAILQ_FOREACH(st, &uas->results, next) {
|
|
if (st->stream == p->stream) {
|
|
break;
|
|
}
|
|
}
|
|
if (st == NULL) {
|
|
assert(uas->status3[p->stream] == NULL);
|
|
uas->status3[p->stream] = p;
|
|
p->status = USB_RET_ASYNC;
|
|
break;
|
|
}
|
|
} else {
|
|
st = QTAILQ_FIRST(&uas->results);
|
|
if (st == NULL) {
|
|
assert(uas->status2 == NULL);
|
|
uas->status2 = p;
|
|
p->status = USB_RET_ASYNC;
|
|
break;
|
|
}
|
|
}
|
|
usb_packet_copy(p, &st->status, st->length);
|
|
QTAILQ_REMOVE(&uas->results, st, next);
|
|
g_free(st);
|
|
break;
|
|
case UAS_PIPE_ID_DATA_IN:
|
|
case UAS_PIPE_ID_DATA_OUT:
|
|
if (p->stream) {
|
|
req = usb_uas_find_request(uas, p->stream);
|
|
} else {
|
|
req = (p->ep->nr == UAS_PIPE_ID_DATA_IN)
|
|
? uas->datain2 : uas->dataout2;
|
|
}
|
|
if (req == NULL) {
|
|
if (p->stream) {
|
|
assert(uas->data3[p->stream] == NULL);
|
|
uas->data3[p->stream] = p;
|
|
p->status = USB_RET_ASYNC;
|
|
break;
|
|
} else {
|
|
error_report("%s: no inflight request", __func__);
|
|
p->status = USB_RET_STALL;
|
|
break;
|
|
}
|
|
}
|
|
scsi_req_ref(req->req);
|
|
req->data = p;
|
|
usb_uas_copy_data(req);
|
|
if (p->actual_length == p->iov.size || req->complete) {
|
|
req->data = NULL;
|
|
} else {
|
|
req->data_async = true;
|
|
p->status = USB_RET_ASYNC;
|
|
}
|
|
scsi_req_unref(req->req);
|
|
usb_uas_start_next_transfer(uas);
|
|
break;
|
|
default:
|
|
error_report("%s: invalid endpoint %d", __func__, p->ep->nr);
|
|
p->status = USB_RET_STALL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void usb_uas_handle_destroy(USBDevice *dev)
|
|
{
|
|
UASDevice *uas = USB_UAS(dev);
|
|
|
|
qemu_bh_delete(uas->status_bh);
|
|
}
|
|
|
|
static void usb_uas_realize(USBDevice *dev, Error **errp)
|
|
{
|
|
UASDevice *uas = USB_UAS(dev);
|
|
|
|
usb_desc_create_serial(dev);
|
|
usb_desc_init(dev);
|
|
|
|
QTAILQ_INIT(&uas->results);
|
|
QTAILQ_INIT(&uas->requests);
|
|
uas->status_bh = qemu_bh_new(usb_uas_send_status_bh, uas);
|
|
|
|
scsi_bus_new(&uas->bus, sizeof(uas->bus), DEVICE(dev),
|
|
&usb_uas_scsi_info, NULL);
|
|
}
|
|
|
|
static const VMStateDescription vmstate_usb_uas = {
|
|
.name = "usb-uas",
|
|
.unmigratable = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_USB_DEVICE(dev, UASDevice),
|
|
VMSTATE_END_OF_LIST()
|
|
}
|
|
};
|
|
|
|
static Property uas_properties[] = {
|
|
DEFINE_PROP_UINT32("log-scsi-req", UASDevice, requestlog, 0),
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
};
|
|
|
|
static void usb_uas_class_initfn(ObjectClass *klass, void *data)
|
|
{
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
|
|
|
|
uc->realize = usb_uas_realize;
|
|
uc->product_desc = desc_strings[STR_PRODUCT];
|
|
uc->usb_desc = &desc;
|
|
uc->cancel_packet = usb_uas_cancel_io;
|
|
uc->handle_attach = usb_desc_attach;
|
|
uc->handle_reset = usb_uas_handle_reset;
|
|
uc->handle_control = usb_uas_handle_control;
|
|
uc->handle_data = usb_uas_handle_data;
|
|
uc->handle_destroy = usb_uas_handle_destroy;
|
|
set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
|
|
dc->fw_name = "storage";
|
|
dc->vmsd = &vmstate_usb_uas;
|
|
dc->props = uas_properties;
|
|
}
|
|
|
|
static const TypeInfo uas_info = {
|
|
.name = TYPE_USB_UAS,
|
|
.parent = TYPE_USB_DEVICE,
|
|
.instance_size = sizeof(UASDevice),
|
|
.class_init = usb_uas_class_initfn,
|
|
};
|
|
|
|
static void usb_uas_register_types(void)
|
|
{
|
|
type_register_static(&uas_info);
|
|
}
|
|
|
|
type_init(usb_uas_register_types)
|