* [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
@ 2012-07-02 9:41 Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 01/14] scsi: simplify handling of the VPD page length field Paolo Bonzini
` (14 more replies)
0 siblings, 15 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Anthony Liguori
Anthony,
The following changes since commit 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
bsd-user: fix build (2012-06-28 20:28:36 +0000)
are available in the git repository at:
git://github.com/bonzini/qemu.git scsi-next
for you to fetch changes up to 9ce1bb2d36f24af79d2757497acbaf4dc4a2e302:
scsi: Fix transfer length for READ POSITION commands. (2012-07-02 11:27:00 +0200)
The MegaSAS changes are rebased and it includes improved support for
SCSI tape and media changer commands.
----------------------------------------------------------------
Christian Hoff (4):
scsi: Fix data length == SCSI_SENSE_BUF_SIZE
scsi: Fix LOAD_UNLOAD
scsi: Add basic support for SCSI media changer commands.
scsi: Fix transfer length for READ POSITION commands.
Hannes Reinecke (2):
megasas: Add header file
megasas: LSI Megaraid SAS HBA emulation
Paolo Bonzini (6):
scsi: simplify handling of the VPD page length field
scsi: add a qdev property for the disk's WWN
atapi: implement READ DISC INFORMATION
scsi-disk: implement READ DISC INFORMATION
virtio-scsi: do not crash on adding buffers to the event queue
scsi: Ensure command and transfer lengths are set for all SCSI devices
Ronnie Sahlberg (2):
ISCSI: Add SCSI passthrough via scsi-generic to libiscsi
ISCSI: force use of sg for SMC and SSC devices
block/iscsi.c | 152 ++++
default-configs/pci.mak | 1 +
hw/Makefile.objs | 1 +
hw/ide/atapi.c | 31 +
hw/megasas.c | 2198 +++++++++++++++++++++++++++++++++++++++++++++++
hw/mfi.h | 1248 +++++++++++++++++++++++++++
hw/pci_ids.h | 2 +
hw/scsi-bus.c | 94 +-
hw/scsi-defs.h | 15 +-
hw/scsi-disk.c | 69 +-
hw/scsi-generic.c | 13 +-
hw/virtio-scsi.c | 6 +-
trace-events | 79 ++
13 files changed, 3872 insertions(+), 37 deletions(-)
create mode 100644 hw/megasas.c
create mode 100644 hw/mfi.h
--
1.7.10.2
^ permalink raw reply [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 01/14] scsi: simplify handling of the VPD page length field
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN Paolo Bonzini
` (13 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel
The last four bytes of the thin provisioning page were cut out.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-disk.c | 15 +++++++--------
1 file changed, 7 insertions(+), 8 deletions(-)
diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c
index ae25194..747e756 100644
--- a/hw/scsi-disk.c
+++ b/hw/scsi-disk.c
@@ -522,6 +522,7 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
int buflen = 0;
+ int start;
if (req->cmd.buf[1] & 0x1) {
/* Vital product data */
@@ -530,14 +531,14 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
outbuf[buflen++] = s->qdev.type & 0x1f;
outbuf[buflen++] = page_code ; // this page
outbuf[buflen++] = 0x00;
+ outbuf[buflen++] = 0x00;
+ start = buflen;
switch (page_code) {
case 0x00: /* Supported page codes, mandatory */
{
- int pages;
DPRINTF("Inquiry EVPD[Supported pages] "
"buffer size %zd\n", req->cmd.xfer);
- pages = buflen++;
outbuf[buflen++] = 0x00; // list of supported pages (this page)
if (s->serial) {
outbuf[buflen++] = 0x80; // unit serial number
@@ -547,7 +548,6 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
outbuf[buflen++] = 0xb0; // block limits
outbuf[buflen++] = 0xb2; // thin provisioning
}
- outbuf[pages] = buflen - pages - 1; // number of pages
break;
}
case 0x80: /* Device serial number, optional */
@@ -566,7 +566,6 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
DPRINTF("Inquiry EVPD[Serial number] "
"buffer size %zd\n", req->cmd.xfer);
- outbuf[buflen++] = l;
memcpy(outbuf+buflen, s->serial, l);
buflen += l;
break;
@@ -584,7 +583,6 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
DPRINTF("Inquiry EVPD[Device identification] "
"buffer size %zd\n", req->cmd.xfer);
- outbuf[buflen++] = 4 + id_len;
outbuf[buflen++] = 0x2; // ASCII
outbuf[buflen++] = 0; // not officially assigned
outbuf[buflen++] = 0; // reserved
@@ -609,8 +607,7 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
return -1;
}
/* required VPD size with unmap support */
- outbuf[3] = buflen = 0x3c;
-
+ buflen = 0x40;
memset(outbuf + 4, 0, buflen - 4);
/* optimal transfer length granularity */
@@ -632,7 +629,7 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
}
case 0xb2: /* thin provisioning */
{
- outbuf[3] = buflen = 8;
+ buflen = 8;
outbuf[4] = 0;
outbuf[5] = 0x60; /* write_same 10/16 supported */
outbuf[6] = s->qdev.conf.discard_granularity ? 2 : 1;
@@ -643,6 +640,8 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
return -1;
}
/* done with EVPD */
+ assert(buflen - start <= 255);
+ outbuf[start - 1] = buflen - start;
return buflen;
}
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 01/14] scsi: simplify handling of the VPD page length field Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-03 19:09 ` Blue Swirl
2012-07-02 9:41 ` [Qemu-devel] [PATCH 03/14] atapi: implement READ DISC INFORMATION Paolo Bonzini
` (12 subsequent siblings)
14 siblings, 1 reply; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-disk.c | 14 +++++++++++++-
1 file changed, 13 insertions(+), 1 deletion(-)
diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c
index 747e756..e87e57c 100644
--- a/hw/scsi-disk.c
+++ b/hw/scsi-disk.c
@@ -67,6 +67,7 @@ struct SCSIDiskState
bool media_changed;
bool media_event;
bool eject_request;
+ uint64_t wwn;
QEMUBH *bh;
char *version;
char *serial;
@@ -587,9 +588,17 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
outbuf[buflen++] = 0; // not officially assigned
outbuf[buflen++] = 0; // reserved
outbuf[buflen++] = id_len; // length of data following
-
memcpy(outbuf+buflen, str, id_len);
buflen += id_len;
+
+ if (s->wwn) {
+ outbuf[buflen++] = 0x1; // Binary
+ outbuf[buflen++] = 0x3; // NAA
+ outbuf[buflen++] = 0; // reserved
+ outbuf[buflen++] = 8;
+ stq_be_p(&outbuf[buflen], s->wwn);
+ buflen += 8;
+ }
break;
}
case 0xb0: /* block limits */
@@ -1924,6 +1933,7 @@ static Property scsi_hd_properties[] = {
SCSI_DISK_F_REMOVABLE, false),
DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
SCSI_DISK_F_DPOFUA, false),
+ DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
DEFINE_PROP_END_OF_LIST(),
};
@@ -1968,6 +1978,7 @@ static TypeInfo scsi_hd_info = {
static Property scsi_cd_properties[] = {
DEFINE_SCSI_DISK_PROPERTIES(),
+ DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
DEFINE_PROP_END_OF_LIST(),
};
@@ -2029,6 +2040,7 @@ static Property scsi_disk_properties[] = {
SCSI_DISK_F_REMOVABLE, false),
DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
SCSI_DISK_F_DPOFUA, false),
+ DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
DEFINE_PROP_END_OF_LIST(),
};
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 03/14] atapi: implement READ DISC INFORMATION
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 01/14] scsi: simplify handling of the VPD page length field Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 04/14] scsi-disk: " Paolo Bonzini
` (11 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Kevin Wolf, Markus Armbruster
This command is not necessary for CD-ROM and DVD-ROM, but some versions of
udev trip on its absence.
Cc: Kevin Wolf <kwolf@redhat.com>
Cc: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/ide/atapi.c | 31 +++++++++++++++++++++++++++++++
1 file changed, 31 insertions(+)
diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
index 5919cf5..f7f714c 100644
--- a/hw/ide/atapi.c
+++ b/hw/ide/atapi.c
@@ -956,6 +956,36 @@ static void cmd_read_cdvd_capacity(IDEState *s, uint8_t* buf)
ide_atapi_cmd_reply(s, 8, 8);
}
+static void cmd_read_disc_information(IDEState *s, uint8_t* buf)
+{
+ uint8_t type = buf[1] & 7;
+ uint32_t max_len = ube16_to_cpu(buf + 7);
+
+ /* Types 1/2 are only defined for Blu-Ray. */
+ if (type != 0) {
+ ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
+ ASC_INV_FIELD_IN_CMD_PACKET);
+ return;
+ }
+
+ memset(buf, 0, 34);
+ buf[1] = 32;
+ buf[2] = 0xe; /* last session complete, disc finalized */
+ buf[3] = 1; /* first track on disc */
+ buf[4] = 1; /* # of sessions */
+ buf[5] = 1; /* first track of last session */
+ buf[6] = 1; /* last track of last session */
+ buf[7] = 0x20; /* unrestricted use */
+ buf[8] = 0x00; /* CD-ROM or DVD-ROM */
+ /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
+ /* 12-23: not meaningful for CD-ROM or DVD-ROM */
+ /* 24-31: disc bar code */
+ /* 32: disc application code */
+ /* 33: number of OPC tables */
+
+ ide_atapi_cmd_reply(s, 34, max_len);
+}
+
static void cmd_read_dvd_structure(IDEState *s, uint8_t* buf)
{
int max_len;
@@ -1045,6 +1075,7 @@ static const struct {
[ 0x43 ] = { cmd_read_toc_pma_atip, CHECK_READY },
[ 0x46 ] = { cmd_get_configuration, ALLOW_UA },
[ 0x4a ] = { cmd_get_event_status_notification, ALLOW_UA },
+ [ 0x51 ] = { cmd_read_disc_information, CHECK_READY },
[ 0x5a ] = { cmd_mode_sense, /* (10) */ 0 },
[ 0xa8 ] = { cmd_read, /* (12) */ CHECK_READY },
[ 0xad ] = { cmd_read_dvd_structure, CHECK_READY },
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 04/14] scsi-disk: implement READ DISC INFORMATION
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (2 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 03/14] atapi: implement READ DISC INFORMATION Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 05/14] ISCSI: Add SCSI passthrough via scsi-generic to libiscsi Paolo Bonzini
` (10 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Kevin Wolf, Markus Armbruster
This command is not necessary for CD-ROM and DVD-ROM, but some versions of
udev trip on its absence.
Cc: Kevin Wolf <kwolf@redhat.com>
Cc: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-defs.h | 1 +
hw/scsi-disk.c | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 41 insertions(+)
diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h
index 219c84d..3c9f1b5 100644
--- a/hw/scsi-defs.h
+++ b/hw/scsi-defs.h
@@ -82,6 +82,7 @@
#define GET_EVENT_STATUS_NOTIFICATION 0x4a
#define LOG_SELECT 0x4c
#define LOG_SENSE 0x4d
+#define READ_DISC_INFORMATION 0x51
#define RESERVE_TRACK 0x53
#define MODE_SELECT_10 0x55
#define RESERVE_10 0x56
diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c
index e87e57c..34336b1 100644
--- a/hw/scsi-disk.c
+++ b/hw/scsi-disk.c
@@ -724,6 +724,39 @@ static inline bool media_is_cd(SCSIDiskState *s)
return nb_sectors <= CD_MAX_SECTORS;
}
+static int scsi_read_disc_information(SCSIDiskState *s, SCSIDiskReq *r,
+ uint8_t *outbuf)
+{
+ uint8_t type = r->req.cmd.buf[1] & 7;
+
+ if (s->qdev.type != TYPE_ROM) {
+ return -1;
+ }
+
+ /* Types 1/2 are only defined for Blu-Ray. */
+ if (type != 0) {
+ scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
+ return -1;
+ }
+
+ memset(outbuf, 0, 34);
+ outbuf[1] = 32;
+ outbuf[2] = 0xe; /* last session complete, disc finalized */
+ outbuf[3] = 1; /* first track on disc */
+ outbuf[4] = 1; /* # of sessions */
+ outbuf[5] = 1; /* first track of last session */
+ outbuf[6] = 1; /* last track of last session */
+ outbuf[7] = 0x20; /* unrestricted use */
+ outbuf[8] = 0x00; /* CD-ROM or DVD-ROM */
+ /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
+ /* 12-23: not meaningful for CD-ROM or DVD-ROM */
+ /* 24-31: disc bar code */
+ /* 32: disc application code */
+ /* 33: number of OPC tables */
+
+ return 34;
+}
+
static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r,
uint8_t *outbuf)
{
@@ -1363,6 +1396,12 @@ static int scsi_disk_emulate_command(SCSIDiskReq *r)
goto illegal_request;
}
break;
+ case READ_DISC_INFORMATION:
+ buflen = scsi_read_disc_information(s, r, outbuf);
+ if (buflen < 0) {
+ goto illegal_request;
+ }
+ break;
case READ_DVD_STRUCTURE:
buflen = scsi_read_dvd_structure(s, r, outbuf);
if (buflen < 0) {
@@ -1490,6 +1529,7 @@ static int32_t scsi_send_command(SCSIRequest *req, uint8_t *buf)
case ALLOW_MEDIUM_REMOVAL:
case READ_CAPACITY_10:
case READ_TOC:
+ case READ_DISC_INFORMATION:
case READ_DVD_STRUCTURE:
case GET_CONFIGURATION:
case GET_EVENT_STATUS_NOTIFICATION:
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 05/14] ISCSI: Add SCSI passthrough via scsi-generic to libiscsi
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (3 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 04/14] scsi-disk: " Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 06/14] ISCSI: force use of sg for SMC and SSC devices Paolo Bonzini
` (9 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Ronnie Sahlberg
From: Ronnie Sahlberg <ronniesahlberg@gmail.com>
Update iscsi to allow passthrough of SG_IO scsi commands when the iscsi
device is forced to be scsi-generic.
Implement both bdrv_ioctl() and bdrv_aio_ioctl() in the iscsi backend,
emulate the SG_IO ioctl and pass the SCSI commands across to the
iscsi target.
This allows end-to-end passthrough of SCSI all the way from the guest,
to qemu, via scsi-generic, then libiscsi all the way to the iscsi target.
To activate this you need to specify that the iscsi lun should be treated
as a scsi-generic device.
Example:
-device lsi -device scsi-generic,drive=MyISCSI \
-drive file=iscsi://10.1.1.125/iqn.ronnie.test/1,if=none,id=MyISCSI
Note, you can currently not boot a qemu guest from a scsi device.
Note,
This only works when the host is linux, since the emulation relies on
definitions of SG_IO from the scsi-generic implementation in the
linux kernel.
It should be fairly easy to re-implement some structures similar enough
for non-linux hosts to do the same style of passthrough via a fake
scsi generic layer and libiscsi if need be.
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
block/iscsi.c | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++++
hw/scsi-generic.c | 13 ++---
2 files changed, 147 insertions(+), 8 deletions(-)
diff --git a/block/iscsi.c b/block/iscsi.c
index 22888a0..029739e 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -35,6 +35,10 @@
#include <iscsi/iscsi.h>
#include <iscsi/scsi-lowlevel.h>
+#ifdef __linux__
+#include <scsi/sg.h>
+#include <hw/scsi-defs.h>
+#endif
typedef struct IscsiLun {
struct iscsi_context *iscsi;
@@ -56,6 +60,9 @@ typedef struct IscsiAIOCB {
int canceled;
size_t read_size;
size_t read_offset;
+#ifdef __linux__
+ sg_io_hdr_t *ioh;
+#endif
} IscsiAIOCB;
struct IscsiTask {
@@ -515,6 +522,136 @@ iscsi_aio_discard(BlockDriverState *bs,
return &acb->common;
}
+#ifdef __linux__
+static void
+iscsi_aio_ioctl_cb(struct iscsi_context *iscsi, int status,
+ void *command_data, void *opaque)
+{
+ IscsiAIOCB *acb = opaque;
+
+ if (acb->canceled != 0) {
+ qemu_aio_release(acb);
+ scsi_free_scsi_task(acb->task);
+ acb->task = NULL;
+ return;
+ }
+
+ acb->status = 0;
+ if (status < 0) {
+ error_report("Failed to ioctl(SG_IO) to iSCSI lun. %s",
+ iscsi_get_error(iscsi));
+ acb->status = -EIO;
+ }
+
+ acb->ioh->driver_status = 0;
+ acb->ioh->host_status = 0;
+ acb->ioh->resid = 0;
+
+#define SG_ERR_DRIVER_SENSE 0x08
+
+ if (status == SCSI_STATUS_CHECK_CONDITION && acb->task->datain.size >= 2) {
+ int ss;
+
+ acb->ioh->driver_status |= SG_ERR_DRIVER_SENSE;
+
+ acb->ioh->sb_len_wr = acb->task->datain.size - 2;
+ ss = (acb->ioh->mx_sb_len >= acb->ioh->sb_len_wr) ?
+ acb->ioh->mx_sb_len : acb->ioh->sb_len_wr;
+ memcpy(acb->ioh->sbp, &acb->task->datain.data[2], ss);
+ }
+
+ iscsi_schedule_bh(iscsi_readv_writev_bh_cb, acb);
+ scsi_free_scsi_task(acb->task);
+ acb->task = NULL;
+}
+
+static BlockDriverAIOCB *iscsi_aio_ioctl(BlockDriverState *bs,
+ unsigned long int req, void *buf,
+ BlockDriverCompletionFunc *cb, void *opaque)
+{
+ IscsiLun *iscsilun = bs->opaque;
+ struct iscsi_context *iscsi = iscsilun->iscsi;
+ struct iscsi_data data;
+ IscsiAIOCB *acb;
+
+ assert(req == SG_IO);
+
+ acb = qemu_aio_get(&iscsi_aio_pool, bs, cb, opaque);
+
+ acb->iscsilun = iscsilun;
+ acb->canceled = 0;
+ acb->buf = NULL;
+ acb->ioh = buf;
+
+ acb->task = malloc(sizeof(struct scsi_task));
+ if (acb->task == NULL) {
+ error_report("iSCSI: Failed to allocate task for scsi command. %s",
+ iscsi_get_error(iscsi));
+ qemu_aio_release(acb);
+ return NULL;
+ }
+ memset(acb->task, 0, sizeof(struct scsi_task));
+
+ switch (acb->ioh->dxfer_direction) {
+ case SG_DXFER_TO_DEV:
+ acb->task->xfer_dir = SCSI_XFER_WRITE;
+ break;
+ case SG_DXFER_FROM_DEV:
+ acb->task->xfer_dir = SCSI_XFER_READ;
+ break;
+ default:
+ acb->task->xfer_dir = SCSI_XFER_NONE;
+ break;
+ }
+
+ acb->task->cdb_size = acb->ioh->cmd_len;
+ memcpy(&acb->task->cdb[0], acb->ioh->cmdp, acb->ioh->cmd_len);
+ acb->task->expxferlen = acb->ioh->dxfer_len;
+
+ if (acb->task->xfer_dir == SCSI_XFER_WRITE) {
+ data.data = acb->ioh->dxferp;
+ data.size = acb->ioh->dxfer_len;
+ }
+ if (iscsi_scsi_command_async(iscsi, iscsilun->lun, acb->task,
+ iscsi_aio_ioctl_cb,
+ (acb->task->xfer_dir == SCSI_XFER_WRITE) ?
+ &data : NULL,
+ acb) != 0) {
+ scsi_free_scsi_task(acb->task);
+ qemu_aio_release(acb);
+ return NULL;
+ }
+
+ /* tell libiscsi to read straight into the buffer we got from ioctl */
+ if (acb->task->xfer_dir == SCSI_XFER_READ) {
+ scsi_task_add_data_in_buffer(acb->task,
+ acb->ioh->dxfer_len,
+ acb->ioh->dxferp);
+ }
+
+ iscsi_set_events(iscsilun);
+
+ return &acb->common;
+}
+
+static int iscsi_ioctl(BlockDriverState *bs, unsigned long int req, void *buf)
+{
+ IscsiLun *iscsilun = bs->opaque;
+
+ switch (req) {
+ case SG_GET_VERSION_NUM:
+ *(int *)buf = 30000;
+ break;
+ case SG_GET_SCSI_ID:
+ ((struct sg_scsi_id *)buf)->scsi_type = iscsilun->type;
+ break;
+ default:
+ return -1;
+ }
+ return 0;
+}
+#endif
+
static int64_t
iscsi_getlength(BlockDriverState *bs)
{
@@ -926,6 +1063,11 @@ static BlockDriver bdrv_iscsi = {
.bdrv_aio_flush = iscsi_aio_flush,
.bdrv_aio_discard = iscsi_aio_discard,
+
+#ifdef __linux__
+ .bdrv_ioctl = iscsi_ioctl,
+ .bdrv_aio_ioctl = iscsi_aio_ioctl,
+#endif
};
static void iscsi_block_init(void)
diff --git a/hw/scsi-generic.c b/hw/scsi-generic.c
index d856d23..8d51060 100644
--- a/hw/scsi-generic.c
+++ b/hw/scsi-generic.c
@@ -400,12 +400,6 @@ static int scsi_generic_initfn(SCSIDevice *s)
return -1;
}
- /* check we are really using a /dev/sg* file */
- if (!bdrv_is_sg(s->conf.bs)) {
- error_report("not /dev/sg*");
- return -1;
- }
-
if (bdrv_get_on_error(s->conf.bs, 0) != BLOCK_ERR_STOP_ENOSPC) {
error_report("Device doesn't support drive option werror");
return -1;
@@ -416,8 +410,11 @@ static int scsi_generic_initfn(SCSIDevice *s)
}
/* check we are using a driver managing SG_IO (version 3 and after */
- if (bdrv_ioctl(s->conf.bs, SG_GET_VERSION_NUM, &sg_version) < 0 ||
- sg_version < 30000) {
+ if (bdrv_ioctl(s->conf.bs, SG_GET_VERSION_NUM, &sg_version) < 0) {
+ error_report("scsi generic interface not supported");
+ return -1;
+ }
+ if (sg_version < 30000) {
error_report("scsi generic interface too old");
return -1;
}
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 06/14] ISCSI: force use of sg for SMC and SSC devices
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (4 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 05/14] ISCSI: Add SCSI passthrough via scsi-generic to libiscsi Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 07/14] megasas: Add header file Paolo Bonzini
` (8 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Ronnie Sahlberg
From: Ronnie Sahlberg <ronniesahlberg@gmail.com>
If the device we open is a SMC or SSC device, then force the use of sg. We
dont have any medium changer or tape emulation so only passthrough via
real sg or scsi-generic via iscsi would work anyway.
Forcing sg also makes qemu skip trying to read from the device to guess
the image format by reading from the device (find_image_format()).
SMC devices do not implement READ6/10/12/16 so it is not possible to
read from them (SSC have different CDBs).
With this patch I can successfully manage a SMC device wiht iscsi in
passthrough mode.
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
[Added TYPE_TAPE handling - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
block/iscsi.c | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/block/iscsi.c b/block/iscsi.c
index 029739e..ac65277 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -1022,6 +1022,16 @@ static int iscsi_open(BlockDriverState *bs, const char *filename, int flags)
if (iscsi_url != NULL) {
iscsi_destroy_url(iscsi_url);
}
+
+ /* Medium changer or tape. We dont have any emulation for this so this must
+ * be sg ioctl compatible. We force it to be sg, otherwise qemu will try
+ * to read from the device to guess the image format.
+ */
+ if (iscsilun->type == TYPE_MEDIUM_CHANGER ||
+ iscsilun->type == TYPE_TAPE) {
+ bs->sg = 1;
+ }
+
return 0;
failed:
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 07/14] megasas: Add header file
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (5 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 06/14] ISCSI: force use of sg for SMC and SSC devices Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation Paolo Bonzini
` (7 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Hannes Reinecke
From: Hannes Reinecke <hare@suse.de>
This patch adds the header file for megasas.
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/mfi.h | 1248 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 1248 insertions(+)
create mode 100644 hw/mfi.h
diff --git a/hw/mfi.h b/hw/mfi.h
new file mode 100644
index 0000000..8a82162
--- /dev/null
+++ b/hw/mfi.h
@@ -0,0 +1,1248 @@
+/*
+ * NetBSD header file, copied from
+ * http://gitorious.org/freebsd/freebsd/blobs/HEAD/sys/dev/mfi/mfireg.h
+ */
+/*-
+ * Copyright (c) 2006 IronPort Systems
+ * Copyright (c) 2007 LSI Corp.
+ * Copyright (c) 2007 Rajesh Prabhakaran.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
+ */
+
+#ifndef MFI_REG_H
+#define MFI_REG_H
+
+/*
+ * MegaRAID SAS MFI firmware definitions
+ */
+
+/*
+ * Start with the register set. All registers are 32 bits wide.
+ * The usual Intel IOP style setup.
+ */
+#define MFI_IMSG0 0x10 /* Inbound message 0 */
+#define MFI_IMSG1 0x14 /* Inbound message 1 */
+#define MFI_OMSG0 0x18 /* Outbound message 0 */
+#define MFI_OMSG1 0x1c /* Outbound message 1 */
+#define MFI_IDB 0x20 /* Inbound doorbell */
+#define MFI_ISTS 0x24 /* Inbound interrupt status */
+#define MFI_IMSK 0x28 /* Inbound interrupt mask */
+#define MFI_ODB 0x2c /* Outbound doorbell */
+#define MFI_OSTS 0x30 /* Outbound interrupt status */
+#define MFI_OMSK 0x34 /* Outbound interrupt mask */
+#define MFI_IQP 0x40 /* Inbound queue port */
+#define MFI_OQP 0x44 /* Outbound queue port */
+
+/*
+ * 1078 specific related register
+ */
+#define MFI_ODR0 0x9c /* outbound doorbell register0 */
+#define MFI_ODCR0 0xa0 /* outbound doorbell clear register0 */
+#define MFI_OSP0 0xb0 /* outbound scratch pad0 */
+#define MFI_IQPL 0xc0 /* Inbound queue port (low bytes) */
+#define MFI_IQPH 0xc4 /* Inbound queue port (high bytes) */
+#define MFI_DIAG 0xf8 /* Host diag */
+#define MFI_SEQ 0xfc /* Sequencer offset */
+#define MFI_1078_EIM 0x80000004 /* 1078 enable intrrupt mask */
+#define MFI_RMI 0x2 /* reply message interrupt */
+#define MFI_1078_RM 0x80000000 /* reply 1078 message interrupt */
+#define MFI_ODC 0x4 /* outbound doorbell change interrupt */
+
+/*
+ * gen2 specific changes
+ */
+#define MFI_GEN2_EIM 0x00000005 /* gen2 enable interrupt mask */
+#define MFI_GEN2_RM 0x00000001 /* reply gen2 message interrupt */
+
+/*
+ * skinny specific changes
+ */
+#define MFI_SKINNY_IDB 0x00 /* Inbound doorbell is at 0x00 for skinny */
+#define MFI_SKINNY_RM 0x00000001 /* reply skinny message interrupt */
+
+/* Bits for MFI_OSTS */
+#define MFI_OSTS_INTR_VALID 0x00000002
+
+/*
+ * Firmware state values. Found in OMSG0 during initialization.
+ */
+#define MFI_FWSTATE_MASK 0xf0000000
+#define MFI_FWSTATE_UNDEFINED 0x00000000
+#define MFI_FWSTATE_BB_INIT 0x10000000
+#define MFI_FWSTATE_FW_INIT 0x40000000
+#define MFI_FWSTATE_WAIT_HANDSHAKE 0x60000000
+#define MFI_FWSTATE_FW_INIT_2 0x70000000
+#define MFI_FWSTATE_DEVICE_SCAN 0x80000000
+#define MFI_FWSTATE_BOOT_MSG_PENDING 0x90000000
+#define MFI_FWSTATE_FLUSH_CACHE 0xa0000000
+#define MFI_FWSTATE_READY 0xb0000000
+#define MFI_FWSTATE_OPERATIONAL 0xc0000000
+#define MFI_FWSTATE_FAULT 0xf0000000
+#define MFI_FWSTATE_MAXSGL_MASK 0x00ff0000
+#define MFI_FWSTATE_MAXCMD_MASK 0x0000ffff
+#define MFI_FWSTATE_MSIX_SUPPORTED 0x04000000
+#define MFI_FWSTATE_HOSTMEMREQD_MASK 0x08000000
+
+/*
+ * Control bits to drive the card to ready state. These go into the IDB
+ * register.
+ */
+#define MFI_FWINIT_ABORT 0x00000001 /* Abort all pending commands */
+#define MFI_FWINIT_READY 0x00000002 /* Move from operational to ready */
+#define MFI_FWINIT_MFIMODE 0x00000004 /* unknown */
+#define MFI_FWINIT_CLEAR_HANDSHAKE 0x00000008 /* Respond to WAIT_HANDSHAKE */
+#define MFI_FWINIT_HOTPLUG 0x00000010
+#define MFI_FWINIT_STOP_ADP 0x00000020 /* Move to operational, stop */
+#define MFI_FWINIT_ADP_RESET 0x00000040 /* Reset ADP */
+
+/* MFI Commands */
+typedef enum {
+ MFI_CMD_INIT = 0x00,
+ MFI_CMD_LD_READ,
+ MFI_CMD_LD_WRITE,
+ MFI_CMD_LD_SCSI_IO,
+ MFI_CMD_PD_SCSI_IO,
+ MFI_CMD_DCMD,
+ MFI_CMD_ABORT,
+ MFI_CMD_SMP,
+ MFI_CMD_STP
+} mfi_cmd_t;
+
+/* Direct commands */
+typedef enum {
+ MFI_DCMD_CTRL_MFI_HOST_MEM_ALLOC = 0x0100e100,
+ MFI_DCMD_CTRL_GET_INFO = 0x01010000,
+ MFI_DCMD_CTRL_GET_PROPERTIES = 0x01020100,
+ MFI_DCMD_CTRL_SET_PROPERTIES = 0x01020200,
+ MFI_DCMD_CTRL_ALARM = 0x01030000,
+ MFI_DCMD_CTRL_ALARM_GET = 0x01030100,
+ MFI_DCMD_CTRL_ALARM_ENABLE = 0x01030200,
+ MFI_DCMD_CTRL_ALARM_DISABLE = 0x01030300,
+ MFI_DCMD_CTRL_ALARM_SILENCE = 0x01030400,
+ MFI_DCMD_CTRL_ALARM_TEST = 0x01030500,
+ MFI_DCMD_CTRL_EVENT_GETINFO = 0x01040100,
+ MFI_DCMD_CTRL_EVENT_CLEAR = 0x01040200,
+ MFI_DCMD_CTRL_EVENT_GET = 0x01040300,
+ MFI_DCMD_CTRL_EVENT_COUNT = 0x01040400,
+ MFI_DCMD_CTRL_EVENT_WAIT = 0x01040500,
+ MFI_DCMD_CTRL_SHUTDOWN = 0x01050000,
+ MFI_DCMD_HIBERNATE_STANDBY = 0x01060000,
+ MFI_DCMD_CTRL_GET_TIME = 0x01080101,
+ MFI_DCMD_CTRL_SET_TIME = 0x01080102,
+ MFI_DCMD_CTRL_BIOS_DATA_GET = 0x010c0100,
+ MFI_DCMD_CTRL_BIOS_DATA_SET = 0x010c0200,
+ MFI_DCMD_CTRL_FACTORY_DEFAULTS = 0x010d0000,
+ MFI_DCMD_CTRL_MFC_DEFAULTS_GET = 0x010e0201,
+ MFI_DCMD_CTRL_MFC_DEFAULTS_SET = 0x010e0202,
+ MFI_DCMD_CTRL_CACHE_FLUSH = 0x01101000,
+ MFI_DCMD_PD_GET_LIST = 0x02010000,
+ MFI_DCMD_PD_LIST_QUERY = 0x02010100,
+ MFI_DCMD_PD_GET_INFO = 0x02020000,
+ MFI_DCMD_PD_STATE_SET = 0x02030100,
+ MFI_DCMD_PD_REBUILD = 0x02040100,
+ MFI_DCMD_PD_BLINK = 0x02070100,
+ MFI_DCMD_PD_UNBLINK = 0x02070200,
+ MFI_DCMD_LD_GET_LIST = 0x03010000,
+ MFI_DCMD_LD_GET_INFO = 0x03020000,
+ MFI_DCMD_LD_GET_PROP = 0x03030000,
+ MFI_DCMD_LD_SET_PROP = 0x03040000,
+ MFI_DCMD_LD_DELETE = 0x03090000,
+ MFI_DCMD_CFG_READ = 0x04010000,
+ MFI_DCMD_CFG_ADD = 0x04020000,
+ MFI_DCMD_CFG_CLEAR = 0x04030000,
+ MFI_DCMD_CFG_FOREIGN_READ = 0x04060100,
+ MFI_DCMD_CFG_FOREIGN_IMPORT = 0x04060400,
+ MFI_DCMD_BBU_STATUS = 0x05010000,
+ MFI_DCMD_BBU_CAPACITY_INFO = 0x05020000,
+ MFI_DCMD_BBU_DESIGN_INFO = 0x05030000,
+ MFI_DCMD_BBU_PROP_GET = 0x05050100,
+ MFI_DCMD_CLUSTER = 0x08000000,
+ MFI_DCMD_CLUSTER_RESET_ALL = 0x08010100,
+ MFI_DCMD_CLUSTER_RESET_LD = 0x08010200
+} mfi_dcmd_t;
+
+/* Modifiers for MFI_DCMD_CTRL_FLUSHCACHE */
+#define MFI_FLUSHCACHE_CTRL 0x01
+#define MFI_FLUSHCACHE_DISK 0x02
+
+/* Modifiers for MFI_DCMD_CTRL_SHUTDOWN */
+#define MFI_SHUTDOWN_SPINDOWN 0x01
+
+/*
+ * MFI Frame flags
+ */
+typedef enum {
+ MFI_FRAME_DONT_POST_IN_REPLY_QUEUE = 0x0001,
+ MFI_FRAME_SGL64 = 0x0002,
+ MFI_FRAME_SENSE64 = 0x0004,
+ MFI_FRAME_DIR_WRITE = 0x0008,
+ MFI_FRAME_DIR_READ = 0x0010,
+ MFI_FRAME_IEEE_SGL = 0x0020,
+} mfi_frame_flags;
+
+/* MFI Status codes */
+typedef enum {
+ MFI_STAT_OK = 0x00,
+ MFI_STAT_INVALID_CMD,
+ MFI_STAT_INVALID_DCMD,
+ MFI_STAT_INVALID_PARAMETER,
+ MFI_STAT_INVALID_SEQUENCE_NUMBER,
+ MFI_STAT_ABORT_NOT_POSSIBLE,
+ MFI_STAT_APP_HOST_CODE_NOT_FOUND,
+ MFI_STAT_APP_IN_USE,
+ MFI_STAT_APP_NOT_INITIALIZED,
+ MFI_STAT_ARRAY_INDEX_INVALID,
+ MFI_STAT_ARRAY_ROW_NOT_EMPTY,
+ MFI_STAT_CONFIG_RESOURCE_CONFLICT,
+ MFI_STAT_DEVICE_NOT_FOUND,
+ MFI_STAT_DRIVE_TOO_SMALL,
+ MFI_STAT_FLASH_ALLOC_FAIL,
+ MFI_STAT_FLASH_BUSY,
+ MFI_STAT_FLASH_ERROR = 0x10,
+ MFI_STAT_FLASH_IMAGE_BAD,
+ MFI_STAT_FLASH_IMAGE_INCOMPLETE,
+ MFI_STAT_FLASH_NOT_OPEN,
+ MFI_STAT_FLASH_NOT_STARTED,
+ MFI_STAT_FLUSH_FAILED,
+ MFI_STAT_HOST_CODE_NOT_FOUNT,
+ MFI_STAT_LD_CC_IN_PROGRESS,
+ MFI_STAT_LD_INIT_IN_PROGRESS,
+ MFI_STAT_LD_LBA_OUT_OF_RANGE,
+ MFI_STAT_LD_MAX_CONFIGURED,
+ MFI_STAT_LD_NOT_OPTIMAL,
+ MFI_STAT_LD_RBLD_IN_PROGRESS,
+ MFI_STAT_LD_RECON_IN_PROGRESS,
+ MFI_STAT_LD_WRONG_RAID_LEVEL,
+ MFI_STAT_MAX_SPARES_EXCEEDED,
+ MFI_STAT_MEMORY_NOT_AVAILABLE = 0x20,
+ MFI_STAT_MFC_HW_ERROR,
+ MFI_STAT_NO_HW_PRESENT,
+ MFI_STAT_NOT_FOUND,
+ MFI_STAT_NOT_IN_ENCL,
+ MFI_STAT_PD_CLEAR_IN_PROGRESS,
+ MFI_STAT_PD_TYPE_WRONG,
+ MFI_STAT_PR_DISABLED,
+ MFI_STAT_ROW_INDEX_INVALID,
+ MFI_STAT_SAS_CONFIG_INVALID_ACTION,
+ MFI_STAT_SAS_CONFIG_INVALID_DATA,
+ MFI_STAT_SAS_CONFIG_INVALID_PAGE,
+ MFI_STAT_SAS_CONFIG_INVALID_TYPE,
+ MFI_STAT_SCSI_DONE_WITH_ERROR,
+ MFI_STAT_SCSI_IO_FAILED,
+ MFI_STAT_SCSI_RESERVATION_CONFLICT,
+ MFI_STAT_SHUTDOWN_FAILED = 0x30,
+ MFI_STAT_TIME_NOT_SET,
+ MFI_STAT_WRONG_STATE,
+ MFI_STAT_LD_OFFLINE,
+ MFI_STAT_PEER_NOTIFICATION_REJECTED,
+ MFI_STAT_PEER_NOTIFICATION_FAILED,
+ MFI_STAT_RESERVATION_IN_PROGRESS,
+ MFI_STAT_I2C_ERRORS_DETECTED,
+ MFI_STAT_PCI_ERRORS_DETECTED,
+ MFI_STAT_DIAG_FAILED,
+ MFI_STAT_BOOT_MSG_PENDING,
+ MFI_STAT_FOREIGN_CONFIG_INCOMPLETE,
+ MFI_STAT_INVALID_SGL,
+ MFI_STAT_UNSUPPORTED_HW,
+ MFI_STAT_CC_SCHEDULE_DISABLED,
+ MFI_STAT_PD_COPYBACK_IN_PROGRESS,
+ MFI_STAT_MULTIPLE_PDS_IN_ARRAY = 0x40,
+ MFI_STAT_FW_DOWNLOAD_ERROR,
+ MFI_STAT_FEATURE_SECURITY_NOT_ENABLED,
+ MFI_STAT_LOCK_KEY_ALREADY_EXISTS,
+ MFI_STAT_LOCK_KEY_BACKUP_NOT_ALLOWED,
+ MFI_STAT_LOCK_KEY_VERIFY_NOT_ALLOWED,
+ MFI_STAT_LOCK_KEY_VERIFY_FAILED,
+ MFI_STAT_LOCK_KEY_REKEY_NOT_ALLOWED,
+ MFI_STAT_LOCK_KEY_INVALID,
+ MFI_STAT_LOCK_KEY_ESCROW_INVALID,
+ MFI_STAT_LOCK_KEY_BACKUP_REQUIRED,
+ MFI_STAT_SECURE_LD_EXISTS,
+ MFI_STAT_LD_SECURE_NOT_ALLOWED,
+ MFI_STAT_REPROVISION_NOT_ALLOWED,
+ MFI_STAT_PD_SECURITY_TYPE_WRONG,
+ MFI_STAT_LD_ENCRYPTION_TYPE_INVALID,
+ MFI_STAT_CONFIG_FDE_NON_FDE_MIX_NOT_ALLOWED = 0x50,
+ MFI_STAT_CONFIG_LD_ENCRYPTION_TYPE_MIX_NOT_ALLOWED,
+ MFI_STAT_SECRET_KEY_NOT_ALLOWED,
+ MFI_STAT_PD_HW_ERRORS_DETECTED,
+ MFI_STAT_LD_CACHE_PINNED,
+ MFI_STAT_POWER_STATE_SET_IN_PROGRESS,
+ MFI_STAT_POWER_STATE_SET_BUSY,
+ MFI_STAT_POWER_STATE_WRONG,
+ MFI_STAT_PR_NO_AVAILABLE_PD_FOUND,
+ MFI_STAT_CTRL_RESET_REQUIRED,
+ MFI_STAT_LOCK_KEY_EKM_NO_BOOT_AGENT,
+ MFI_STAT_SNAP_NO_SPACE,
+ MFI_STAT_SNAP_PARTIAL_FAILURE,
+ MFI_STAT_UPGRADE_KEY_INCOMPATIBLE,
+ MFI_STAT_PFK_INCOMPATIBLE,
+ MFI_STAT_PD_MAX_UNCONFIGURED,
+ MFI_STAT_IO_METRICS_DISABLED = 0x60,
+ MFI_STAT_AEC_NOT_STOPPED,
+ MFI_STAT_PI_TYPE_WRONG,
+ MFI_STAT_LD_PD_PI_INCOMPATIBLE,
+ MFI_STAT_PI_NOT_ENABLED,
+ MFI_STAT_LD_BLOCK_SIZE_MISMATCH,
+ MFI_STAT_INVALID_STATUS = 0xFF
+} mfi_status_t;
+
+/* Event classes */
+typedef enum {
+ MFI_EVT_CLASS_DEBUG = -2,
+ MFI_EVT_CLASS_PROGRESS = -1,
+ MFI_EVT_CLASS_INFO = 0,
+ MFI_EVT_CLASS_WARNING = 1,
+ MFI_EVT_CLASS_CRITICAL = 2,
+ MFI_EVT_CLASS_FATAL = 3,
+ MFI_EVT_CLASS_DEAD = 4
+} mfi_evt_class_t;
+
+/* Event locales */
+typedef enum {
+ MFI_EVT_LOCALE_LD = 0x0001,
+ MFI_EVT_LOCALE_PD = 0x0002,
+ MFI_EVT_LOCALE_ENCL = 0x0004,
+ MFI_EVT_LOCALE_BBU = 0x0008,
+ MFI_EVT_LOCALE_SAS = 0x0010,
+ MFI_EVT_LOCALE_CTRL = 0x0020,
+ MFI_EVT_LOCALE_CONFIG = 0x0040,
+ MFI_EVT_LOCALE_CLUSTER = 0x0080,
+ MFI_EVT_LOCALE_ALL = 0xffff
+} mfi_evt_locale_t;
+
+/* Event args */
+typedef enum {
+ MR_EVT_ARGS_NONE = 0x00,
+ MR_EVT_ARGS_CDB_SENSE,
+ MR_EVT_ARGS_LD,
+ MR_EVT_ARGS_LD_COUNT,
+ MR_EVT_ARGS_LD_LBA,
+ MR_EVT_ARGS_LD_OWNER,
+ MR_EVT_ARGS_LD_LBA_PD_LBA,
+ MR_EVT_ARGS_LD_PROG,
+ MR_EVT_ARGS_LD_STATE,
+ MR_EVT_ARGS_LD_STRIP,
+ MR_EVT_ARGS_PD,
+ MR_EVT_ARGS_PD_ERR,
+ MR_EVT_ARGS_PD_LBA,
+ MR_EVT_ARGS_PD_LBA_LD,
+ MR_EVT_ARGS_PD_PROG,
+ MR_EVT_ARGS_PD_STATE,
+ MR_EVT_ARGS_PCI,
+ MR_EVT_ARGS_RATE,
+ MR_EVT_ARGS_STR,
+ MR_EVT_ARGS_TIME,
+ MR_EVT_ARGS_ECC,
+ MR_EVT_ARGS_LD_PROP,
+ MR_EVT_ARGS_PD_SPARE,
+ MR_EVT_ARGS_PD_INDEX,
+ MR_EVT_ARGS_DIAG_PASS,
+ MR_EVT_ARGS_DIAG_FAIL,
+ MR_EVT_ARGS_PD_LBA_LBA,
+ MR_EVT_ARGS_PORT_PHY,
+ MR_EVT_ARGS_PD_MISSING,
+ MR_EVT_ARGS_PD_ADDRESS,
+ MR_EVT_ARGS_BITMAP,
+ MR_EVT_ARGS_CONNECTOR,
+ MR_EVT_ARGS_PD_PD,
+ MR_EVT_ARGS_PD_FRU,
+ MR_EVT_ARGS_PD_PATHINFO,
+ MR_EVT_ARGS_PD_POWER_STATE,
+ MR_EVT_ARGS_GENERIC,
+} mfi_evt_args;
+
+/* Event codes */
+#define MR_EVT_CFG_CLEARED 0x0004
+#define MR_EVT_CTRL_SHUTDOWN 0x002a
+#define MR_EVT_LD_STATE_CHANGE 0x0051
+#define MR_EVT_PD_INSERTED 0x005b
+#define MR_EVT_PD_REMOVED 0x0070
+#define MR_EVT_PD_STATE_CHANGED 0x0072
+#define MR_EVT_LD_CREATED 0x008a
+#define MR_EVT_LD_DELETED 0x008b
+#define MR_EVT_FOREIGN_CFG_IMPORTED 0x00db
+#define MR_EVT_LD_OFFLINE 0x00fc
+#define MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED 0x0152
+
+typedef enum {
+ MR_LD_CACHE_WRITE_BACK = 0x01,
+ MR_LD_CACHE_WRITE_ADAPTIVE = 0x02,
+ MR_LD_CACHE_READ_AHEAD = 0x04,
+ MR_LD_CACHE_READ_ADAPTIVE = 0x08,
+ MR_LD_CACHE_WRITE_CACHE_BAD_BBU = 0x10,
+ MR_LD_CACHE_ALLOW_WRITE_CACHE = 0x20,
+ MR_LD_CACHE_ALLOW_READ_CACHE = 0x40
+} mfi_ld_cache;
+
+typedef enum {
+ MR_PD_CACHE_UNCHANGED = 0,
+ MR_PD_CACHE_ENABLE = 1,
+ MR_PD_CACHE_DISABLE = 2
+} mfi_pd_cache;
+
+typedef enum {
+ MR_PD_QUERY_TYPE_ALL = 0,
+ MR_PD_QUERY_TYPE_STATE = 1,
+ MR_PD_QUERY_TYPE_POWER_STATE = 2,
+ MR_PD_QUERY_TYPE_MEDIA_TYPE = 3,
+ MR_PD_QUERY_TYPE_SPEED = 4,
+ MR_PD_QUERY_TYPE_EXPOSED_TO_HOST = 5, /*query for system drives */
+} mfi_pd_query_type;
+
+/*
+ * Other propertities and definitions
+ */
+#define MFI_MAX_PD_CHANNELS 2
+#define MFI_MAX_LD_CHANNELS 2
+#define MFI_MAX_CHANNELS (MFI_MAX_PD_CHANNELS + MFI_MAX_LD_CHANNELS)
+#define MFI_MAX_CHANNEL_DEVS 128
+#define MFI_DEFAULT_ID -1
+#define MFI_MAX_LUN 8
+#define MFI_MAX_LD 64
+
+#define MFI_FRAME_SIZE 64
+#define MFI_MBOX_SIZE 12
+
+/* Firmware flashing can take 40s */
+#define MFI_POLL_TIMEOUT_SECS 50
+
+/* Allow for speedier math calculations */
+#define MFI_SECTOR_LEN 512
+
+/* Scatter Gather elements */
+struct mfi_sg32 {
+ uint32_t addr;
+ uint32_t len;
+} __attribute__ ((packed));
+
+struct mfi_sg64 {
+ uint64_t addr;
+ uint32_t len;
+} __attribute__ ((packed));
+
+struct mfi_sg_skinny {
+ uint64_t addr;
+ uint32_t len;
+ uint32_t flag;
+} __attribute__ ((packed));
+
+union mfi_sgl {
+ struct mfi_sg32 sg32[1];
+ struct mfi_sg64 sg64[1];
+ struct mfi_sg_skinny sg_skinny[1];
+} __attribute__ ((packed));
+
+/* Message frames. All messages have a common header */
+struct mfi_frame_header {
+ uint8_t frame_cmd;
+ uint8_t sense_len;
+ uint8_t cmd_status;
+ uint8_t scsi_status;
+ uint8_t target_id;
+ uint8_t lun_id;
+ uint8_t cdb_len;
+ uint8_t sge_count;
+ uint64_t context;
+ uint16_t flags;
+ uint16_t timeout;
+ uint32_t data_len;
+} __attribute__ ((packed));
+
+struct mfi_init_frame {
+ struct mfi_frame_header header;
+ uint32_t qinfo_new_addr_lo;
+ uint32_t qinfo_new_addr_hi;
+ uint32_t qinfo_old_addr_lo;
+ uint32_t qinfo_old_addr_hi;
+ uint32_t reserved[6];
+};
+
+#define MFI_IO_FRAME_SIZE 40
+struct mfi_io_frame {
+ struct mfi_frame_header header;
+ uint32_t sense_addr_lo;
+ uint32_t sense_addr_hi;
+ uint32_t lba_lo;
+ uint32_t lba_hi;
+ union mfi_sgl sgl;
+} __attribute__ ((packed));
+
+#define MFI_PASS_FRAME_SIZE 48
+struct mfi_pass_frame {
+ struct mfi_frame_header header;
+ uint32_t sense_addr_lo;
+ uint32_t sense_addr_hi;
+ uint8_t cdb[16];
+ union mfi_sgl sgl;
+} __attribute__ ((packed));
+
+#define MFI_DCMD_FRAME_SIZE 40
+struct mfi_dcmd_frame {
+ struct mfi_frame_header header;
+ uint32_t opcode;
+ uint8_t mbox[MFI_MBOX_SIZE];
+ union mfi_sgl sgl;
+} __attribute__ ((packed));
+
+struct mfi_abort_frame {
+ struct mfi_frame_header header;
+ uint64_t abort_context;
+ uint32_t abort_mfi_addr_lo;
+ uint32_t abort_mfi_addr_hi;
+ uint32_t reserved1[6];
+} __attribute__ ((packed));
+
+struct mfi_smp_frame {
+ struct mfi_frame_header header;
+ uint64_t sas_addr;
+ union {
+ struct mfi_sg32 sg32[2];
+ struct mfi_sg64 sg64[2];
+ } sgl;
+} __attribute__ ((packed));
+
+struct mfi_stp_frame {
+ struct mfi_frame_header header;
+ uint16_t fis[10];
+ uint32_t stp_flags;
+ union {
+ struct mfi_sg32 sg32[2];
+ struct mfi_sg64 sg64[2];
+ } sgl;
+} __attribute__ ((packed));
+
+union mfi_frame {
+ struct mfi_frame_header header;
+ struct mfi_init_frame init;
+ struct mfi_io_frame io;
+ struct mfi_pass_frame pass;
+ struct mfi_dcmd_frame dcmd;
+ struct mfi_abort_frame abort;
+ struct mfi_smp_frame smp;
+ struct mfi_stp_frame stp;
+ uint64_t raw[8];
+ uint8_t bytes[MFI_FRAME_SIZE];
+};
+
+#define MFI_SENSE_LEN 128
+struct mfi_sense {
+ uint8_t data[MFI_SENSE_LEN];
+};
+
+#define MFI_QUEUE_FLAG_CONTEXT64 0x00000002
+
+/* The queue init structure that is passed with the init message */
+struct mfi_init_qinfo {
+ uint32_t flags;
+ uint32_t rq_entries;
+ uint32_t rq_addr_lo;
+ uint32_t rq_addr_hi;
+ uint32_t pi_addr_lo;
+ uint32_t pi_addr_hi;
+ uint32_t ci_addr_lo;
+ uint32_t ci_addr_hi;
+} __attribute__ ((packed));
+
+/* Controller properties */
+struct mfi_ctrl_props {
+ uint16_t seq_num;
+ uint16_t pred_fail_poll_interval;
+ uint16_t intr_throttle_cnt;
+ uint16_t intr_throttle_timeout;
+ uint8_t rebuild_rate;
+ uint8_t patrol_read_rate;
+ uint8_t bgi_rate;
+ uint8_t cc_rate;
+ uint8_t recon_rate;
+ uint8_t cache_flush_interval;
+ uint8_t spinup_drv_cnt;
+ uint8_t spinup_delay;
+ uint8_t cluster_enable;
+ uint8_t coercion_mode;
+ uint8_t alarm_enable;
+ uint8_t disable_auto_rebuild;
+ uint8_t disable_battery_warn;
+ uint8_t ecc_bucket_size;
+ uint16_t ecc_bucket_leak_rate;
+ uint8_t restore_hotspare_on_insertion;
+ uint8_t expose_encl_devices;
+ uint8_t maintainPdFailHistory;
+ uint8_t disallowHostRequestReordering;
+ uint8_t abortCCOnError;
+ uint8_t loadBalanceMode;
+ uint8_t disableAutoDetectBackplane;
+ uint8_t snapVDSpace;
+ uint32_t OnOffProperties;
+/* set TRUE to disable copyBack (0=copyback enabled) */
+#define MFI_CTRL_PROP_CopyBackDisabled (1 << 0)
+#define MFI_CTRL_PROP_SMARTerEnabled (1 << 1)
+#define MFI_CTRL_PROP_PRCorrectUnconfiguredAreas (1 << 2)
+#define MFI_CTRL_PROP_UseFdeOnly (1 << 3)
+#define MFI_CTRL_PROP_DisableNCQ (1 << 4)
+#define MFI_CTRL_PROP_SSDSMARTerEnabled (1 << 5)
+#define MFI_CTRL_PROP_SSDPatrolReadEnabled (1 << 6)
+#define MFI_CTRL_PROP_EnableSpinDownUnconfigured (1 << 7)
+#define MFI_CTRL_PROP_AutoEnhancedImport (1 << 8)
+#define MFI_CTRL_PROP_EnableSecretKeyControl (1 << 9)
+#define MFI_CTRL_PROP_DisableOnlineCtrlReset (1 << 10)
+#define MFI_CTRL_PROP_AllowBootWithPinnedCache (1 << 11)
+#define MFI_CTRL_PROP_DisableSpinDownHS (1 << 12)
+#define MFI_CTRL_PROP_EnableJBOD (1 << 13)
+
+ uint8_t autoSnapVDSpace; /* % of source LD to be
+ * reserved for auto snapshot
+ * in snapshot repository, for
+ * metadata and user data
+ * 1=5%, 2=10%, 3=15% and so on
+ */
+ uint8_t viewSpace; /* snapshot writeable VIEWs
+ * capacity as a % of source LD
+ * capacity. 0=READ only
+ * 1=5%, 2=10%, 3=15% and so on
+ */
+ uint16_t spinDownTime; /* # of idle minutes before device
+ * is spun down (0=use FW defaults)
+ */
+ uint8_t reserved[24];
+} __attribute__ ((packed));
+
+/* PCI information about the card. */
+struct mfi_info_pci {
+ uint16_t vendor;
+ uint16_t device;
+ uint16_t subvendor;
+ uint16_t subdevice;
+ uint8_t reserved[24];
+} __attribute__ ((packed));
+
+/* Host (front end) interface information */
+struct mfi_info_host {
+ uint8_t type;
+#define MFI_INFO_HOST_PCIX 0x01
+#define MFI_INFO_HOST_PCIE 0x02
+#define MFI_INFO_HOST_ISCSI 0x04
+#define MFI_INFO_HOST_SAS3G 0x08
+ uint8_t reserved[6];
+ uint8_t port_count;
+ uint64_t port_addr[8];
+} __attribute__ ((packed));
+
+/* Device (back end) interface information */
+struct mfi_info_device {
+ uint8_t type;
+#define MFI_INFO_DEV_SPI 0x01
+#define MFI_INFO_DEV_SAS3G 0x02
+#define MFI_INFO_DEV_SATA1 0x04
+#define MFI_INFO_DEV_SATA3G 0x08
+ uint8_t reserved[6];
+ uint8_t port_count;
+ uint64_t port_addr[8];
+} __attribute__ ((packed));
+
+/* Firmware component information */
+struct mfi_info_component {
+ char name[8];
+ char version[32];
+ char build_date[16];
+ char build_time[16];
+} __attribute__ ((packed));
+
+/* Controller default settings */
+struct mfi_defaults {
+ uint64_t sas_addr;
+ uint8_t phy_polarity;
+ uint8_t background_rate;
+ uint8_t stripe_size;
+ uint8_t flush_time;
+ uint8_t write_back;
+ uint8_t read_ahead;
+ uint8_t cache_when_bbu_bad;
+ uint8_t cached_io;
+ uint8_t smart_mode;
+ uint8_t alarm_disable;
+ uint8_t coercion;
+ uint8_t zrc_config;
+ uint8_t dirty_led_shows_drive_activity;
+ uint8_t bios_continue_on_error;
+ uint8_t spindown_mode;
+ uint8_t allowed_device_types;
+ uint8_t allow_mix_in_enclosure;
+ uint8_t allow_mix_in_ld;
+ uint8_t allow_sata_in_cluster;
+ uint8_t max_chained_enclosures;
+ uint8_t disable_ctrl_r;
+ uint8_t enable_web_bios;
+ uint8_t phy_polarity_split;
+ uint8_t direct_pd_mapping;
+ uint8_t bios_enumerate_lds;
+ uint8_t restored_hot_spare_on_insertion;
+ uint8_t expose_enclosure_devices;
+ uint8_t maintain_pd_fail_history;
+ uint8_t disable_puncture;
+ uint8_t zero_based_enumeration;
+ uint8_t disable_preboot_cli;
+ uint8_t show_drive_led_on_activity;
+ uint8_t cluster_disable;
+ uint8_t sas_disable;
+ uint8_t auto_detect_backplane;
+ uint8_t fde_only;
+ uint8_t delay_during_post;
+ uint8_t resv[19];
+} __attribute__ ((packed));
+
+/* Controller default settings */
+struct mfi_bios_data {
+ uint16_t boot_target_id;
+ uint8_t do_not_int_13;
+ uint8_t continue_on_error;
+ uint8_t verbose;
+ uint8_t geometry;
+ uint8_t expose_all_drives;
+ uint8_t reserved[56];
+ uint8_t check_sum;
+} __attribute__ ((packed));
+
+/* SAS (?) controller info, returned from MFI_DCMD_CTRL_GETINFO. */
+struct mfi_ctrl_info {
+ struct mfi_info_pci pci;
+ struct mfi_info_host host;
+ struct mfi_info_device device;
+
+ /* Firmware components that are present and active. */
+ uint32_t image_check_word;
+ uint32_t image_component_count;
+ struct mfi_info_component image_component[8];
+
+ /* Firmware components that have been flashed but are inactive */
+ uint32_t pending_image_component_count;
+ struct mfi_info_component pending_image_component[8];
+
+ uint8_t max_arms;
+ uint8_t max_spans;
+ uint8_t max_arrays;
+ uint8_t max_lds;
+ char product_name[80];
+ char serial_number[32];
+ uint32_t hw_present;
+#define MFI_INFO_HW_BBU 0x01
+#define MFI_INFO_HW_ALARM 0x02
+#define MFI_INFO_HW_NVRAM 0x04
+#define MFI_INFO_HW_UART 0x08
+#define MFI_INFO_HW_MEM 0x10
+#define MFI_INFO_HW_FLASH 0x20
+ uint32_t current_fw_time;
+ uint16_t max_cmds;
+ uint16_t max_sg_elements;
+ uint32_t max_request_size;
+ uint16_t lds_present;
+ uint16_t lds_degraded;
+ uint16_t lds_offline;
+ uint16_t pd_present;
+ uint16_t pd_disks_present;
+ uint16_t pd_disks_pred_failure;
+ uint16_t pd_disks_failed;
+ uint16_t nvram_size;
+ uint16_t memory_size;
+ uint16_t flash_size;
+ uint16_t ram_correctable_errors;
+ uint16_t ram_uncorrectable_errors;
+ uint8_t cluster_allowed;
+ uint8_t cluster_active;
+ uint16_t max_strips_per_io;
+
+ uint32_t raid_levels;
+#define MFI_INFO_RAID_0 0x01
+#define MFI_INFO_RAID_1 0x02
+#define MFI_INFO_RAID_5 0x04
+#define MFI_INFO_RAID_1E 0x08
+#define MFI_INFO_RAID_6 0x10
+
+ uint32_t adapter_ops;
+#define MFI_INFO_AOPS_RBLD_RATE 0x0001
+#define MFI_INFO_AOPS_CC_RATE 0x0002
+#define MFI_INFO_AOPS_BGI_RATE 0x0004
+#define MFI_INFO_AOPS_RECON_RATE 0x0008
+#define MFI_INFO_AOPS_PATROL_RATE 0x0010
+#define MFI_INFO_AOPS_ALARM_CONTROL 0x0020
+#define MFI_INFO_AOPS_CLUSTER_SUPPORTED 0x0040
+#define MFI_INFO_AOPS_BBU 0x0080
+#define MFI_INFO_AOPS_SPANNING_ALLOWED 0x0100
+#define MFI_INFO_AOPS_DEDICATED_SPARES 0x0200
+#define MFI_INFO_AOPS_REVERTIBLE_SPARES 0x0400
+#define MFI_INFO_AOPS_FOREIGN_IMPORT 0x0800
+#define MFI_INFO_AOPS_SELF_DIAGNOSTIC 0x1000
+#define MFI_INFO_AOPS_MIXED_ARRAY 0x2000
+#define MFI_INFO_AOPS_GLOBAL_SPARES 0x4000
+
+ uint32_t ld_ops;
+#define MFI_INFO_LDOPS_READ_POLICY 0x01
+#define MFI_INFO_LDOPS_WRITE_POLICY 0x02
+#define MFI_INFO_LDOPS_IO_POLICY 0x04
+#define MFI_INFO_LDOPS_ACCESS_POLICY 0x08
+#define MFI_INFO_LDOPS_DISK_CACHE_POLICY 0x10
+
+ struct {
+ uint8_t min;
+ uint8_t max;
+ uint8_t reserved[2];
+ } __attribute__ ((packed)) stripe_sz_ops;
+
+ uint32_t pd_ops;
+#define MFI_INFO_PDOPS_FORCE_ONLINE 0x01
+#define MFI_INFO_PDOPS_FORCE_OFFLINE 0x02
+#define MFI_INFO_PDOPS_FORCE_REBUILD 0x04
+
+ uint32_t pd_mix_support;
+#define MFI_INFO_PDMIX_SAS 0x01
+#define MFI_INFO_PDMIX_SATA 0x02
+#define MFI_INFO_PDMIX_ENCL 0x04
+#define MFI_INFO_PDMIX_LD 0x08
+#define MFI_INFO_PDMIX_SATA_CLUSTER 0x10
+
+ uint8_t ecc_bucket_count;
+ uint8_t reserved2[11];
+ struct mfi_ctrl_props properties;
+ char package_version[0x60];
+ uint8_t pad[0x800 - 0x6a0];
+} __attribute__ ((packed));
+
+/* keep track of an event. */
+union mfi_evt {
+ struct {
+ uint16_t locale;
+ uint8_t reserved;
+ int8_t class;
+ } members;
+ uint32_t word;
+} __attribute__ ((packed));
+
+/* event log state. */
+struct mfi_evt_log_state {
+ uint32_t newest_seq_num;
+ uint32_t oldest_seq_num;
+ uint32_t clear_seq_num;
+ uint32_t shutdown_seq_num;
+ uint32_t boot_seq_num;
+} __attribute__ ((packed));
+
+struct mfi_progress {
+ uint16_t progress;
+ uint16_t elapsed_seconds;
+} __attribute__ ((packed));
+
+struct mfi_evt_ld {
+ uint16_t target_id;
+ uint8_t ld_index;
+ uint8_t reserved;
+} __attribute__ ((packed));
+
+struct mfi_evt_pd {
+ uint16_t device_id;
+ uint8_t enclosure_index;
+ uint8_t slot_number;
+} __attribute__ ((packed));
+
+/* event detail, returned from MFI_DCMD_CTRL_EVENT_WAIT. */
+struct mfi_evt_detail {
+ uint32_t seq;
+ uint32_t time;
+ uint32_t code;
+ union mfi_evt class;
+ uint8_t arg_type;
+ uint8_t reserved1[15];
+
+ union {
+ struct {
+ struct mfi_evt_pd pd;
+ uint8_t cdb_len;
+ uint8_t sense_len;
+ uint8_t reserved[2];
+ uint8_t cdb[16];
+ uint8_t sense[64];
+ } cdb_sense;
+
+ struct mfi_evt_ld ld;
+
+ struct {
+ struct mfi_evt_ld ld;
+ uint64_t count;
+ } ld_count;
+
+ struct {
+ uint64_t lba;
+ struct mfi_evt_ld ld;
+ } ld_lba;
+
+ struct {
+ struct mfi_evt_ld ld;
+ uint32_t pre_owner;
+ uint32_t new_owner;
+ } ld_owner;
+
+ struct {
+ uint64_t ld_lba;
+ uint64_t pd_lba;
+ struct mfi_evt_ld ld;
+ struct mfi_evt_pd pd;
+ } ld_lba_pd_lba;
+
+ struct {
+ struct mfi_evt_ld ld;
+ struct mfi_progress prog;
+ } ld_prog;
+
+ struct {
+ struct mfi_evt_ld ld;
+ uint32_t prev_state;
+ uint32_t new_state;
+ } ld_state;
+
+ struct {
+ uint64_t strip;
+ struct mfi_evt_ld ld;
+ } ld_strip;
+
+ struct mfi_evt_pd pd;
+
+ struct {
+ struct mfi_evt_pd pd;
+ uint32_t err;
+ } pd_err;
+
+ struct {
+ uint64_t lba;
+ struct mfi_evt_pd pd;
+ } pd_lba;
+
+ struct {
+ uint64_t lba;
+ struct mfi_evt_pd pd;
+ struct mfi_evt_ld ld;
+ } pd_lba_ld;
+
+ struct {
+ struct mfi_evt_pd pd;
+ struct mfi_progress prog;
+ } pd_prog;
+
+ struct {
+ struct mfi_evt_pd ld;
+ uint32_t prev_state;
+ uint32_t new_state;
+ } pd_state;
+
+ struct {
+ uint16_t venderId;
+ uint16_t deviceId;
+ uint16_t subVenderId;
+ uint16_t subDeviceId;
+ } pci;
+
+ uint32_t rate;
+
+ char str[96];
+
+ struct {
+ uint32_t rtc;
+ uint16_t elapsedSeconds;
+ } time;
+
+ struct {
+ uint32_t ecar;
+ uint32_t elog;
+ char str[64];
+ } ecc;
+
+ uint8_t b[96];
+ uint16_t s[48];
+ uint32_t w[24];
+ uint64_t d[12];
+ } args;
+
+ char description[128];
+} __attribute__ ((packed));
+
+struct mfi_evt_list {
+ uint32_t count;
+ uint32_t reserved;
+ struct mfi_evt_detail event[1];
+} __attribute__ ((packed));
+
+union mfi_pd_ref {
+ struct {
+ uint16_t device_id;
+ uint16_t seq_num;
+ } v;
+ uint32_t ref;
+} __attribute__ ((packed));
+
+union mfi_pd_ddf_type {
+ struct {
+ uint16_t pd_type;
+#define MFI_PD_DDF_TYPE_FORCED_PD_GUID (1 << 0)
+#define MFI_PD_DDF_TYPE_IN_VD (1 << 1)
+#define MFI_PD_DDF_TYPE_IS_GLOBAL_SPARE (1 << 2)
+#define MFI_PD_DDF_TYPE_IS_SPARE (1 << 3)
+#define MFI_PD_DDF_TYPE_IS_FOREIGN (1 << 4)
+#define MFI_PD_DDF_TYPE_INTF_SPI (1 << 12)
+#define MFI_PD_DDF_TYPE_INTF_SAS (1 << 13)
+#define MFI_PD_DDF_TYPE_INTF_SATA1 (1 << 14)
+#define MFI_PD_DDF_TYPE_INTF_SATA3G (1 << 15)
+ uint16_t reserved;
+ } ddf;
+ struct {
+ uint32_t reserved;
+ } non_disk;
+ uint32_t type;
+} __attribute__ ((packed));
+
+struct mfi_pd_progress {
+ uint32_t active;
+#define PD_PROGRESS_ACTIVE_REBUILD (1 << 0)
+#define PD_PROGRESS_ACTIVE_PATROL (1 << 1)
+#define PD_PROGRESS_ACTIVE_CLEAR (1 << 2)
+ struct mfi_progress rbld;
+ struct mfi_progress patrol;
+ struct mfi_progress clear;
+ struct mfi_progress reserved[4];
+} __attribute__ ((packed));
+
+struct mfi_pd_info {
+ union mfi_pd_ref ref;
+ uint8_t inquiry_data[96];
+ uint8_t vpd_page83[64];
+ uint8_t not_supported;
+ uint8_t scsi_dev_type;
+ uint8_t connected_port_bitmap;
+ uint8_t device_speed;
+ uint32_t media_err_count;
+ uint32_t other_err_count;
+ uint32_t pred_fail_count;
+ uint32_t last_pred_fail_event_seq_num;
+ uint16_t fw_state;
+ uint8_t disable_for_removal;
+ uint8_t link_speed;
+ union mfi_pd_ddf_type state;
+ struct {
+ uint8_t count;
+ uint8_t is_path_broken;
+ uint8_t reserved[6];
+ uint64_t sas_addr[4];
+ } path_info;
+ uint64_t raw_size;
+ uint64_t non_coerced_size;
+ uint64_t coerced_size;
+ uint16_t encl_device_id;
+ uint8_t encl_index;
+ uint8_t slot_number;
+ struct mfi_pd_progress prog_info;
+ uint8_t bad_block_table_full;
+ uint8_t unusable_in_current_config;
+ uint8_t vpd_page83_ext[64];
+ uint8_t reserved[512-358];
+} __attribute__ ((packed));
+
+struct mfi_pd_address {
+ uint16_t device_id;
+ uint16_t encl_device_id;
+ uint8_t encl_index;
+ uint8_t slot_number;
+ uint8_t scsi_dev_type;
+ uint8_t connect_port_bitmap;
+ uint64_t sas_addr[2];
+} __attribute__ ((packed));
+
+#define MFI_MAX_SYS_PDS 240
+struct mfi_pd_list {
+ uint32_t size;
+ uint32_t count;
+ struct mfi_pd_address addr[MFI_MAX_SYS_PDS];
+} __attribute__ ((packed));
+
+union mfi_ld_ref {
+ struct {
+ uint8_t target_id;
+ uint8_t reserved;
+ uint16_t seq;
+ } v;
+ uint32_t ref;
+} __attribute__ ((packed));
+
+struct mfi_ld_list {
+ uint32_t ld_count;
+ uint32_t reserved1;
+ struct {
+ union mfi_ld_ref ld;
+ uint8_t state;
+ uint8_t reserved2[3];
+ uint64_t size;
+ } ld_list[MFI_MAX_LD];
+} __attribute__ ((packed));
+
+enum mfi_ld_access {
+ MFI_LD_ACCESS_RW = 0,
+ MFI_LD_ACCSSS_RO = 2,
+ MFI_LD_ACCESS_BLOCKED = 3,
+};
+#define MFI_LD_ACCESS_MASK 3
+
+enum mfi_ld_state {
+ MFI_LD_STATE_OFFLINE = 0,
+ MFI_LD_STATE_PARTIALLY_DEGRADED = 1,
+ MFI_LD_STATE_DEGRADED = 2,
+ MFI_LD_STATE_OPTIMAL = 3
+};
+
+enum mfi_syspd_state {
+ MFI_PD_STATE_UNCONFIGURED_GOOD = 0x00,
+ MFI_PD_STATE_UNCONFIGURED_BAD = 0x01,
+ MFI_PD_STATE_HOT_SPARE = 0x02,
+ MFI_PD_STATE_OFFLINE = 0x10,
+ MFI_PD_STATE_FAILED = 0x11,
+ MFI_PD_STATE_REBUILD = 0x14,
+ MFI_PD_STATE_ONLINE = 0x18,
+ MFI_PD_STATE_COPYBACK = 0x20,
+ MFI_PD_STATE_SYSTEM = 0x40
+};
+
+struct mfi_ld_props {
+ union mfi_ld_ref ld;
+ char name[16];
+ uint8_t default_cache_policy;
+ uint8_t access_policy;
+ uint8_t disk_cache_policy;
+ uint8_t current_cache_policy;
+ uint8_t no_bgi;
+ uint8_t reserved[7];
+} __attribute__ ((packed));
+
+struct mfi_ld_params {
+ uint8_t primary_raid_level;
+ uint8_t raid_level_qualifier;
+ uint8_t secondary_raid_level;
+ uint8_t stripe_size;
+ uint8_t num_drives;
+ uint8_t span_depth;
+ uint8_t state;
+ uint8_t init_state;
+ uint8_t is_consistent;
+ uint8_t reserved[23];
+} __attribute__ ((packed));
+
+struct mfi_ld_progress {
+ uint32_t active;
+#define MFI_LD_PROGRESS_CC (1<<0)
+#define MFI_LD_PROGRESS_BGI (1<<1)
+#define MFI_LD_PROGRESS_FGI (1<<2)
+#define MFI_LD_PORGRESS_RECON (1<<3)
+ struct mfi_progress cc;
+ struct mfi_progress bgi;
+ struct mfi_progress fgi;
+ struct mfi_progress recon;
+ struct mfi_progress reserved[4];
+} __attribute__ ((packed));
+
+struct mfi_span {
+ uint64_t start_block;
+ uint64_t num_blocks;
+ uint16_t array_ref;
+ uint8_t reserved[6];
+} __attribute__ ((packed));
+
+#define MFI_MAX_SPAN_DEPTH 8
+struct mfi_ld_config {
+ struct mfi_ld_props properties;
+ struct mfi_ld_params params;
+ struct mfi_span span[MFI_MAX_SPAN_DEPTH];
+} __attribute__ ((packed));
+
+struct mfi_ld_info {
+ struct mfi_ld_config ld_config;
+ uint64_t size;
+ struct mfi_ld_progress progress;
+ uint16_t cluster_owner;
+ uint8_t reconstruct_active;
+ uint8_t reserved1[1];
+ uint8_t vpd_page83[64];
+ uint8_t reserved2[16];
+} __attribute__ ((packed));
+
+union mfi_spare_type {
+ uint8_t flags;
+#define MFI_SPARE_IS_DEDICATED (1 << 0)
+#define MFI_SPARE_IS_REVERTABLE (1 << 1)
+#define MFI_SPARE_IS_ENCL_AFFINITY (1 << 2)
+ uint8_t type;
+} __attribute__ ((packed));
+
+#define MFI_MAX_ARRAYS 16
+struct mfi_spare {
+ union mfi_pd_ref ref;
+ union mfi_spare_type spare_type;
+ uint8_t reserved[2];
+ uint8_t array_count;
+ uint16_t array_refd[MFI_MAX_ARRAYS];
+} __attribute__ ((packed));
+
+#define MFI_MAX_ROW_SIZE 32
+struct mfi_array {
+ uint64_t size;
+ uint8_t num_drives;
+ uint8_t reserved;
+ uint16_t array_ref;
+ uint8_t pad[20];
+ struct {
+ union mfi_pd_ref ref;
+ uint16_t fw_state; /* enum mfi_syspd_state */
+ struct {
+ uint8_t pd;
+ uint8_t slot;
+ } encl;
+ } pd[MFI_MAX_ROW_SIZE];
+} __attribute__ ((packed));
+
+struct mfi_config_data {
+ uint32_t size;
+ uint16_t array_count;
+ uint16_t array_size;
+ uint16_t log_drv_count;
+ uint16_t log_drv_size;
+ uint16_t spares_count;
+ uint16_t spares_size;
+ uint8_t reserved[16];
+ /*
+ struct mfi_array array[];
+ struct mfi_ld_config ld[];
+ struct mfi_spare spare[];
+ */
+} __attribute__ ((packed));
+
+#define MFI_SCSI_MAX_TARGETS 128
+#define MFI_SCSI_MAX_LUNS 8
+#define MFI_SCSI_INITIATOR_ID 255
+#define MFI_SCSI_MAX_CMDS 8
+#define MFI_SCSI_MAX_CDB_LEN 16
+
+#endif /* MFI_REG_H */
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (6 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 07/14] megasas: Add header file Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-03 19:09 ` Blue Swirl
2012-07-02 9:41 ` [Qemu-devel] [PATCH 09/14] virtio-scsi: do not crash on adding buffers to the event queue Paolo Bonzini
` (6 subsequent siblings)
14 siblings, 1 reply; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Hannes Reinecke
From: Hannes Reinecke <hare@suse.de>
This patch adds an emulation for the LSI Megaraid SAS 8708EM2 HBA.
I've tested it to work with Linux, Windows Vista, and Windows7.
Signed-off-by: Hannes Reinecke <hare@suse.de>
[ Squashed tracing patch (no need to keep it separate) and trivial changes
from Andreas Faerber. Rebased over IOMMU and QBus changes. - Paolo ]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
default-configs/pci.mak | 1 +
hw/Makefile.objs | 1 +
hw/megasas.c | 2198 +++++++++++++++++++++++++++++++++++++++++++++++
hw/pci_ids.h | 2 +
trace-events | 79 ++
5 files changed, 2281 insertions(+)
create mode 100644 hw/megasas.c
diff --git a/default-configs/pci.mak b/default-configs/pci.mak
index 9d3e1db..4b49c00 100644
--- a/default-configs/pci.mak
+++ b/default-configs/pci.mak
@@ -10,6 +10,7 @@ CONFIG_EEPRO100_PCI=y
CONFIG_PCNET_PCI=y
CONFIG_PCNET_COMMON=y
CONFIG_LSI_SCSI_PCI=y
+CONFIG_MEGASAS_SCSI_PCI=y
CONFIG_RTL8139_PCI=y
CONFIG_E1000_PCI=y
CONFIG_IDE_CORE=y
diff --git a/hw/Makefile.objs b/hw/Makefile.objs
index 3d77259..9a350de 100644
--- a/hw/Makefile.objs
+++ b/hw/Makefile.objs
@@ -86,6 +86,7 @@ hw-obj-$(CONFIG_OPENCORES_ETH) += opencores_eth.o
# SCSI layer
hw-obj-$(CONFIG_LSI_SCSI_PCI) += lsi53c895a.o
+hw-obj-$(CONFIG_MEGASAS_SCSI_PCI) += megasas.o
hw-obj-$(CONFIG_ESP) += esp.o
hw-obj-y += sysbus.o isa-bus.o
diff --git a/hw/megasas.c b/hw/megasas.c
new file mode 100644
index 0000000..b48836f
--- /dev/null
+++ b/hw/megasas.c
@@ -0,0 +1,2198 @@
+/*
+ * QEMU MegaRAID SAS 8708EM2 Host Bus Adapter emulation
+ * Based on the linux driver code at drivers/scsi/megaraid
+ *
+ * Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hw.h"
+#include "pci.h"
+#include "dma.h"
+#include "msix.h"
+#include "iov.h"
+#include "scsi.h"
+#include "scsi-defs.h"
+#include "block_int.h"
+#include "trace.h"
+
+#include "mfi.h"
+
+#define MEGASAS_VERSION "1.70"
+#define MEGASAS_MAX_FRAMES 2048 /* Firmware limit at 65535 */
+#define MEGASAS_DEFAULT_FRAMES 1000 /* Windows requires this */
+#define MEGASAS_MAX_SGE 128 /* Firmware limit */
+#define MEGASAS_DEFAULT_SGE 80
+#define MEGASAS_MAX_SECTORS 0xFFFF /* No real limit */
+#define MEGASAS_MAX_ARRAYS 128
+
+#define MEGASAS_FLAG_USE_JBOD 0
+#define MEGASAS_MASK_USE_JBOD (1 << MEGASAS_FLAG_USE_JBOD)
+#define MEGASAS_FLAG_USE_MSIX 1
+#define MEGASAS_MASK_USE_MSIX (1 << MEGASAS_FLAG_USE_MSIX)
+#define MEGASAS_FLAG_USE_QUEUE64 2
+#define MEGASAS_MASK_USE_QUEUE64 (1 << MEGASAS_FLAG_USE_QUEUE64)
+
+const char *mfi_frame_desc[] = {
+ "MFI init", "LD Read", "LD Write", "LD SCSI", "PD SCSI",
+ "MFI Doorbell", "MFI Abort", "MFI SMP", "MFI Stop"};
+
+typedef struct MegasasCmd {
+ uint32_t index;
+ uint16_t flags;
+ uint16_t count;
+ uint64_t context;
+
+ target_phys_addr_t pa;
+ target_phys_addr_t pa_size;
+ union mfi_frame *frame;
+ SCSIRequest *req;
+ QEMUSGList qsg;
+ void *iov_buf;
+ size_t iov_size;
+ size_t iov_offset;
+ struct MegasasState *state;
+} MegasasCmd;
+
+typedef struct MegasasState {
+ PCIDevice dev;
+ MemoryRegion mmio_io;
+ MemoryRegion port_io;
+ MemoryRegion queue_io;
+ uint32_t frame_hi;
+
+ int fw_state;
+ uint32_t fw_sge;
+ uint32_t fw_cmds;
+ uint32_t flags;
+ int fw_luns;
+ int intr_mask;
+ int doorbell;
+ int busy;
+
+ MegasasCmd *event_cmd;
+ int event_locale;
+ int event_class;
+ int event_count;
+ int shutdown_event;
+ int boot_event;
+
+ uint64_t reply_queue_pa;
+ void *reply_queue;
+ int reply_queue_len;
+ int reply_queue_head;
+ int reply_queue_tail;
+ uint64_t consumer_pa;
+ uint64_t producer_pa;
+
+ MegasasCmd frames[MEGASAS_MAX_FRAMES];
+
+ SCSIBus bus;
+} MegasasState;
+
+#define MEGASAS_INTR_DISABLED_MASK 0xFFFFFFFF
+
+static bool megasas_intr_enabled(MegasasState *s)
+{
+ if ((s->intr_mask & MEGASAS_INTR_DISABLED_MASK) !=
+ MEGASAS_INTR_DISABLED_MASK) {
+ return true;
+ }
+ return false;
+}
+
+static bool megasas_use_queue64(MegasasState *s)
+{
+ return s->flags & MEGASAS_MASK_USE_QUEUE64;
+}
+
+static bool megasas_use_msix(MegasasState *s)
+{
+ return s->flags & MEGASAS_MASK_USE_MSIX;
+}
+
+static bool megasas_is_jbod(MegasasState *s)
+{
+ return s->flags & MEGASAS_MASK_USE_JBOD;
+}
+
+static void megasas_frame_set_cmd_status(unsigned long frame, uint8_t v)
+{
+ stb_phys(frame + offsetof(struct mfi_frame_header, cmd_status), v);
+}
+
+static void megasas_frame_set_scsi_status(unsigned long frame, uint8_t v)
+{
+ stb_phys(frame + offsetof(struct mfi_frame_header, scsi_status), v);
+}
+
+/*
+ * Context is considered opaque, but the HBA firmware is running
+ * in little endian mode. So convert it to little endian, too.
+ */
+static uint64_t megasas_frame_get_context(unsigned long frame)
+{
+ return ldq_le_phys(frame + offsetof(struct mfi_frame_header, context));
+}
+
+static bool megasas_frame_is_ieee_sgl(MegasasCmd *cmd)
+{
+ return cmd->flags & MFI_FRAME_IEEE_SGL;
+}
+
+static bool megasas_frame_is_sgl64(MegasasCmd *cmd)
+{
+ return cmd->flags & MFI_FRAME_SGL64;
+}
+
+static bool megasas_frame_is_sense64(MegasasCmd *cmd)
+{
+ return cmd->flags & MFI_FRAME_SENSE64;
+}
+
+static uint64_t megasas_sgl_get_addr(MegasasCmd *cmd,
+ union mfi_sgl *sgl)
+{
+ uint64_t addr;
+
+ if (megasas_frame_is_ieee_sgl(cmd)) {
+ addr = le64_to_cpu(sgl->sg_skinny->addr);
+ } else if (megasas_frame_is_sgl64(cmd)) {
+ addr = le64_to_cpu(sgl->sg64->addr);
+ } else {
+ addr = le32_to_cpu(sgl->sg32->addr);
+ }
+ return addr;
+}
+
+static uint32_t megasas_sgl_get_len(MegasasCmd *cmd,
+ union mfi_sgl *sgl)
+{
+ uint32_t len;
+
+ if (megasas_frame_is_ieee_sgl(cmd)) {
+ len = le32_to_cpu(sgl->sg_skinny->len);
+ } else if (megasas_frame_is_sgl64(cmd)) {
+ len = le32_to_cpu(sgl->sg64->len);
+ } else {
+ len = le32_to_cpu(sgl->sg32->len);
+ }
+ return len;
+}
+
+static union mfi_sgl *megasas_sgl_next(MegasasCmd *cmd,
+ union mfi_sgl *sgl)
+{
+ uint8_t *next = (uint8_t *)sgl;
+
+ if (megasas_frame_is_ieee_sgl(cmd)) {
+ next += sizeof(struct mfi_sg_skinny);
+ } else if (megasas_frame_is_sgl64(cmd)) {
+ next += sizeof(struct mfi_sg64);
+ } else {
+ next += sizeof(struct mfi_sg32);
+ }
+
+ if (next >= (uint8_t *)cmd->frame + cmd->pa_size) {
+ return NULL;
+ }
+ return (union mfi_sgl *)next;
+}
+
+static void megasas_soft_reset(MegasasState *s);
+
+static int megasas_map_sgl(MegasasState *s, MegasasCmd *cmd, union mfi_sgl *sgl)
+{
+ int i;
+ int iov_count = 0;
+ size_t iov_size = 0;
+
+ cmd->flags = le16_to_cpu(cmd->frame->header.flags);
+ iov_count = cmd->frame->header.sge_count;
+ if (iov_count > MEGASAS_MAX_SGE) {
+ trace_megasas_iovec_sgl_overflow(cmd->index, iov_count,
+ MEGASAS_MAX_SGE);
+ return iov_count;
+ }
+ qemu_sglist_init(&cmd->qsg, iov_count, pci_dma_context(&s->dev));
+ for (i = 0; i < iov_count; i++) {
+ dma_addr_t iov_pa, iov_size_p;
+
+ if (!sgl) {
+ trace_megasas_iovec_sgl_underflow(cmd->index, i);
+ goto unmap;
+ }
+ iov_pa = megasas_sgl_get_addr(cmd, sgl);
+ iov_size_p = megasas_sgl_get_len(cmd, sgl);
+ if (!iov_pa || !iov_size_p) {
+ trace_megasas_iovec_sgl_invalid(cmd->index, i,
+ iov_pa, iov_size_p);
+ goto unmap;
+ }
+ qemu_sglist_add(&cmd->qsg, iov_pa, iov_size_p);
+ sgl = megasas_sgl_next(cmd, sgl);
+ iov_size += (size_t)iov_size_p;
+ }
+ if (cmd->iov_size > iov_size) {
+ trace_megasas_iovec_overflow(cmd->index, iov_size, cmd->iov_size);
+ } else if (cmd->iov_size < iov_size) {
+ trace_megasas_iovec_underflow(cmd->iov_size, iov_size, cmd->iov_size);
+ }
+ cmd->iov_offset = 0;
+ return 0;
+unmap:
+ qemu_sglist_destroy(&cmd->qsg);
+ return iov_count - i;
+}
+
+static void megasas_unmap_sgl(MegasasCmd *cmd)
+{
+ qemu_sglist_destroy(&cmd->qsg);
+ cmd->iov_offset = 0;
+}
+
+/*
+ * passthrough sense and io sense are at the same offset
+ */
+static int megasas_build_sense(MegasasCmd *cmd, uint8_t *sense_ptr,
+ uint8_t sense_len)
+{
+ uint32_t pa_hi = 0, pa_lo;
+ target_phys_addr_t pa;
+
+ if (sense_len > cmd->frame->header.sense_len) {
+ sense_len = cmd->frame->header.sense_len;
+ }
+ if (sense_len) {
+ pa_lo = le32_to_cpu(cmd->frame->pass.sense_addr_lo);
+ if (megasas_frame_is_sense64(cmd)) {
+ pa_hi = le32_to_cpu(cmd->frame->pass.sense_addr_hi);
+ }
+ pa = ((uint64_t) pa_hi << 32) | pa_lo;
+ cpu_physical_memory_write(pa, sense_ptr, sense_len);
+ cmd->frame->header.sense_len = sense_len;
+ }
+ return sense_len;
+}
+
+static void megasas_write_sense(MegasasCmd *cmd, SCSISense sense)
+{
+ uint8_t sense_buf[SCSI_SENSE_BUF_SIZE];
+ uint8_t sense_len = 18;
+
+ memset(sense_buf, 0, sense_len);
+ sense_buf[0] = 0xf0;
+ sense_buf[2] = sense.key;
+ sense_buf[7] = 10;
+ sense_buf[12] = sense.asc;
+ sense_buf[13] = sense.ascq;
+ megasas_build_sense(cmd, sense_buf, sense_len);
+}
+
+static void megasas_copy_sense(MegasasCmd *cmd)
+{
+ uint8_t sense_buf[SCSI_SENSE_BUF_SIZE];
+ uint8_t sense_len;
+
+ sense_len = scsi_req_get_sense(cmd->req, sense_buf,
+ SCSI_SENSE_BUF_SIZE);
+ megasas_build_sense(cmd, sense_buf, sense_len);
+}
+
+/*
+ * Format an INQUIRY CDB
+ */
+static int megasas_setup_inquiry(uint8_t *cdb, int pg, int len)
+{
+ memset(cdb, 0, 6);
+ cdb[0] = INQUIRY;
+ if (pg > 0) {
+ cdb[1] = 0x1;
+ cdb[2] = pg;
+ }
+ cdb[3] = (len >> 8) & 0xff;
+ cdb[4] = (len & 0xff);
+ return len;
+}
+
+/*
+ * Encode lba and len into a READ_16/WRITE_16 CDB
+ */
+static void megasas_encode_lba(uint8_t *cdb, uint64_t lba,
+ uint32_t len, bool is_write)
+{
+ memset(cdb, 0x0, 16);
+ if (is_write) {
+ cdb[0] = WRITE_16;
+ } else {
+ cdb[0] = READ_16;
+ }
+ cdb[2] = (lba >> 56) & 0xff;
+ cdb[3] = (lba >> 48) & 0xff;
+ cdb[4] = (lba >> 40) & 0xff;
+ cdb[5] = (lba >> 32) & 0xff;
+ cdb[6] = (lba >> 24) & 0xff;
+ cdb[7] = (lba >> 16) & 0xff;
+ cdb[8] = (lba >> 8) & 0xff;
+ cdb[9] = (lba) & 0xff;
+ cdb[10] = (len >> 24) & 0xff;
+ cdb[11] = (len >> 16) & 0xff;
+ cdb[12] = (len >> 8) & 0xff;
+ cdb[13] = (len) & 0xff;
+}
+
+/*
+ * Utility functions
+ */
+static uint64_t megasas_fw_time(void)
+{
+ struct tm curtime;
+ uint64_t bcd_time;
+
+ qemu_get_timedate(&curtime, 0);
+ bcd_time = ((uint64_t)curtime.tm_sec & 0xff) << 48 |
+ ((uint64_t)curtime.tm_min & 0xff) << 40 |
+ ((uint64_t)curtime.tm_hour & 0xff) << 32 |
+ ((uint64_t)curtime.tm_mday & 0xff) << 24 |
+ ((uint64_t)curtime.tm_mon & 0xff) << 16 |
+ ((uint64_t)(curtime.tm_year + 1900) & 0xffff);
+
+ return bcd_time;
+}
+
+static uint64_t megasas_gen_sas_addr(uint64_t id)
+{
+ uint64_t addr;
+
+ addr = 0x5001a4aULL << 36;
+ addr |= id & 0xfffffffff;
+
+ return addr;
+}
+
+/*
+ * Frame handling
+ */
+static int megasas_next_index(MegasasState *s, int index, int limit)
+{
+ index++;
+ if (index == limit) {
+ index = 0;
+ }
+ return index;
+}
+
+static MegasasCmd *megasas_lookup_frame(MegasasState *s,
+ target_phys_addr_t frame)
+{
+ MegasasCmd *cmd = NULL;
+ int num = 0, index;
+
+ index = s->reply_queue_head;
+
+ while (num < s->fw_cmds) {
+ if (s->frames[index].pa && s->frames[index].pa == frame) {
+ cmd = &s->frames[index];
+ break;
+ }
+ index = megasas_next_index(s, index, s->fw_cmds);
+ num++;
+ }
+
+ return cmd;
+}
+
+static MegasasCmd *megasas_next_frame(MegasasState *s,
+ target_phys_addr_t frame)
+{
+ MegasasCmd *cmd = NULL;
+ int num = 0, index;
+
+ cmd = megasas_lookup_frame(s, frame);
+ if (cmd) {
+ trace_megasas_qf_found(cmd->index, cmd->pa);
+ return cmd;
+ }
+ index = s->reply_queue_head;
+ num = 0;
+ while (num < s->fw_cmds) {
+ if (!s->frames[index].pa) {
+ cmd = &s->frames[index];
+ break;
+ }
+ index = megasas_next_index(s, index, s->fw_cmds);
+ num++;
+ }
+ if (!cmd) {
+ trace_megasas_qf_failed(frame);
+ }
+ trace_megasas_qf_new(index, cmd);
+ return cmd;
+}
+
+static MegasasCmd *megasas_enqueue_frame(MegasasState *s,
+ target_phys_addr_t frame, uint64_t context, int count)
+{
+ MegasasCmd *cmd = NULL;
+ int frame_size = MFI_FRAME_SIZE * 16;
+ target_phys_addr_t frame_size_p = frame_size;
+
+ cmd = megasas_next_frame(s, frame);
+ /* All frames busy */
+ if (!cmd) {
+ return NULL;
+ }
+ if (!cmd->pa) {
+ cmd->pa = frame;
+ /* Map all possible frames */
+ cmd->frame = cpu_physical_memory_map(frame, &frame_size_p, 0);
+ if (frame_size_p != frame_size) {
+ trace_megasas_qf_map_failed(cmd->index, (unsigned long)frame);
+ if (cmd->frame) {
+ cpu_physical_memory_unmap(cmd->frame, frame_size_p, 0, 0);
+ cmd->frame = NULL;
+ cmd->pa = 0;
+ }
+ s->event_count++;
+ return NULL;
+ }
+ cmd->pa_size = frame_size_p;
+ cmd->context = context;
+ if (!megasas_use_queue64(s)) {
+ cmd->context &= (uint64_t)0xFFFFFFFF;
+ }
+ }
+ cmd->count = count;
+ s->busy++;
+
+ trace_megasas_qf_enqueue(cmd->index, cmd->count, cmd->context,
+ s->reply_queue_head, s->busy);
+
+ return cmd;
+}
+
+static void megasas_complete_frame(MegasasState *s, uint64_t context)
+{
+ int tail, queue_offset;
+
+ /* Decrement busy count */
+ s->busy--;
+
+ if (s->reply_queue_pa) {
+ /*
+ * Put command on the reply queue.
+ * Context is opaque, but emulation is running in
+ * little endian. So convert it.
+ */
+ tail = s->reply_queue_head;
+ if (megasas_use_queue64(s)) {
+ queue_offset = tail * sizeof(uint64_t);
+ stq_le_phys(s->reply_queue_pa + queue_offset, context);
+ } else {
+ queue_offset = tail * sizeof(uint32_t);
+ stl_le_phys(s->reply_queue_pa + queue_offset, context);
+ }
+ s->reply_queue_head = megasas_next_index(s, tail, s->fw_cmds);
+ trace_megasas_qf_complete(context, tail, queue_offset,
+ s->busy, s->doorbell);
+ }
+
+ if (megasas_intr_enabled(s)) {
+ /* Notify HBA */
+ s->doorbell++;
+ if (s->doorbell == 1) {
+ if (msix_enabled(&s->dev)) {
+ trace_megasas_msix_raise(0);
+ msix_notify(&s->dev, 0);
+ } else {
+ trace_megasas_irq_raise();
+ qemu_irq_raise(s->dev.irq[0]);
+ }
+ }
+ } else {
+ trace_megasas_qf_complete_noirq(context);
+ }
+}
+
+static void megasas_reset_frames(MegasasState *s)
+{
+ int i;
+ MegasasCmd *cmd;
+
+ for (i = 0; i < s->fw_cmds; i++) {
+ cmd = &s->frames[i];
+ if (cmd->pa) {
+ cpu_physical_memory_unmap(cmd->frame, cmd->pa_size, 0, 0);
+ cmd->frame = NULL;
+ cmd->pa = 0;
+ }
+ }
+}
+
+static void megasas_abort_command(MegasasCmd *cmd)
+{
+ if (cmd->req) {
+ scsi_req_abort(cmd->req, ABORTED_COMMAND);
+ cmd->req = NULL;
+ }
+}
+
+static int megasas_init_firmware(MegasasState *s, MegasasCmd *cmd)
+{
+ uint32_t pa_hi, pa_lo;
+ target_phys_addr_t iq_pa, initq_size;
+ struct mfi_init_qinfo *initq;
+ uint32_t flags;
+ int ret = MFI_STAT_OK;
+
+ pa_lo = le32_to_cpu(cmd->frame->init.qinfo_new_addr_lo);
+ pa_hi = le32_to_cpu(cmd->frame->init.qinfo_new_addr_hi);
+ iq_pa = (((uint64_t) pa_hi << 32) | pa_lo);
+ trace_megasas_init_firmware((uint64_t)iq_pa);
+ initq_size = sizeof(*initq);
+ initq = cpu_physical_memory_map(iq_pa, &initq_size, 0);
+ if (!initq || initq_size != sizeof(*initq)) {
+ trace_megasas_initq_map_failed(cmd->index);
+ s->event_count++;
+ ret = MFI_STAT_MEMORY_NOT_AVAILABLE;
+ goto out;
+ }
+ s->reply_queue_len = le32_to_cpu(initq->rq_entries) & 0xFFFF;
+ if (s->reply_queue_len > s->fw_cmds) {
+ trace_megasas_initq_mismatch(s->reply_queue_len, s->fw_cmds);
+ s->event_count++;
+ ret = MFI_STAT_INVALID_PARAMETER;
+ goto out;
+ }
+ pa_lo = le32_to_cpu(initq->rq_addr_lo);
+ pa_hi = le32_to_cpu(initq->rq_addr_hi);
+ s->reply_queue_pa = ((uint64_t) pa_hi << 32) | pa_lo;
+ pa_lo = le32_to_cpu(initq->ci_addr_lo);
+ pa_hi = le32_to_cpu(initq->ci_addr_hi);
+ s->consumer_pa = ((uint64_t) pa_hi << 32) | pa_lo;
+ pa_lo = le32_to_cpu(initq->pi_addr_lo);
+ pa_hi = le32_to_cpu(initq->pi_addr_hi);
+ s->producer_pa = ((uint64_t) pa_hi << 32) | pa_lo;
+ s->reply_queue_head = ldl_le_phys(s->producer_pa);
+ s->reply_queue_tail = ldl_le_phys(s->consumer_pa);
+ flags = le32_to_cpu(initq->flags);
+ if (flags & MFI_QUEUE_FLAG_CONTEXT64) {
+ s->flags |= MEGASAS_MASK_USE_QUEUE64;
+ }
+ trace_megasas_init_queue((unsigned long)s->reply_queue_pa,
+ s->reply_queue_len, s->reply_queue_head,
+ s->reply_queue_tail, flags);
+ megasas_reset_frames(s);
+ s->fw_state = MFI_FWSTATE_OPERATIONAL;
+out:
+ if (initq) {
+ cpu_physical_memory_unmap(initq, initq_size, 0, 0);
+ }
+ return ret;
+}
+
+static int megasas_map_dcmd(MegasasState *s, MegasasCmd *cmd)
+{
+ dma_addr_t iov_pa, iov_size;
+
+ cmd->flags = le16_to_cpu(cmd->frame->header.flags);
+ if (!cmd->frame->header.sge_count) {
+ trace_megasas_dcmd_zero_sge(cmd->index);
+ cmd->iov_size = 0;
+ return 0;
+ } else if (cmd->frame->header.sge_count > 1) {
+ trace_megasas_dcmd_invalid_sge(cmd->index,
+ cmd->frame->header.sge_count);
+ cmd->iov_size = 0;
+ return -1;
+ }
+ iov_pa = megasas_sgl_get_addr(cmd, &cmd->frame->dcmd.sgl);
+ iov_size = megasas_sgl_get_len(cmd, &cmd->frame->dcmd.sgl);
+ qemu_sglist_init(&cmd->qsg, 1, pci_dma_context(&s->dev));
+ qemu_sglist_add(&cmd->qsg, iov_pa, iov_size);
+ cmd->iov_size = iov_size;
+ return cmd->iov_size;
+}
+
+static void megasas_finish_dcmd(MegasasCmd *cmd, uint32_t iov_size)
+{
+ trace_megasas_finish_dcmd(cmd->index, iov_size);
+
+ if (cmd->frame->header.sge_count) {
+ qemu_sglist_destroy(&cmd->qsg);
+ }
+ if (iov_size > cmd->iov_size) {
+ if (megasas_frame_is_ieee_sgl(cmd)) {
+ cmd->frame->dcmd.sgl.sg_skinny->len = cpu_to_le32(iov_size);
+ } else if (megasas_frame_is_sgl64(cmd)) {
+ cmd->frame->dcmd.sgl.sg64->len = cpu_to_le32(iov_size);
+ } else {
+ cmd->frame->dcmd.sgl.sg32->len = cpu_to_le32(iov_size);
+ }
+ }
+ cmd->iov_size = 0;
+ return;
+}
+
+static int megasas_ctrl_get_info(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_ctrl_info info;
+ size_t dcmd_size = sizeof(info);
+ BusChild *kid;
+ int num_ld_disks = 0;
+
+ QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
+ num_ld_disks++;
+ }
+
+ memset(&info, 0x0, cmd->iov_size);
+ if (cmd->iov_size < dcmd_size) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_size);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ info.pci.vendor = cpu_to_le16(PCI_VENDOR_ID_LSI_LOGIC);
+ info.pci.device = cpu_to_le16(PCI_DEVICE_ID_LSI_SAS1078);
+ info.pci.subvendor = cpu_to_le16(PCI_VENDOR_ID_LSI_LOGIC);
+ info.pci.subdevice = cpu_to_le16(0x1013);
+
+ info.host.type = MFI_INFO_HOST_PCIX;
+ info.device.type = MFI_INFO_DEV_SAS3G;
+ info.device.port_count = 2;
+ info.device.port_addr[0] = cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
+
+ memcpy(info.product_name, "MegaRAID SAS 8708EM2", 20);
+ snprintf(info.serial_number, 32, "QEMU%08lx",
+ (unsigned long)s & 0xFFFFFFFF);
+ snprintf(info.package_version, 0x60, "%s-QEMU", QEMU_VERSION);
+ memcpy(info.image_component[0].name, "APP", 3);
+ memcpy(info.image_component[0].version, MEGASAS_VERSION "-QEMU", 9);
+ memcpy(info.image_component[0].build_date, __DATE__, 11);
+ memcpy(info.image_component[0].build_time, __TIME__, 8);
+ info.image_component_count = 1;
+ if (s->dev.has_rom) {
+ uint8_t biosver[32];
+ uint8_t *ptr;
+
+ ptr = memory_region_get_ram_ptr(&s->dev.rom);
+ memcpy(biosver, ptr + 0x41, 31);
+ qemu_put_ram_ptr(ptr);
+ memcpy(info.image_component[1].name, "BIOS", 4);
+ memcpy(info.image_component[1].version, biosver,
+ strlen((const char *)biosver));
+ info.image_component_count++;
+ }
+ info.current_fw_time = cpu_to_le32(megasas_fw_time());
+ info.max_arms = 32;
+ info.max_spans = 8;
+ info.max_arrays = MEGASAS_MAX_ARRAYS;
+ info.max_lds = s->fw_luns;
+ info.max_cmds = cpu_to_le16(s->fw_cmds);
+ info.max_sg_elements = cpu_to_le16(s->fw_sge);
+ info.max_request_size = cpu_to_le32(MEGASAS_MAX_SECTORS);
+ info.lds_present = cpu_to_le16(num_ld_disks);
+ info.pd_present = cpu_to_le16(num_ld_disks);
+ info.pd_disks_present = cpu_to_le16(num_ld_disks);
+ info.hw_present = cpu_to_le32(MFI_INFO_HW_NVRAM |
+ MFI_INFO_HW_MEM |
+ MFI_INFO_HW_FLASH);
+ info.memory_size = cpu_to_le16(512);
+ info.nvram_size = cpu_to_le16(32);
+ info.flash_size = cpu_to_le16(16);
+ info.raid_levels = cpu_to_le32(MFI_INFO_RAID_0);
+ info.adapter_ops = cpu_to_le32(MFI_INFO_AOPS_RBLD_RATE |
+ MFI_INFO_AOPS_SELF_DIAGNOSTIC |
+ MFI_INFO_AOPS_MIXED_ARRAY);
+ info.ld_ops = cpu_to_le32(MFI_INFO_LDOPS_DISK_CACHE_POLICY |
+ MFI_INFO_LDOPS_ACCESS_POLICY |
+ MFI_INFO_LDOPS_IO_POLICY |
+ MFI_INFO_LDOPS_WRITE_POLICY |
+ MFI_INFO_LDOPS_READ_POLICY);
+ info.max_strips_per_io = cpu_to_le16(s->fw_sge);
+ info.stripe_sz_ops.min = 3;
+ info.stripe_sz_ops.max = ffs(MEGASAS_MAX_SECTORS + 1) - 1;
+ info.properties.pred_fail_poll_interval = cpu_to_le16(300);
+ info.properties.intr_throttle_cnt = cpu_to_le16(16);
+ info.properties.intr_throttle_timeout = cpu_to_le16(50);
+ info.properties.rebuild_rate = 30;
+ info.properties.patrol_read_rate = 30;
+ info.properties.bgi_rate = 30;
+ info.properties.cc_rate = 30;
+ info.properties.recon_rate = 30;
+ info.properties.cache_flush_interval = 4;
+ info.properties.spinup_drv_cnt = 2;
+ info.properties.spinup_delay = 6;
+ info.properties.ecc_bucket_size = 15;
+ info.properties.ecc_bucket_leak_rate = cpu_to_le16(1440);
+ info.properties.expose_encl_devices = 1;
+ info.properties.OnOffProperties = cpu_to_le32(MFI_CTRL_PROP_EnableJBOD);
+ info.pd_ops = cpu_to_le32(MFI_INFO_PDOPS_FORCE_ONLINE |
+ MFI_INFO_PDOPS_FORCE_OFFLINE);
+ info.pd_mix_support = cpu_to_le32(MFI_INFO_PDMIX_SAS |
+ MFI_INFO_PDMIX_SATA |
+ MFI_INFO_PDMIX_LD);
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_mfc_get_defaults(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_defaults info;
+ size_t dcmd_size = sizeof(struct mfi_defaults);
+
+ memset(&info, 0x0, dcmd_size);
+ if (cmd->iov_size < dcmd_size) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_size);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ info.sas_addr = cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
+ info.stripe_size = 3;
+ info.flush_time = 4;
+ info.background_rate = 30;
+ info.allow_mix_in_enclosure = 1;
+ info.allow_mix_in_ld = 1;
+ info.direct_pd_mapping = 1;
+ /* Enable for BIOS support */
+ info.bios_enumerate_lds = 1;
+ info.disable_ctrl_r = 1;
+ info.expose_enclosure_devices = 1;
+ info.disable_preboot_cli = 1;
+ info.cluster_disable = 1;
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_get_bios_info(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_bios_data info;
+ size_t dcmd_size = sizeof(info);
+
+ memset(&info, 0x0, dcmd_size);
+ if (cmd->iov_size < dcmd_size) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_size);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+ info.continue_on_error = 1;
+ info.verbose = 1;
+ if (megasas_is_jbod(s)) {
+ info.expose_all_drives = 1;
+ }
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_get_fw_time(MegasasState *s, MegasasCmd *cmd)
+{
+ uint64_t fw_time;
+ size_t dcmd_size = sizeof(fw_time);
+
+ fw_time = cpu_to_le64(megasas_fw_time());
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&fw_time, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_set_fw_time(MegasasState *s, MegasasCmd *cmd)
+{
+ uint64_t fw_time;
+
+ /* This is a dummy; setting of firmware time is not allowed */
+ memcpy(&fw_time, cmd->frame->dcmd.mbox, sizeof(fw_time));
+
+ trace_megasas_dcmd_set_fw_time(cmd->index, fw_time);
+ fw_time = cpu_to_le64(megasas_fw_time());
+ return MFI_STAT_OK;
+}
+
+static int megasas_event_info(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_evt_log_state info;
+ size_t dcmd_size = sizeof(info);
+
+ memset(&info, 0, dcmd_size);
+
+ info.newest_seq_num = cpu_to_le32(s->event_count);
+ info.shutdown_seq_num = cpu_to_le32(s->shutdown_event);
+ info.boot_seq_num = cpu_to_le32(s->boot_event);
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_event_wait(MegasasState *s, MegasasCmd *cmd)
+{
+ union mfi_evt event;
+
+ if (cmd->iov_size < sizeof(struct mfi_evt_detail)) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ sizeof(struct mfi_evt_detail));
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+ s->event_count = cpu_to_le32(cmd->frame->dcmd.mbox[0]);
+ event.word = cpu_to_le32(cmd->frame->dcmd.mbox[4]);
+ s->event_locale = event.members.locale;
+ s->event_class = event.members.class;
+ s->event_cmd = cmd;
+ /* Decrease busy count; event frame doesn't count here */
+ s->busy--;
+ cmd->iov_size = sizeof(struct mfi_evt_detail);
+ return MFI_STAT_INVALID_STATUS;
+}
+
+static int megasas_dcmd_pd_get_list(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_pd_list info;
+ size_t dcmd_size = sizeof(info);
+ BusChild *kid;
+ uint32_t offset, dcmd_limit, num_pd_disks = 0, max_pd_disks;
+ uint16_t sdev_id;
+
+ memset(&info, 0, dcmd_size);
+ offset = 8;
+ dcmd_limit = offset + sizeof(struct mfi_pd_address);
+ if (cmd->iov_size < dcmd_limit) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_limit);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ max_pd_disks = (cmd->iov_size - offset) / sizeof(struct mfi_pd_address);
+ if (max_pd_disks > s->fw_luns) {
+ max_pd_disks = s->fw_luns;
+ }
+
+ QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
+ SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
+
+ sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
+ info.addr[num_pd_disks].device_id = cpu_to_le16(sdev_id);
+ info.addr[num_pd_disks].encl_device_id = 0xFFFF;
+ info.addr[num_pd_disks].encl_index = 0;
+ info.addr[num_pd_disks].slot_number = (sdev->id & 0xFF);
+ info.addr[num_pd_disks].scsi_dev_type = sdev->type;
+ info.addr[num_pd_disks].connect_port_bitmap = 0x1;
+ info.addr[num_pd_disks].sas_addr[0] =
+ cpu_to_le64(megasas_gen_sas_addr((uint64_t)sdev));
+ num_pd_disks++;
+ offset += sizeof(struct mfi_pd_address);
+ }
+ trace_megasas_dcmd_pd_get_list(cmd->index, num_pd_disks,
+ max_pd_disks, offset);
+
+ info.size = cpu_to_le32(offset);
+ info.count = cpu_to_le32(num_pd_disks);
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, offset, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_pd_list_query(MegasasState *s, MegasasCmd *cmd)
+{
+ uint16_t flags;
+
+ /* mbox0 contains flags */
+ flags = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
+ trace_megasas_dcmd_pd_list_query(cmd->index, flags);
+ if (flags == MR_PD_QUERY_TYPE_ALL ||
+ megasas_is_jbod(s)) {
+ return megasas_dcmd_pd_get_list(s, cmd);
+ }
+
+ return MFI_STAT_OK;
+}
+
+static int megasas_pd_get_info_submit(SCSIDevice *sdev, int lun,
+ MegasasCmd *cmd)
+{
+ struct mfi_pd_info *info = cmd->iov_buf;
+ size_t dcmd_size = sizeof(struct mfi_pd_info);
+ BlockConf *conf = &sdev->conf;
+ uint64_t pd_size;
+ uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
+ uint8_t cmdbuf[6];
+ SCSIRequest *req;
+ size_t len, resid;
+
+ if (!cmd->iov_buf) {
+ cmd->iov_buf = g_malloc(dcmd_size);
+ memset(cmd->iov_buf, 0, dcmd_size);
+ info = cmd->iov_buf;
+ info->inquiry_data[0] = 0x7f; /* Force PQual 0x3, PType 0x1f */
+ info->vpd_page83[0] = 0x7f;
+ megasas_setup_inquiry(cmdbuf, 0, sizeof(info->inquiry_data));
+ req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
+ if (!req) {
+ trace_megasas_dcmd_req_alloc_failed(cmd->index,
+ "PD get info std inquiry");
+ g_free(cmd->iov_buf);
+ cmd->iov_buf = NULL;
+ return MFI_STAT_FLASH_ALLOC_FAIL;
+ }
+ trace_megasas_dcmd_internal_submit(cmd->index,
+ "PD get info std inquiry", lun);
+ len = scsi_req_enqueue(req);
+ if (len > 0) {
+ cmd->iov_size = len;
+ scsi_req_continue(req);
+ }
+ return MFI_STAT_INVALID_STATUS;
+ } else if (info->inquiry_data[0] != 0x7f && info->vpd_page83[0] == 0x7f) {
+ megasas_setup_inquiry(cmdbuf, 0x83, sizeof(info->vpd_page83));
+ req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
+ if (!req) {
+ trace_megasas_dcmd_req_alloc_failed(cmd->index,
+ "PD get info vpd inquiry");
+ return MFI_STAT_FLASH_ALLOC_FAIL;
+ }
+ trace_megasas_dcmd_internal_submit(cmd->index,
+ "PD get info vpd inquiry", lun);
+ len = scsi_req_enqueue(req);
+ if (len > 0) {
+ cmd->iov_size = len;
+ scsi_req_continue(req);
+ }
+ return MFI_STAT_INVALID_STATUS;
+ }
+ /* Finished, set FW state */
+ if ((info->inquiry_data[0] >> 5) == 0) {
+ if (megasas_is_jbod(cmd->state)) {
+ info->fw_state = cpu_to_le16(MFI_PD_STATE_SYSTEM);
+ } else {
+ info->fw_state = cpu_to_le16(MFI_PD_STATE_ONLINE);
+ }
+ } else {
+ info->fw_state = cpu_to_le16(MFI_PD_STATE_OFFLINE);
+ }
+
+ info->ref.v.device_id = cpu_to_le16(sdev_id);
+ info->state.ddf.pd_type = cpu_to_le16(MFI_PD_DDF_TYPE_IN_VD|
+ MFI_PD_DDF_TYPE_INTF_SAS);
+ bdrv_get_geometry(conf->bs, &pd_size);
+ info->raw_size = cpu_to_le64(pd_size);
+ info->non_coerced_size = cpu_to_le64(pd_size);
+ info->coerced_size = cpu_to_le64(pd_size);
+ info->encl_device_id = 0xFFFF;
+ info->slot_number = (sdev->id & 0xFF);
+ info->path_info.count = 1;
+ info->path_info.sas_addr[0] =
+ cpu_to_le64(megasas_gen_sas_addr((uint64_t)sdev));
+ info->connected_port_bitmap = 0x1;
+ info->device_speed = 1;
+ info->link_speed = 1;
+ resid = dma_buf_read(cmd->iov_buf, dcmd_size, &cmd->qsg);
+ g_free(cmd->iov_buf);
+ cmd->iov_size = dcmd_size - resid;
+ cmd->iov_buf = NULL;
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_pd_get_info(MegasasState *s, MegasasCmd *cmd)
+{
+ size_t dcmd_size = sizeof(struct mfi_pd_info);
+ uint16_t pd_id;
+ SCSIDevice *sdev = NULL;
+ int retval = MFI_STAT_DEVICE_NOT_FOUND;
+
+ if (cmd->iov_size < dcmd_size) {
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ /* mbox0 has the ID */
+ pd_id = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
+ sdev = scsi_device_find(&s->bus, 0, pd_id, 0);
+ trace_megasas_dcmd_pd_get_info(cmd->index, pd_id);
+
+ if (sdev) {
+ /* Submit inquiry */
+ retval = megasas_pd_get_info_submit(sdev, pd_id, cmd);
+ }
+
+ return retval;
+}
+
+static int megasas_dcmd_ld_get_list(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_ld_list info;
+ size_t dcmd_size = sizeof(info), resid;
+ uint32_t num_ld_disks = 0, max_ld_disks = s->fw_luns;
+ uint64_t ld_size;
+ BusChild *kid;
+
+ memset(&info, 0, dcmd_size);
+ if (cmd->iov_size < dcmd_size) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_size);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ if (megasas_is_jbod(s)) {
+ max_ld_disks = 0;
+ }
+ QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
+ SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
+ BlockConf *conf = &sdev->conf;
+
+ if (num_ld_disks >= max_ld_disks) {
+ break;
+ }
+ /* Logical device size is in blocks */
+ bdrv_get_geometry(conf->bs, &ld_size);
+ info.ld_list[num_ld_disks].ld.v.target_id = sdev->id;
+ info.ld_list[num_ld_disks].state = MFI_LD_STATE_OPTIMAL;
+ info.ld_list[num_ld_disks].size = cpu_to_le64(ld_size);
+ num_ld_disks++;
+ }
+ info.ld_count = cpu_to_le32(num_ld_disks);
+ trace_megasas_dcmd_ld_get_list(cmd->index, num_ld_disks, max_ld_disks);
+
+ resid = dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ cmd->iov_size = dcmd_size - resid;
+ return MFI_STAT_OK;
+}
+
+static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun,
+ MegasasCmd *cmd)
+{
+ struct mfi_ld_info *info = cmd->iov_buf;
+ size_t dcmd_size = sizeof(struct mfi_ld_info);
+ uint8_t cdb[6];
+ SCSIRequest *req;
+ ssize_t len, resid;
+ BlockConf *conf = &sdev->conf;
+ uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
+ uint64_t ld_size;
+
+ if (!cmd->iov_buf) {
+ cmd->iov_buf = g_malloc(dcmd_size);
+ memset(cmd->iov_buf, 0x0, dcmd_size);
+ info = cmd->iov_buf;
+ megasas_setup_inquiry(cdb, 0x83, sizeof(info->vpd_page83));
+ req = scsi_req_new(sdev, cmd->index, lun, cdb, cmd);
+ if (!req) {
+ trace_megasas_dcmd_req_alloc_failed(cmd->index,
+ "LD get info vpd inquiry");
+ g_free(cmd->iov_buf);
+ cmd->iov_buf = NULL;
+ return MFI_STAT_FLASH_ALLOC_FAIL;
+ }
+ trace_megasas_dcmd_internal_submit(cmd->index,
+ "LD get info vpd inquiry", lun);
+ len = scsi_req_enqueue(req);
+ if (len > 0) {
+ cmd->iov_size = len;
+ scsi_req_continue(req);
+ }
+ return MFI_STAT_INVALID_STATUS;
+ }
+
+ info->ld_config.params.state = MFI_LD_STATE_OPTIMAL;
+ info->ld_config.properties.ld.v.target_id = lun;
+ info->ld_config.params.stripe_size = 3;
+ info->ld_config.params.num_drives = 1;
+ info->ld_config.params.is_consistent = 1;
+ /* Logical device size is in blocks */
+ bdrv_get_geometry(conf->bs, &ld_size);
+ info->size = cpu_to_le64(ld_size);
+ memset(info->ld_config.span, 0, sizeof(info->ld_config.span));
+ info->ld_config.span[0].start_block = 0;
+ info->ld_config.span[0].num_blocks = info->size;
+ info->ld_config.span[0].array_ref = cpu_to_le16(sdev_id);
+
+ resid = dma_buf_read(cmd->iov_buf, dcmd_size, &cmd->qsg);
+ g_free(cmd->iov_buf);
+ cmd->iov_size = dcmd_size - resid;
+ cmd->iov_buf = NULL;
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_ld_get_info(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_ld_info info;
+ size_t dcmd_size = sizeof(info);
+ uint16_t ld_id;
+ uint32_t max_ld_disks = s->fw_luns;
+ SCSIDevice *sdev = NULL;
+ int retval = MFI_STAT_DEVICE_NOT_FOUND;
+
+ if (cmd->iov_size < dcmd_size) {
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ /* mbox0 has the ID */
+ ld_id = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
+ trace_megasas_dcmd_ld_get_info(cmd->index, ld_id);
+
+ if (megasas_is_jbod(s)) {
+ return MFI_STAT_DEVICE_NOT_FOUND;
+ }
+
+ if (ld_id < max_ld_disks) {
+ sdev = scsi_device_find(&s->bus, 0, ld_id, 0);
+ }
+
+ if (sdev) {
+ retval = megasas_ld_get_info_submit(sdev, ld_id, cmd);
+ }
+
+ return retval;
+}
+
+static int megasas_dcmd_cfg_read(MegasasState *s, MegasasCmd *cmd)
+{
+ uint8_t data[4096];
+ struct mfi_config_data *info;
+ int num_pd_disks = 0, array_offset, ld_offset;
+ BusChild *kid;
+
+ if (cmd->iov_size > 4096) {
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
+ num_pd_disks++;
+ }
+ info = (struct mfi_config_data *)&data;
+ /*
+ * Array mapping:
+ * - One array per SCSI device
+ * - One logical drive per SCSI device
+ * spanning the entire device
+ */
+ info->array_count = num_pd_disks;
+ info->array_size = sizeof(struct mfi_array) * num_pd_disks;
+ info->log_drv_count = num_pd_disks;
+ info->log_drv_size = sizeof(struct mfi_ld_config) * num_pd_disks;
+ info->spares_count = 0;
+ info->spares_size = sizeof(struct mfi_spare);
+ info->size = sizeof(struct mfi_config_data) + info->array_size +
+ info->log_drv_size;
+ if (info->size > 4096) {
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+
+ array_offset = sizeof(struct mfi_config_data);
+ ld_offset = array_offset + sizeof(struct mfi_array) * num_pd_disks;
+
+ QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
+ SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
+ BlockConf *conf = &sdev->conf;
+ uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
+ struct mfi_array *array;
+ struct mfi_ld_config *ld;
+ uint64_t pd_size;
+ int i;
+
+ array = (struct mfi_array *)(data + array_offset);
+ bdrv_get_geometry(conf->bs, &pd_size);
+ array->size = cpu_to_le64(pd_size);
+ array->num_drives = 1;
+ array->array_ref = cpu_to_le16(sdev_id);
+ array->pd[0].ref.v.device_id = cpu_to_le16(sdev_id);
+ array->pd[0].ref.v.seq_num = 0;
+ array->pd[0].fw_state = MFI_PD_STATE_ONLINE;
+ array->pd[0].encl.pd = 0xFF;
+ array->pd[0].encl.slot = (sdev->id & 0xFF);
+ for (i = 1; i < MFI_MAX_ROW_SIZE; i++) {
+ array->pd[i].ref.v.device_id = 0xFFFF;
+ array->pd[i].ref.v.seq_num = 0;
+ array->pd[i].fw_state = MFI_PD_STATE_UNCONFIGURED_GOOD;
+ array->pd[i].encl.pd = 0xFF;
+ array->pd[i].encl.slot = 0xFF;
+ }
+ array_offset += sizeof(struct mfi_array);
+ ld = (struct mfi_ld_config *)(data + ld_offset);
+ memset(ld, 0, sizeof(struct mfi_ld_config));
+ ld->properties.ld.v.target_id = (sdev->id & 0xFF);
+ ld->properties.default_cache_policy = MR_LD_CACHE_READ_AHEAD |
+ MR_LD_CACHE_READ_ADAPTIVE;
+ ld->properties.current_cache_policy = MR_LD_CACHE_READ_AHEAD |
+ MR_LD_CACHE_READ_ADAPTIVE;
+ ld->params.state = MFI_LD_STATE_OPTIMAL;
+ ld->params.stripe_size = 3;
+ ld->params.num_drives = 1;
+ ld->params.span_depth = 1;
+ ld->params.is_consistent = 1;
+ ld->span[0].start_block = 0;
+ ld->span[0].num_blocks = cpu_to_le64(pd_size);
+ ld->span[0].array_ref = cpu_to_le16(sdev_id);
+ ld_offset += sizeof(struct mfi_ld_config);
+ }
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)data, info->size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_get_properties(MegasasState *s, MegasasCmd *cmd)
+{
+ struct mfi_ctrl_props info;
+ size_t dcmd_size = sizeof(info);
+
+ memset(&info, 0x0, dcmd_size);
+ if (cmd->iov_size < dcmd_size) {
+ trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
+ dcmd_size);
+ return MFI_STAT_INVALID_PARAMETER;
+ }
+ info.pred_fail_poll_interval = cpu_to_le16(300);
+ info.intr_throttle_cnt = cpu_to_le16(16);
+ info.intr_throttle_timeout = cpu_to_le16(50);
+ info.rebuild_rate = 30;
+ info.patrol_read_rate = 30;
+ info.bgi_rate = 30;
+ info.cc_rate = 30;
+ info.recon_rate = 30;
+ info.cache_flush_interval = 4;
+ info.spinup_drv_cnt = 2;
+ info.spinup_delay = 6;
+ info.ecc_bucket_size = 15;
+ info.ecc_bucket_leak_rate = cpu_to_le16(1440);
+ info.expose_encl_devices = 1;
+
+ cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
+ return MFI_STAT_OK;
+}
+
+static int megasas_cache_flush(MegasasState *s, MegasasCmd *cmd)
+{
+ qemu_aio_flush();
+ return MFI_STAT_OK;
+}
+
+static int megasas_ctrl_shutdown(MegasasState *s, MegasasCmd *cmd)
+{
+ s->fw_state = MFI_FWSTATE_READY;
+ return MFI_STAT_OK;
+}
+
+static int megasas_cluster_reset_ld(MegasasState *s, MegasasCmd *cmd)
+{
+ return MFI_STAT_INVALID_DCMD;
+}
+
+static int megasas_dcmd_set_properties(MegasasState *s, MegasasCmd *cmd)
+{
+ uint8_t *dummy = g_malloc(cmd->iov_size);
+
+ dma_buf_write(dummy, cmd->iov_size, &cmd->qsg);
+
+ trace_megasas_dcmd_dump_frame(0,
+ dummy[0x00], dummy[0x01], dummy[0x02], dummy[0x03],
+ dummy[0x04], dummy[0x05], dummy[0x06], dummy[0x07]);
+ trace_megasas_dcmd_dump_frame(1,
+ dummy[0x08], dummy[0x09], dummy[0x0a], dummy[0x0b],
+ dummy[0x0c], dummy[0x0d], dummy[0x0e], dummy[0x0f]);
+ trace_megasas_dcmd_dump_frame(2,
+ dummy[0x10], dummy[0x11], dummy[0x12], dummy[0x13],
+ dummy[0x14], dummy[0x15], dummy[0x16], dummy[0x17]);
+ trace_megasas_dcmd_dump_frame(3,
+ dummy[0x18], dummy[0x19], dummy[0x1a], dummy[0x1b],
+ dummy[0x1c], dummy[0x1d], dummy[0x1e], dummy[0x1f]);
+ trace_megasas_dcmd_dump_frame(4,
+ dummy[0x20], dummy[0x21], dummy[0x22], dummy[0x23],
+ dummy[0x24], dummy[0x25], dummy[0x26], dummy[0x27]);
+ trace_megasas_dcmd_dump_frame(5,
+ dummy[0x28], dummy[0x29], dummy[0x2a], dummy[0x2b],
+ dummy[0x2c], dummy[0x2d], dummy[0x2e], dummy[0x2f]);
+ trace_megasas_dcmd_dump_frame(6,
+ dummy[0x30], dummy[0x31], dummy[0x32], dummy[0x33],
+ dummy[0x34], dummy[0x35], dummy[0x36], dummy[0x37]);
+ trace_megasas_dcmd_dump_frame(7,
+ dummy[0x38], dummy[0x39], dummy[0x3a], dummy[0x3b],
+ dummy[0x3c], dummy[0x3d], dummy[0x3e], dummy[0x3f]);
+ g_free(dummy);
+ return MFI_STAT_OK;
+}
+
+static int megasas_dcmd_dummy(MegasasState *s, MegasasCmd *cmd)
+{
+ trace_megasas_dcmd_dummy(cmd->index, cmd->iov_size);
+ return MFI_STAT_OK;
+}
+
+static const struct dcmd_cmd_tbl_t {
+ int opcode;
+ const char *desc;
+ int (*func)(MegasasState *s, MegasasCmd *cmd);
+} dcmd_cmd_tbl[] = {
+ { MFI_DCMD_CTRL_MFI_HOST_MEM_ALLOC, "CTRL_HOST_MEM_ALLOC",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_GET_INFO, "CTRL_GET_INFO",
+ megasas_ctrl_get_info },
+ { MFI_DCMD_CTRL_GET_PROPERTIES, "CTRL_GET_PROPERTIES",
+ megasas_dcmd_get_properties },
+ { MFI_DCMD_CTRL_SET_PROPERTIES, "CTRL_SET_PROPERTIES",
+ megasas_dcmd_set_properties },
+ { MFI_DCMD_CTRL_ALARM_GET, "CTRL_ALARM_GET",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_ALARM_ENABLE, "CTRL_ALARM_ENABLE",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_ALARM_DISABLE, "CTRL_ALARM_DISABLE",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_ALARM_SILENCE, "CTRL_ALARM_SILENCE",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_ALARM_TEST, "CTRL_ALARM_TEST",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_EVENT_GETINFO, "CTRL_EVENT_GETINFO",
+ megasas_event_info },
+ { MFI_DCMD_CTRL_EVENT_GET, "CTRL_EVENT_GET",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_EVENT_WAIT, "CTRL_EVENT_WAIT",
+ megasas_event_wait },
+ { MFI_DCMD_CTRL_SHUTDOWN, "CTRL_SHUTDOWN",
+ megasas_ctrl_shutdown },
+ { MFI_DCMD_HIBERNATE_STANDBY, "CTRL_STANDBY",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_GET_TIME, "CTRL_GET_TIME",
+ megasas_dcmd_get_fw_time },
+ { MFI_DCMD_CTRL_SET_TIME, "CTRL_SET_TIME",
+ megasas_dcmd_set_fw_time },
+ { MFI_DCMD_CTRL_BIOS_DATA_GET, "CTRL_BIOS_DATA_GET",
+ megasas_dcmd_get_bios_info },
+ { MFI_DCMD_CTRL_FACTORY_DEFAULTS, "CTRL_FACTORY_DEFAULTS",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_MFC_DEFAULTS_GET, "CTRL_MFC_DEFAULTS_GET",
+ megasas_mfc_get_defaults },
+ { MFI_DCMD_CTRL_MFC_DEFAULTS_SET, "CTRL_MFC_DEFAULTS_SET",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CTRL_CACHE_FLUSH, "CTRL_CACHE_FLUSH",
+ megasas_cache_flush },
+ { MFI_DCMD_PD_GET_LIST, "PD_GET_LIST",
+ megasas_dcmd_pd_get_list },
+ { MFI_DCMD_PD_LIST_QUERY, "PD_LIST_QUERY",
+ megasas_dcmd_pd_list_query },
+ { MFI_DCMD_PD_GET_INFO, "PD_GET_INFO",
+ megasas_dcmd_pd_get_info },
+ { MFI_DCMD_PD_STATE_SET, "PD_STATE_SET",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_PD_REBUILD, "PD_REBUILD",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_PD_BLINK, "PD_BLINK",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_PD_UNBLINK, "PD_UNBLINK",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_LD_GET_LIST, "LD_GET_LIST",
+ megasas_dcmd_ld_get_list},
+ { MFI_DCMD_LD_GET_INFO, "LD_GET_INFO",
+ megasas_dcmd_ld_get_info },
+ { MFI_DCMD_LD_GET_PROP, "LD_GET_PROP",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_LD_SET_PROP, "LD_SET_PROP",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_LD_DELETE, "LD_DELETE",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CFG_READ, "CFG_READ",
+ megasas_dcmd_cfg_read },
+ { MFI_DCMD_CFG_ADD, "CFG_ADD",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CFG_CLEAR, "CFG_CLEAR",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CFG_FOREIGN_READ, "CFG_FOREIGN_READ",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CFG_FOREIGN_IMPORT, "CFG_FOREIGN_IMPORT",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_BBU_STATUS, "BBU_STATUS",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_BBU_CAPACITY_INFO, "BBU_CAPACITY_INFO",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_BBU_DESIGN_INFO, "BBU_DESIGN_INFO",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_BBU_PROP_GET, "BBU_PROP_GET",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CLUSTER, "CLUSTER",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CLUSTER_RESET_ALL, "CLUSTER_RESET_ALL",
+ megasas_dcmd_dummy },
+ { MFI_DCMD_CLUSTER_RESET_LD, "CLUSTER_RESET_LD",
+ megasas_cluster_reset_ld },
+ { -1, NULL, NULL }
+};
+
+static int megasas_handle_dcmd(MegasasState *s, MegasasCmd *cmd)
+{
+ int opcode, len;
+ int retval = 0;
+ const struct dcmd_cmd_tbl_t *cmdptr = dcmd_cmd_tbl;
+
+ opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
+ trace_megasas_handle_dcmd(cmd->index, opcode);
+ len = megasas_map_dcmd(s, cmd);
+ if (len < 0) {
+ return MFI_STAT_MEMORY_NOT_AVAILABLE;
+ }
+ while (cmdptr->opcode != -1 && cmdptr->opcode != opcode) {
+ cmdptr++;
+ }
+ if (cmdptr->opcode == -1) {
+ trace_megasas_dcmd_unhandled(cmd->index, opcode, len);
+ retval = megasas_dcmd_dummy(s, cmd);
+ } else {
+ trace_megasas_dcmd_enter(cmd->index, cmdptr->desc, len);
+ retval = cmdptr->func(s, cmd);
+ }
+ if (retval != MFI_STAT_INVALID_STATUS) {
+ megasas_finish_dcmd(cmd, len);
+ }
+ return retval;
+}
+
+static int megasas_finish_internal_dcmd(MegasasCmd *cmd,
+ SCSIRequest *req)
+{
+ int opcode;
+ int retval = MFI_STAT_OK;
+ int lun = req->lun;
+
+ opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
+ scsi_req_unref(req);
+ trace_megasas_dcmd_internal_finish(cmd->index, opcode, lun);
+ switch (opcode) {
+ case MFI_DCMD_PD_GET_INFO:
+ retval = megasas_pd_get_info_submit(req->dev, lun, cmd);
+ break;
+ case MFI_DCMD_LD_GET_INFO:
+ retval = megasas_ld_get_info_submit(req->dev, lun, cmd);
+ break;
+ default:
+ trace_megasas_dcmd_internal_invalid(cmd->index, opcode);
+ retval = MFI_STAT_INVALID_DCMD;
+ break;
+ }
+ if (retval != MFI_STAT_INVALID_STATUS) {
+ megasas_finish_dcmd(cmd, cmd->iov_size);
+ }
+ return retval;
+}
+
+static int megasas_enqueue_req(MegasasCmd *cmd, bool is_write)
+{
+ int len;
+
+ len = scsi_req_enqueue(cmd->req);
+ if (len < 0) {
+ len = -len;
+ }
+ if (len > 0) {
+ if (len > cmd->iov_size) {
+ if (is_write) {
+ trace_megasas_iov_write_overflow(cmd->index, len,
+ cmd->iov_size);
+ } else {
+ trace_megasas_iov_read_overflow(cmd->index, len,
+ cmd->iov_size);
+ }
+ }
+ if (len < cmd->iov_size) {
+ if (is_write) {
+ trace_megasas_iov_write_underflow(cmd->index, len,
+ cmd->iov_size);
+ } else {
+ trace_megasas_iov_read_underflow(cmd->index, len,
+ cmd->iov_size);
+ }
+ cmd->iov_size = len;
+ }
+ scsi_req_continue(cmd->req);
+ }
+ return len;
+}
+
+static int megasas_handle_scsi(MegasasState *s, MegasasCmd *cmd,
+ bool is_logical)
+{
+ uint8_t *cdb;
+ int len;
+ bool is_write;
+ struct SCSIDevice *sdev = NULL;
+
+ cdb = cmd->frame->pass.cdb;
+
+ if (cmd->frame->header.target_id < s->fw_luns) {
+ sdev = scsi_device_find(&s->bus, 0, cmd->frame->header.target_id,
+ cmd->frame->header.lun_id);
+ }
+ cmd->iov_size = le32_to_cpu(cmd->frame->header.data_len);
+ trace_megasas_handle_scsi(mfi_frame_desc[cmd->frame->header.frame_cmd],
+ is_logical, cmd->frame->header.target_id,
+ cmd->frame->header.lun_id, sdev, cmd->iov_size);
+
+ if (!sdev || (megasas_is_jbod(s) && is_logical)) {
+ trace_megasas_scsi_target_not_present(
+ mfi_frame_desc[cmd->frame->header.frame_cmd], is_logical,
+ cmd->frame->header.target_id, cmd->frame->header.lun_id);
+ return MFI_STAT_DEVICE_NOT_FOUND;
+ }
+
+ if (cmd->frame->header.cdb_len > 16) {
+ trace_megasas_scsi_invalid_cdb_len(
+ mfi_frame_desc[cmd->frame->header.frame_cmd], is_logical,
+ cmd->frame->header.target_id, cmd->frame->header.lun_id,
+ cmd->frame->header.cdb_len);
+ megasas_write_sense(cmd, SENSE_CODE(INVALID_OPCODE));
+ cmd->frame->header.scsi_status = CHECK_CONDITION;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+
+ if (megasas_map_sgl(s, cmd, &cmd->frame->pass.sgl)) {
+ megasas_write_sense(cmd, SENSE_CODE(TARGET_FAILURE));
+ cmd->frame->header.scsi_status = CHECK_CONDITION;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+
+ cmd->req = scsi_req_new(sdev, cmd->index,
+ cmd->frame->header.lun_id, cdb, cmd);
+ if (!cmd->req) {
+ trace_megasas_scsi_req_alloc_failed(
+ mfi_frame_desc[cmd->frame->header.frame_cmd],
+ cmd->frame->header.target_id, cmd->frame->header.lun_id);
+ megasas_write_sense(cmd, SENSE_CODE(NO_SENSE));
+ cmd->frame->header.scsi_status = BUSY;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+
+ is_write = (cmd->req->cmd.mode == SCSI_XFER_TO_DEV);
+ len = megasas_enqueue_req(cmd, is_write);
+ if (len > 0) {
+ if (is_write) {
+ trace_megasas_scsi_write_start(cmd->index, len);
+ } else {
+ trace_megasas_scsi_read_start(cmd->index, len);
+ }
+ } else {
+ trace_megasas_scsi_nodata(cmd->index);
+ }
+ return MFI_STAT_INVALID_STATUS;
+}
+
+static int megasas_handle_io(MegasasState *s, MegasasCmd *cmd)
+{
+ uint32_t lba_count, lba_start_hi, lba_start_lo;
+ uint64_t lba_start;
+ bool is_write = (cmd->frame->header.frame_cmd == MFI_CMD_LD_WRITE);
+ uint8_t cdb[16];
+ int len;
+ struct SCSIDevice *sdev = NULL;
+
+ lba_count = le32_to_cpu(cmd->frame->io.header.data_len);
+ lba_start_lo = le32_to_cpu(cmd->frame->io.lba_lo);
+ lba_start_hi = le32_to_cpu(cmd->frame->io.lba_hi);
+ lba_start = ((uint64_t)lba_start_hi << 32) | lba_start_lo;
+
+ if (cmd->frame->header.target_id < s->fw_luns) {
+ sdev = scsi_device_find(&s->bus, 0, cmd->frame->header.target_id,
+ cmd->frame->header.lun_id);
+ }
+
+ trace_megasas_handle_io(cmd->index,
+ mfi_frame_desc[cmd->frame->header.frame_cmd],
+ cmd->frame->header.target_id,
+ cmd->frame->header.lun_id,
+ (unsigned long)lba_start, (unsigned long)lba_count);
+ if (!sdev) {
+ trace_megasas_io_target_not_present(cmd->index,
+ mfi_frame_desc[cmd->frame->header.frame_cmd],
+ cmd->frame->header.target_id, cmd->frame->header.lun_id);
+ return MFI_STAT_DEVICE_NOT_FOUND;
+ }
+
+ if (cmd->frame->header.cdb_len > 16) {
+ trace_megasas_scsi_invalid_cdb_len(
+ mfi_frame_desc[cmd->frame->header.frame_cmd], 1,
+ cmd->frame->header.target_id, cmd->frame->header.lun_id,
+ cmd->frame->header.cdb_len);
+ megasas_write_sense(cmd, SENSE_CODE(INVALID_OPCODE));
+ cmd->frame->header.scsi_status = CHECK_CONDITION;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+
+ cmd->iov_size = lba_count * sdev->blocksize;
+ if (megasas_map_sgl(s, cmd, &cmd->frame->io.sgl)) {
+ megasas_write_sense(cmd, SENSE_CODE(TARGET_FAILURE));
+ cmd->frame->header.scsi_status = CHECK_CONDITION;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+
+ megasas_encode_lba(cdb, lba_start, lba_count, is_write);
+ cmd->req = scsi_req_new(sdev, cmd->index,
+ cmd->frame->header.lun_id, cdb, cmd);
+ if (!cmd->req) {
+ trace_megasas_scsi_req_alloc_failed(
+ mfi_frame_desc[cmd->frame->header.frame_cmd],
+ cmd->frame->header.target_id, cmd->frame->header.lun_id);
+ megasas_write_sense(cmd, SENSE_CODE(NO_SENSE));
+ cmd->frame->header.scsi_status = BUSY;
+ s->event_count++;
+ return MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+ len = megasas_enqueue_req(cmd, is_write);
+ if (len > 0) {
+ if (is_write) {
+ trace_megasas_io_write_start(cmd->index, lba_start, lba_count, len);
+ } else {
+ trace_megasas_io_read_start(cmd->index, lba_start, lba_count, len);
+ }
+ }
+ return MFI_STAT_INVALID_STATUS;
+}
+
+static int megasas_finish_internal_command(MegasasCmd *cmd,
+ SCSIRequest *req, size_t resid)
+{
+ int retval = MFI_STAT_INVALID_CMD;
+
+ if (cmd->frame->header.frame_cmd == MFI_CMD_DCMD) {
+ cmd->iov_size -= resid;
+ retval = megasas_finish_internal_dcmd(cmd, req);
+ }
+ return retval;
+}
+
+static QEMUSGList *megasas_get_sg_list(SCSIRequest *req)
+{
+ MegasasCmd *cmd = req->hba_private;
+
+ if (cmd->frame->header.frame_cmd == MFI_CMD_DCMD) {
+ return NULL;
+ } else {
+ return &cmd->qsg;
+ }
+}
+
+static void megasas_xfer_complete(SCSIRequest *req, uint32_t len)
+{
+ MegasasCmd *cmd = req->hba_private;
+ uint8_t *buf;
+ uint32_t opcode;
+
+ trace_megasas_io_complete(cmd->index, len);
+
+ if (cmd->frame->header.frame_cmd != MFI_CMD_DCMD) {
+ scsi_req_continue(req);
+ return;
+ }
+
+ buf = scsi_req_get_buf(req);
+ opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
+ if (opcode == MFI_DCMD_PD_GET_INFO && cmd->iov_buf) {
+ struct mfi_pd_info *info = cmd->iov_buf;
+
+ if (info->inquiry_data[0] == 0x7f) {
+ memset(info->inquiry_data, 0, sizeof(info->inquiry_data));
+ memcpy(info->inquiry_data, buf, len);
+ } else if (info->vpd_page83[0] == 0x7f) {
+ memset(info->vpd_page83, 0, sizeof(info->vpd_page83));
+ memcpy(info->vpd_page83, buf, len);
+ }
+ scsi_req_continue(req);
+ } else if (opcode == MFI_DCMD_LD_GET_INFO) {
+ struct mfi_ld_info *info = cmd->iov_buf;
+
+ if (cmd->iov_buf) {
+ memcpy(info->vpd_page83, buf, sizeof(info->vpd_page83));
+ scsi_req_continue(req);
+ }
+ }
+}
+
+static void megasas_command_complete(SCSIRequest *req, uint32_t status,
+ size_t resid)
+{
+ MegasasCmd *cmd = req->hba_private;
+ uint8_t cmd_status = MFI_STAT_OK;
+
+ trace_megasas_command_complete(cmd->index, status, resid);
+
+ if (cmd->req != req) {
+ /*
+ * Internal command complete
+ */
+ cmd_status = megasas_finish_internal_command(cmd, req, resid);
+ if (cmd_status == MFI_STAT_INVALID_STATUS) {
+ return;
+ }
+ } else {
+ req->status = status;
+ trace_megasas_scsi_complete(cmd->index, req->status,
+ cmd->iov_size, req->cmd.xfer);
+ if (req->status != GOOD) {
+ cmd_status = MFI_STAT_SCSI_DONE_WITH_ERROR;
+ }
+ if (req->status == CHECK_CONDITION) {
+ megasas_copy_sense(cmd);
+ }
+
+ megasas_unmap_sgl(cmd);
+ cmd->frame->header.scsi_status = req->status;
+ scsi_req_unref(cmd->req);
+ cmd->req = NULL;
+ }
+ cmd->frame->header.cmd_status = cmd_status;
+ megasas_complete_frame(cmd->state, cmd->context);
+}
+
+static void megasas_command_cancel(SCSIRequest *req)
+{
+ MegasasCmd *cmd = req->hba_private;
+
+ if (cmd) {
+ megasas_abort_command(cmd);
+ } else {
+ scsi_req_unref(req);
+ }
+}
+
+static int megasas_handle_abort(MegasasState *s, MegasasCmd *cmd)
+{
+ uint64_t abort_ctx = le64_to_cpu(cmd->frame->abort.abort_context);
+ target_phys_addr_t abort_addr, addr_hi, addr_lo;
+ MegasasCmd *abort_cmd;
+
+ addr_hi = le32_to_cpu(cmd->frame->abort.abort_mfi_addr_hi);
+ addr_lo = le32_to_cpu(cmd->frame->abort.abort_mfi_addr_lo);
+ abort_addr = ((uint64_t)addr_hi << 32) | addr_lo;
+
+ abort_cmd = megasas_lookup_frame(s, abort_addr);
+ if (!abort_cmd) {
+ trace_megasas_abort_no_cmd(cmd->index, abort_ctx);
+ s->event_count++;
+ return MFI_STAT_OK;
+ }
+ if (!megasas_use_queue64(s)) {
+ abort_ctx &= (uint64_t)0xFFFFFFFF;
+ }
+ if (abort_cmd->context != abort_ctx) {
+ trace_megasas_abort_invalid_context(cmd->index, abort_cmd->index,
+ abort_cmd->context);
+ s->event_count++;
+ return MFI_STAT_ABORT_NOT_POSSIBLE;
+ }
+ trace_megasas_abort_frame(cmd->index, abort_cmd->index);
+ megasas_abort_command(abort_cmd);
+ if (!s->event_cmd || abort_cmd != s->event_cmd) {
+ s->event_cmd = NULL;
+ }
+ s->event_count++;
+ return MFI_STAT_OK;
+}
+
+static void megasas_handle_frame(MegasasState *s, uint64_t frame_addr,
+ uint32_t frame_count)
+{
+ uint8_t frame_status = MFI_STAT_INVALID_CMD;
+ uint64_t frame_context;
+ MegasasCmd *cmd;
+
+ /*
+ * Always read 64bit context, top bits will be
+ * masked out if required in megasas_enqueue_frame()
+ */
+ frame_context = megasas_frame_get_context(frame_addr);
+
+ cmd = megasas_enqueue_frame(s, frame_addr, frame_context, frame_count);
+ if (!cmd) {
+ /* reply queue full */
+ trace_megasas_frame_busy(frame_addr);
+ megasas_frame_set_scsi_status(frame_addr, BUSY);
+ megasas_frame_set_cmd_status(frame_addr, MFI_STAT_SCSI_DONE_WITH_ERROR);
+ megasas_complete_frame(s, frame_context);
+ s->event_count++;
+ return;
+ }
+ switch (cmd->frame->header.frame_cmd) {
+ case MFI_CMD_INIT:
+ frame_status = megasas_init_firmware(s, cmd);
+ break;
+ case MFI_CMD_DCMD:
+ frame_status = megasas_handle_dcmd(s, cmd);
+ break;
+ case MFI_CMD_ABORT:
+ frame_status = megasas_handle_abort(s, cmd);
+ break;
+ case MFI_CMD_PD_SCSI_IO:
+ frame_status = megasas_handle_scsi(s, cmd, 0);
+ break;
+ case MFI_CMD_LD_SCSI_IO:
+ frame_status = megasas_handle_scsi(s, cmd, 1);
+ break;
+ case MFI_CMD_LD_READ:
+ case MFI_CMD_LD_WRITE:
+ frame_status = megasas_handle_io(s, cmd);
+ break;
+ default:
+ trace_megasas_unhandled_frame_cmd(cmd->index,
+ cmd->frame->header.frame_cmd);
+ s->event_count++;
+ break;
+ }
+ if (frame_status != MFI_STAT_INVALID_STATUS) {
+ if (cmd->frame) {
+ cmd->frame->header.cmd_status = frame_status;
+ } else {
+ megasas_frame_set_cmd_status(frame_addr, frame_status);
+ }
+ megasas_complete_frame(s, cmd->context);
+ }
+}
+
+static uint64_t megasas_mmio_read(void *opaque, target_phys_addr_t addr,
+ unsigned size)
+{
+ MegasasState *s = opaque;
+ uint32_t retval = 0;
+
+ switch (addr) {
+ case MFI_IDB:
+ retval = 0;
+ break;
+ case MFI_OMSG0:
+ case MFI_OSP0:
+ retval = (megasas_use_msix(s) ? MFI_FWSTATE_MSIX_SUPPORTED : 0) |
+ (s->fw_state & MFI_FWSTATE_MASK) |
+ ((s->fw_sge & 0xff) << 16) |
+ (s->fw_cmds & 0xFFFF);
+ break;
+ case MFI_OSTS:
+ if (megasas_intr_enabled(s) && s->doorbell) {
+ retval = MFI_1078_RM | 1;
+ }
+ break;
+ case MFI_OMSK:
+ retval = s->intr_mask;
+ break;
+ case MFI_ODCR0:
+ retval = s->doorbell;
+ break;
+ default:
+ trace_megasas_mmio_invalid_readl(addr);
+ break;
+ }
+ trace_megasas_mmio_readl(addr, retval);
+ return retval;
+}
+
+static void megasas_mmio_write(void *opaque, target_phys_addr_t addr,
+ uint64_t val, unsigned size)
+{
+ MegasasState *s = opaque;
+ uint64_t frame_addr;
+ uint32_t frame_count;
+ int i;
+
+ trace_megasas_mmio_writel(addr, val);
+ switch (addr) {
+ case MFI_IDB:
+ if (val & MFI_FWINIT_ABORT) {
+ /* Abort all pending cmds */
+ for (i = 0; i < s->fw_cmds; i++) {
+ megasas_abort_command(&s->frames[i]);
+ }
+ }
+ if (val & MFI_FWINIT_READY) {
+ /* move to FW READY */
+ megasas_soft_reset(s);
+ }
+ if (val & MFI_FWINIT_MFIMODE) {
+ /* discard MFIs */
+ }
+ break;
+ case MFI_OMSK:
+ s->intr_mask = val;
+ if (!megasas_intr_enabled(s) && !msix_enabled(&s->dev)) {
+ trace_megasas_irq_lower();
+ qemu_irq_lower(s->dev.irq[0]);
+ }
+ if (megasas_intr_enabled(s)) {
+ trace_megasas_intr_enabled();
+ } else {
+ trace_megasas_intr_disabled();
+ }
+ break;
+ case MFI_ODCR0:
+ s->doorbell = 0;
+ if (s->producer_pa && megasas_intr_enabled(s)) {
+ /* Update reply queue pointer */
+ trace_megasas_qf_update(s->reply_queue_head, s->busy);
+ stl_le_phys(s->producer_pa, s->reply_queue_head);
+ if (!msix_enabled(&s->dev)) {
+ trace_megasas_irq_lower();
+ qemu_irq_lower(s->dev.irq[0]);
+ }
+ }
+ break;
+ case MFI_IQPH:
+ /* Received high 32 bits of a 64 bit MFI frame address */
+ s->frame_hi = val;
+ break;
+ case MFI_IQPL:
+ /* Received low 32 bits of a 64 bit MFI frame address */
+ case MFI_IQP:
+ /* Received 32 bit MFI frame address */
+ frame_addr = (val & ~0x1F);
+ /* Add possible 64 bit offset */
+ frame_addr |= ((uint64_t)s->frame_hi << 32);
+ s->frame_hi = 0;
+ frame_count = (val >> 1) & 0xF;
+ megasas_handle_frame(s, frame_addr, frame_count);
+ break;
+ default:
+ trace_megasas_mmio_invalid_writel(addr, val);
+ break;
+ }
+}
+
+static const MemoryRegionOps megasas_mmio_ops = {
+ .read = megasas_mmio_read,
+ .write = megasas_mmio_write,
+ .endianness = DEVICE_LITTLE_ENDIAN,
+ .impl = {
+ .min_access_size = 8,
+ .max_access_size = 8,
+ }
+};
+
+static uint64_t megasas_port_read(void *opaque, target_phys_addr_t addr,
+ unsigned size)
+{
+ return megasas_mmio_read(opaque, addr & 0xff, size);
+}
+
+static void megasas_port_write(void *opaque, target_phys_addr_t addr,
+ uint64_t val, unsigned size)
+{
+ megasas_mmio_write(opaque, addr & 0xff, val, size);
+}
+
+static const MemoryRegionOps megasas_port_ops = {
+ .read = megasas_port_read,
+ .write = megasas_port_write,
+ .endianness = DEVICE_LITTLE_ENDIAN,
+ .impl = {
+ .min_access_size = 4,
+ .max_access_size = 4,
+ }
+};
+
+static uint64_t megasas_queue_read(void *opaque, target_phys_addr_t addr,
+ unsigned size)
+{
+ return 0;
+}
+
+static const MemoryRegionOps megasas_queue_ops = {
+ .read = megasas_queue_read,
+ .endianness = DEVICE_LITTLE_ENDIAN,
+ .impl = {
+ .min_access_size = 8,
+ .max_access_size = 8,
+ }
+};
+
+static void megasas_soft_reset(MegasasState *s)
+{
+ int i;
+ MegasasCmd *cmd;
+
+ trace_megasas_reset();
+ for (i = 0; i < s->fw_cmds; i++) {
+ cmd = &s->frames[i];
+ megasas_abort_command(cmd);
+ }
+ megasas_reset_frames(s);
+ s->reply_queue_len = s->fw_cmds;
+ s->reply_queue_pa = 0;
+ s->consumer_pa = 0;
+ s->producer_pa = 0;
+ s->fw_state = MFI_FWSTATE_READY;
+ s->doorbell = 0;
+ s->intr_mask = MEGASAS_INTR_DISABLED_MASK;
+ s->frame_hi = 0;
+ s->flags &= ~MEGASAS_MASK_USE_QUEUE64;
+ s->event_count++;
+ s->boot_event = s->event_count;
+}
+
+static void megasas_scsi_reset(DeviceState *dev)
+{
+ MegasasState *s = DO_UPCAST(MegasasState, dev.qdev, dev);
+
+ megasas_soft_reset(s);
+}
+
+static const VMStateDescription vmstate_megasas = {
+ .name = "megasas",
+ .version_id = 0,
+ .minimum_version_id = 0,
+ .minimum_version_id_old = 0,
+ .fields = (VMStateField[]) {
+ VMSTATE_PCI_DEVICE(dev, MegasasState),
+
+ VMSTATE_INT32(fw_state, MegasasState),
+ VMSTATE_INT32(intr_mask, MegasasState),
+ VMSTATE_INT32(doorbell, MegasasState),
+ VMSTATE_UINT64(reply_queue_pa, MegasasState),
+ VMSTATE_UINT64(consumer_pa, MegasasState),
+ VMSTATE_UINT64(producer_pa, MegasasState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static int megasas_scsi_uninit(PCIDevice *d)
+{
+ MegasasState *s = DO_UPCAST(MegasasState, dev, d);
+
+#ifdef USE_MSIX
+ msix_uninit(&s->dev, &s->mmio_io);
+#endif
+ memory_region_destroy(&s->mmio_io);
+ memory_region_destroy(&s->port_io);
+ memory_region_destroy(&s->queue_io);
+ return 0;
+}
+
+static const struct SCSIBusInfo megasas_scsi_info = {
+ .tcq = true,
+ .max_target = MFI_MAX_LD,
+ .max_lun = 255,
+
+ .transfer_data = megasas_xfer_complete,
+ .get_sg_list = megasas_get_sg_list,
+ .complete = megasas_command_complete,
+ .cancel = megasas_command_cancel,
+};
+
+static int megasas_scsi_init(PCIDevice *dev)
+{
+ MegasasState *s = DO_UPCAST(MegasasState, dev, dev);
+ uint8_t *pci_conf;
+ int i, bar_type;
+
+ pci_conf = s->dev.config;
+
+ /* PCI latency timer = 0 */
+ pci_conf[PCI_LATENCY_TIMER] = 0;
+ /* Interrupt pin 1 */
+ pci_conf[PCI_INTERRUPT_PIN] = 0x01;
+
+ memory_region_init_io(&s->mmio_io, &megasas_mmio_ops, s,
+ "megasas-mmio", 0x4000);
+ memory_region_init_io(&s->port_io, &megasas_port_ops, s,
+ "megasas-io", 256);
+ memory_region_init_io(&s->queue_io, &megasas_queue_ops, s,
+ "megasas-queue", 0x40000);
+
+#ifdef USE_MSIX
+ /* MSI-X support is currently broken */
+ if (megasas_use_msix(s) &&
+ msix_init(&s->dev, 15, &s->mmio_io, 0, 0x2000)) {
+ s->flags &= ~MEGASAS_MASK_USE_MSIX;
+ }
+#else
+ s->flags &= ~MEGASAS_MASK_USE_MSIX;
+#endif
+
+ bar_type = PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64;
+ pci_register_bar(&s->dev, 0, bar_type, &s->mmio_io);
+ pci_register_bar(&s->dev, 2, PCI_BASE_ADDRESS_SPACE_IO, &s->port_io);
+ pci_register_bar(&s->dev, 3, bar_type, &s->queue_io);
+
+ if (megasas_use_msix(s)) {
+ msix_vector_use(&s->dev, 0);
+ }
+
+ if (s->fw_sge >= MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE) {
+ s->fw_sge = MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE;
+ } else if (s->fw_sge >= 128 - MFI_PASS_FRAME_SIZE) {
+ s->fw_sge = 128 - MFI_PASS_FRAME_SIZE;
+ } else {
+ s->fw_sge = 64 - MFI_PASS_FRAME_SIZE;
+ }
+ if (s->fw_cmds > MEGASAS_MAX_FRAMES) {
+ s->fw_cmds = MEGASAS_MAX_FRAMES;
+ }
+ trace_megasas_init(s->fw_sge, s->fw_cmds,
+ megasas_use_msix(s) ? "MSI-X" : "INTx",
+ megasas_is_jbod(s) ? "jbod" : "raid");
+ s->fw_luns = (MFI_MAX_LD > MAX_SCSI_DEVS) ?
+ MAX_SCSI_DEVS : MFI_MAX_LD;
+ s->producer_pa = 0;
+ s->consumer_pa = 0;
+ for (i = 0; i < s->fw_cmds; i++) {
+ s->frames[i].index = i;
+ s->frames[i].context = -1;
+ s->frames[i].pa = 0;
+ s->frames[i].state = s;
+ }
+
+ scsi_bus_new(&s->bus, &dev->qdev, &megasas_scsi_info);
+ scsi_bus_legacy_handle_cmdline(&s->bus);
+ return 0;
+}
+
+static Property megasas_properties[] = {
+ DEFINE_PROP_UINT32("max_sge", MegasasState, fw_sge,
+ MEGASAS_DEFAULT_SGE),
+ DEFINE_PROP_UINT32("max_cmds", MegasasState, fw_cmds,
+ MEGASAS_DEFAULT_FRAMES),
+#ifdef USE_MSIX
+ DEFINE_PROP_BIT("use_msix", MegasasState, flags,
+ MEGASAS_FLAG_USE_MSIX, false),
+#endif
+ DEFINE_PROP_BIT("use_jbod", MegasasState, flags,
+ MEGASAS_FLAG_USE_JBOD, false),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void megasas_class_init(ObjectClass *oc, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(oc);
+ PCIDeviceClass *pc = PCI_DEVICE_CLASS(oc);
+
+ pc->init = megasas_scsi_init;
+ pc->exit = megasas_scsi_uninit;
+ pc->vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
+ pc->device_id = PCI_DEVICE_ID_LSI_SAS1078;
+ pc->subsystem_vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
+ pc->subsystem_id = 0x1013;
+ pc->class_id = PCI_CLASS_STORAGE_RAID;
+ dc->props = megasas_properties;
+ dc->reset = megasas_scsi_reset;
+ dc->vmsd = &vmstate_megasas;
+ dc->desc = "LSI MegaRAID SAS 1078";
+}
+
+static const TypeInfo megasas_info = {
+ .name = "megasas",
+ .parent = TYPE_PCI_DEVICE,
+ .instance_size = sizeof(MegasasState),
+ .class_init = megasas_class_init,
+};
+
+static void megasas_register_types(void)
+{
+ type_register_static(&megasas_info);
+}
+
+type_init(megasas_register_types)
diff --git a/hw/pci_ids.h b/hw/pci_ids.h
index 649e6b3..b4801d2 100644
--- a/hw/pci_ids.h
+++ b/hw/pci_ids.h
@@ -15,6 +15,7 @@
#define PCI_CLASS_STORAGE_SCSI 0x0100
#define PCI_CLASS_STORAGE_IDE 0x0101
+#define PCI_CLASS_STORAGE_RAID 0x0104
#define PCI_CLASS_STORAGE_SATA 0x0106
#define PCI_CLASS_STORAGE_OTHER 0x0180
@@ -47,6 +48,7 @@
#define PCI_VENDOR_ID_LSI_LOGIC 0x1000
#define PCI_DEVICE_ID_LSI_53C895A 0x0012
+#define PCI_DEVICE_ID_LSI_SAS1078 0x0060
#define PCI_VENDOR_ID_DEC 0x1011
#define PCI_DEVICE_ID_DEC_21154 0x0026
diff --git a/trace-events b/trace-events
index c935ba2..bd0ca7e 100644
--- a/trace-events
+++ b/trace-events
@@ -512,6 +512,85 @@ lm32_uart_irq_state(int level) "irq state %d"
# hw/lm32_sys.c
lm32_sys_memory_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
+# hw/megasas.c
+megasas_init_firmware(uint64_t pa) "pa %" PRIx64 " "
+megasas_init_queue(uint64_t queue_pa, int queue_len, uint64_t head, uint64_t tail, uint32_t flags) "queue at %" PRIx64 " len %d head %" PRIx64 " tail %" PRIx64 " flags %x"
+megasas_initq_map_failed(int frame) "scmd %d: failed to map queue"
+megasas_initq_mismatch(int queue_len, int fw_cmds) "queue size %d max fw cmds %d"
+megasas_qf_found(unsigned int index, uint64_t pa) "found mapped frame %x pa %" PRIx64 ""
+megasas_qf_new(unsigned int index, void *cmd) "return new frame %x cmd %p"
+megasas_qf_failed(unsigned long pa) "all frames busy for frame %lx"
+megasas_qf_enqueue(unsigned int index, unsigned int count, uint64_t context, unsigned int tail, int busy) "enqueue frame %x count %d context %" PRIx64 " tail %x busy %d"
+megasas_qf_update(unsigned int head, unsigned int busy) "update reply queue head %x busy %d"
+megasas_qf_dequeue(unsigned int index) "dequeue frame %x"
+megasas_qf_map_failed(int cmd, unsigned long frame) "scmd %d: frame %lu"
+megasas_qf_complete_noirq(uint64_t context) "context %" PRIx64 " "
+megasas_qf_complete(uint64_t context, unsigned int tail, unsigned int offset, int busy, unsigned int doorbell) "context %" PRIx64 " tail %x offset %d busy %d doorbell %x"
+megasas_handle_frame(const char *cmd, uint64_t addr, uint64_t context, uint32_t count) "MFI cmd %s addr %" PRIx64 " context %" PRIx64 " count %d"
+megasas_frame_busy(uint64_t addr) "frame %" PRIx64 " busy"
+megasas_unhandled_frame_cmd(int cmd, uint8_t frame_cmd) "scmd %d: Unhandled MFI cmd %x"
+megasas_handle_scsi(const char *frame, int bus, int dev, int lun, void *sdev, unsigned long size) "%s dev %x/%x/%x sdev %p xfer %lu"
+megasas_scsi_target_not_present(const char *frame, int bus, int dev, int lun) "%s dev %x/%x/%x target not present"
+megasas_scsi_invalid_cdb_len(const char *frame, int bus, int dev, int lun, int len) "%s dev %x/%x/%x invalid cdb len %d"
+megasas_iov_read_overflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
+megasas_iov_write_overflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
+megasas_iov_read_underflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
+megasas_iov_write_underflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
+megasas_scsi_req_alloc_failed(const char *frame, int dev, int lun) "%s dev %x/%x req allocation failed"
+megasas_scsi_read_start(int cmd, int len) "scmd %d: transfer %d bytes of data"
+megasas_scsi_write_start(int cmd, int len) "scmd %d: transfer %d bytes of data"
+megasas_scsi_nodata(int cmd) "scmd %d: no data to be transferred"
+megasas_scsi_complete(int cmd, uint32_t status, int len, int xfer) "scmd %d: finished with status %x, len %u/%u"
+megasas_command_complete(int cmd, uint32_t status, uint32_t resid) "scmd %d: command completed, status %x, residual %d"
+megasas_handle_io(int cmd, const char *frame, int dev, int lun, unsigned long lba, unsigned long count) "scmd %d: %s dev %x/%x lba %lx count %lu"
+megasas_io_target_not_present(int cmd, const char *frame, int dev, int lun) "scmd %d: %s dev 1/%x/%x LUN not present"
+megasas_io_read_start(int cmd, unsigned long lba, unsigned long count, unsigned long len) "scmd %d: start LBA %lx %lu blocks (%lu bytes)"
+megasas_io_write_start(int cmd, unsigned long lba, unsigned long count, unsigned long len) "scmd %d: start LBA %lx %lu blocks (%lu bytes)"
+megasas_io_complete(int cmd, uint32_t len) "scmd %d: %d bytes completed"
+megasas_io_read(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu"
+megasas_io_write(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu"
+megasas_io_continue(int cmd, int bytes) "scmd %d: %d bytes left"
+megasas_iovec_map_failed(int cmd, int index, unsigned long iov_size) "scmd %d: iovec %d size %lu"
+megasas_iovec_sgl_overflow(int cmd, int index, int limit) "scmd %d: iovec count %d limit %d"
+megasas_iovec_sgl_underflow(int cmd, int index) "scmd %d: iovec count %d"
+megasas_iovec_sgl_invalid(int cmd, int index, uint64_t pa, uint32_t len) "scmd %d: element %d pa %" PRIx64 " len %u"
+megasas_iovec_overflow(int cmd, int len, int limit) "scmd %d: len %d limit %d"
+megasas_iovec_underflow(int cmd, int len, int limit) "scmd %d: len %d limit %d"
+megasas_handle_dcmd(int cmd, int opcode) "scmd %d: MFI DCMD opcode %x"
+megasas_finish_dcmd(int cmd, int size) "scmd %d: MFI DCMD wrote %d bytes"
+megasas_dcmd_req_alloc_failed(int cmd, const char *desc) "scmd %d: %s alloc failed"
+megasas_dcmd_internal_submit(int cmd, const char *desc, int dev) "scmd %d: %s to dev %d"
+megasas_dcmd_internal_finish(int cmd, int opcode, int lun) "scmd %d: DCMD finish internal cmd %x lun %d"
+megasas_dcmd_internal_invalid(int cmd, int opcode) "scmd %d: Invalid internal DCMD %x"
+megasas_dcmd_unhandled(int cmd, int opcode, int len) "scmd %d: opcode %x, len %d"
+megasas_dcmd_zero_sge(int cmd) "scmd %d: zero DCMD sge count"
+megasas_dcmd_invalid_sge(int cmd, int count) "scmd %d: invalid DCMD sge count %d"
+megasas_dcmd_map_failed(int cmd) "scmd %d: Failed to map DCMD buffer"
+megasas_dcmd_invalid_xfer_len(int cmd, unsigned long size, unsigned long max) "scmd %d: invalid xfer len %ld, max %ld"
+megasas_dcmd_enter(int cmd, const char *dcmd, int len) "scmd %d: DCMD %s len %d"
+megasas_dcmd_dummy(int cmd, unsigned long size) "scmd %d: DCMD dummy xfer len %ld"
+megasas_dcmd_set_fw_time(int cmd, unsigned long time) "scmd %d: Set FW time %lx"
+megasas_dcmd_pd_get_list(int cmd, int num, int max, int offset) "scmd %d: DCMD PD get list: %d / %d PDs, size %d"
+megasas_dcmd_ld_get_list(int cmd, int num, int max) "scmd %d: DCMD LD get list: found %d / %d LDs"
+megasas_dcmd_ld_get_info(int cmd, int ld_id) "scmd %d: DCMD LD get info for dev %d"
+megasas_dcmd_pd_get_info(int cmd, int pd_id) "scmd %d: DCMD PD get info for dev %d"
+megasas_dcmd_pd_list_query(int cmd, int flags) "scmd %d: DCMD PD list query flags %x"
+megasas_dcmd_dump_frame(int offset, char f0, char f1, char f2, char f3, char f4, char f5, char f6, char f7) "0x%x: %02x %02x %02x %02x %02x %02x %02x %02x"
+megasas_abort_frame(int cmd, int abort_cmd) "scmd %d: aborting frame %x"
+megasas_abort_no_cmd(int cmd, uint64_t context) "scmd %d: no active command for frame context %" PRIx64 ""
+megasas_abort_invalid_context(int cmd, uint64_t context, int abort_cmd) "scmd %d: invalid frame context %" PRIx64 " for abort frame %x"
+megasas_reset(void) "Reset"
+megasas_init(int sges, int cmds, const char *intr, const char *mode) "Using %d sges, %d cmds, %s, %s mode"
+megasas_msix_raise(int vector) "vector %d"
+megasas_irq_lower(void) "INTx"
+megasas_irq_raise(void) "INTx"
+megasas_intr_enabled(void) "Interrupts enabled"
+megasas_intr_disabled(void) "Interrupts disabled"
+megasas_mmio_readl(unsigned long addr, uint32_t val) "addr 0x%lx: 0x%x"
+megasas_mmio_invalid_readl(unsigned long addr) "addr 0x%lx"
+megasas_mmio_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x"
+megasas_mmio_invalid_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x"
+
# hw/milkymist-ac97.c
milkymist_ac97_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x"
milkymist_ac97_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x"
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 09/14] virtio-scsi: do not crash on adding buffers to the event queue
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (7 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 10/14] scsi: Fix data length == SCSI_SENSE_BUF_SIZE Paolo Bonzini
` (5 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel
The event queue is not supported yet and the handler does not
have to do much anyway when buffers are added. However, the
handler is called unconditionally by the virtio layer, and this
results in a crash as soon as buffers are added to the event
queue because we pass NULL.
Reported-by: Bryan Venteicher <bryanv@daemoninthecloset.org>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/virtio-scsi.c | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/hw/virtio-scsi.c b/hw/virtio-scsi.c
index e1a767e..0a5ac40 100644
--- a/hw/virtio-scsi.c
+++ b/hw/virtio-scsi.c
@@ -405,6 +405,10 @@ static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
}
}
+static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
+{
+}
+
static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status,
size_t resid)
{
@@ -609,7 +613,7 @@ VirtIODevice *virtio_scsi_init(DeviceState *dev, VirtIOSCSIConf *proxyconf)
s->ctrl_vq = virtio_add_queue(&s->vdev, VIRTIO_SCSI_VQ_SIZE,
virtio_scsi_handle_ctrl);
s->event_vq = virtio_add_queue(&s->vdev, VIRTIO_SCSI_VQ_SIZE,
- NULL);
+ virtio_scsi_handle_event);
for (i = 0; i < s->conf->num_queues; i++) {
s->cmd_vqs[i] = virtio_add_queue(&s->vdev, VIRTIO_SCSI_VQ_SIZE,
virtio_scsi_handle_cmd);
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 10/14] scsi: Fix data length == SCSI_SENSE_BUF_SIZE
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (8 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 09/14] virtio-scsi: do not crash on adding buffers to the event queue Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 11/14] scsi: Fix LOAD_UNLOAD Paolo Bonzini
` (4 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Christian Borntraeger, Christian Hoff
From: Christian Hoff <christian.hoff@de.ibm.com>
Fix the edge case where the sense data length is exactly the same
as SCSI_SENSE_BUF_SIZE.
This makes SCSI requests work that use all of the available 95 byte
sense data.
Signed-off-by: Christian Hoff <christian.hoff@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-bus.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c
index 14e2f73..4e95eee 100644
--- a/hw/scsi-bus.c
+++ b/hw/scsi-bus.c
@@ -1389,7 +1389,7 @@ void scsi_req_complete(SCSIRequest *req, int status)
assert(req->status == -1);
req->status = status;
- assert(req->sense_len < sizeof(req->sense));
+ assert(req->sense_len <= sizeof(req->sense));
if (status == GOOD) {
req->sense_len = 0;
}
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 11/14] scsi: Fix LOAD_UNLOAD
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (9 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 10/14] scsi: Fix data length == SCSI_SENSE_BUF_SIZE Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 12/14] scsi: Ensure command and transfer lengths are set for all SCSI devices Paolo Bonzini
` (3 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Christian Borntraeger, Christian Hoff
From: Christian Hoff <christian.hoff@de.ibm.com>
Change operation code of LOAD_UNLOAD command to 0x1b as described in
section 7.3 of the SCSI Stream Commands spec.
Signed-off-by: Christian Hoff <christian.hoff@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-bus.c | 6 +++---
hw/scsi-defs.h | 2 +-
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c
index 4e95eee..2d4429c 100644
--- a/hw/scsi-bus.c
+++ b/hw/scsi-bus.c
@@ -771,7 +771,6 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
case SYNCHRONIZE_CACHE_16:
case LOCATE_16:
case LOCK_UNLOCK_CACHE:
- case LOAD_UNLOAD:
case SET_CD_SPEED:
case SET_LIMITS:
case WRITE_LONG_10:
@@ -902,7 +901,7 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
}
break;
case REWIND:
- case START_STOP:
+ case LOAD_UNLOAD:
cmd->len = 6;
cmd->xfer = 0;
break;
@@ -1200,7 +1199,8 @@ static const char *scsi_command_name(uint8_t cmd)
[ COPY ] = "COPY",
[ ERASE ] = "ERASE",
[ MODE_SENSE ] = "MODE_SENSE",
- [ START_STOP ] = "START_STOP",
+ [ START_STOP ] = "START_STOP/LOAD_UNLOAD",
+ /* LOAD_UNLOAD and START_STOP use the same operation code */
[ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC",
[ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC",
[ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL",
diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h
index 3c9f1b5..6578bb9 100644
--- a/hw/scsi-defs.h
+++ b/hw/scsi-defs.h
@@ -44,6 +44,7 @@
#define COPY 0x18
#define ERASE 0x19
#define MODE_SENSE 0x1a
+#define LOAD_UNLOAD 0x1b
#define START_STOP 0x1b
#define RECEIVE_DIAGNOSTIC 0x1c
#define SEND_DIAGNOSTIC 0x1d
@@ -117,7 +118,6 @@
#define MAINTENANCE_IN 0xa3
#define MAINTENANCE_OUT 0xa4
#define MOVE_MEDIUM 0xa5
-#define LOAD_UNLOAD 0xa6
#define SET_READ_AHEAD 0xa7
#define READ_12 0xa8
#define WRITE_12 0xaa
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 12/14] scsi: Ensure command and transfer lengths are set for all SCSI devices
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (10 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 11/14] scsi: Fix LOAD_UNLOAD Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 13/14] scsi: Add basic support for SCSI media changer commands Paolo Bonzini
` (2 subsequent siblings)
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel
scsi-generic relies on those values to be correct, so it is important that
those values are initialized properly for all device types.
Reported-by: Christian Hoff <christian.hoff@de.ibm.com>
Reported-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-bus.c | 25 ++++++++++++++++++-------
1 file changed, 18 insertions(+), 7 deletions(-)
diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c
index 2d4429c..4ec9b52 100644
--- a/hw/scsi-bus.c
+++ b/hw/scsi-bus.c
@@ -734,20 +734,16 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
switch (buf[0] >> 5) {
case 0:
cmd->xfer = buf[4];
- cmd->len = 6;
break;
case 1:
case 2:
cmd->xfer = lduw_be_p(&buf[7]);
- cmd->len = 10;
break;
case 4:
cmd->xfer = ldl_be_p(&buf[10]) & 0xffffffffULL;
- cmd->len = 16;
break;
case 5:
cmd->xfer = ldl_be_p(&buf[6]) & 0xffffffffULL;
- cmd->len = 12;
break;
default:
return -1;
@@ -884,7 +880,6 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
case READ_REVERSE:
case RECOVER_BUFFERED_DATA:
case WRITE_6:
- cmd->len = 6;
cmd->xfer = buf[4] | (buf[3] << 8) | (buf[2] << 16);
if (buf[1] & 0x01) { /* fixed */
cmd->xfer *= dev->blocksize;
@@ -894,7 +889,6 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
case READ_REVERSE_16:
case VERIFY_16:
case WRITE_16:
- cmd->len = 16;
cmd->xfer = buf[14] | (buf[13] << 8) | (buf[12] << 16);
if (buf[1] & 0x01) { /* fixed */
cmd->xfer *= dev->blocksize;
@@ -902,7 +896,6 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
break;
case REWIND:
case LOAD_UNLOAD:
- cmd->len = 6;
cmd->xfer = 0;
break;
case SPACE_16:
@@ -1000,6 +993,24 @@ int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
{
int rc;
+ switch (buf[0] >> 5) {
+ case 0:
+ cmd->len = 6;
+ break;
+ case 1:
+ case 2:
+ cmd->len = 10;
+ break;
+ case 4:
+ cmd->len = 16;
+ break;
+ case 5:
+ cmd->len = 12;
+ break;
+ default:
+ return -1;
+ }
+
if (dev->type == TYPE_TAPE) {
rc = scsi_req_stream_length(cmd, dev, buf);
} else {
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 13/14] scsi: Add basic support for SCSI media changer commands.
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (11 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 12/14] scsi: Ensure command and transfer lengths are set for all SCSI devices Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 14/14] scsi: Fix transfer length for READ POSITION commands Paolo Bonzini
2012-07-09 16:48 ` [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Anthony Liguori
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Christian Borntraeger, Christian Hoff
From: Christian Hoff <christian.hoff@de.ibm.com>
This adds basic support for SCSI media changer commands.
Not all commands are supported as of now, but enough to cover
basic functionality.
Signed-off-by: Christian Hoff <christian.hoff@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-bus.c | 45 +++++++++++++++++++++++++++++++++++++++------
hw/scsi-defs.h | 4 ++++
2 files changed, 43 insertions(+), 6 deletions(-)
diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c
index 4ec9b52..9c64e30 100644
--- a/hw/scsi-bus.c
+++ b/hw/scsi-bus.c
@@ -770,7 +770,6 @@ static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
case SET_CD_SPEED:
case SET_LIMITS:
case WRITE_LONG_10:
- case MOVE_MEDIUM:
case UPDATE_BLOCK:
case RESERVE_TRACK:
case SET_READ_AHEAD:
@@ -914,6 +913,29 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
return 0;
}
+static int scsi_req_medium_changer_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
+{
+ switch (buf[0]) {
+ /* medium changer commands */
+ case EXCHANGE_MEDIUM:
+ case INITIALIZE_ELEMENT_STATUS:
+ case INITIALIZE_ELEMENT_STATUS_WITH_RANGE:
+ case MOVE_MEDIUM:
+ case POSITION_TO_ELEMENT:
+ cmd->xfer = 0;
+ break;
+ case READ_ELEMENT_STATUS:
+ cmd->xfer = buf[9] | (buf[8] << 8) | (buf[7] << 16);
+ break;
+
+ /* generic commands */
+ default:
+ return scsi_req_length(cmd, dev, buf);
+ }
+ return 0;
+}
+
+
static void scsi_cmd_xfer_mode(SCSICommand *cmd)
{
if (!cmd->xfer) {
@@ -1011,11 +1033,18 @@ int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)
return -1;
}
- if (dev->type == TYPE_TAPE) {
+ switch (dev->type) {
+ case TYPE_TAPE:
rc = scsi_req_stream_length(cmd, dev, buf);
- } else {
+ break;
+ case TYPE_MEDIUM_CHANGER:
+ rc = scsi_req_medium_changer_length(cmd, dev, buf);
+ break;
+ default:
rc = scsi_req_length(cmd, dev, buf);
+ break;
}
+
if (rc != 0)
return rc;
@@ -1193,7 +1222,8 @@ static const char *scsi_command_name(uint8_t cmd)
[ REQUEST_SENSE ] = "REQUEST_SENSE",
[ FORMAT_UNIT ] = "FORMAT_UNIT",
[ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS",
- [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS",
+ [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS/INITIALIZE ELEMENT STATUS",
+ /* LOAD_UNLOAD and INITIALIZE_ELEMENT_STATUS use the same operation code */
[ READ_6 ] = "READ_6",
[ WRITE_6 ] = "WRITE_6",
[ SET_CAPACITY ] = "SET_CAPACITY",
@@ -1218,7 +1248,8 @@ static const char *scsi_command_name(uint8_t cmd)
[ READ_CAPACITY_10 ] = "READ_CAPACITY_10",
[ READ_10 ] = "READ_10",
[ WRITE_10 ] = "WRITE_10",
- [ SEEK_10 ] = "SEEK_10",
+ [ SEEK_10 ] = "SEEK_10/POSITION_TO_ELEMENT",
+ /* SEEK_10 and POSITION_TO_ELEMENT use the same operation code */
[ WRITE_VERIFY_10 ] = "WRITE_VERIFY_10",
[ VERIFY_10 ] = "VERIFY_10",
[ SEARCH_HIGH ] = "SEARCH_HIGH",
@@ -1229,7 +1260,8 @@ static const char *scsi_command_name(uint8_t cmd)
/* READ_POSITION and PRE_FETCH use the same operation code */
[ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE",
[ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE",
- [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA",
+ [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA/INITIALIZE_ELEMENT_STATUS_WITH_RANGE",
+ /* READ_DEFECT_DATA and INITIALIZE_ELEMENT_STATUS_WITH_RANGE use the same operation code */
[ MEDIUM_SCAN ] = "MEDIUM_SCAN",
[ COMPARE ] = "COMPARE",
[ COPY_VERIFY ] = "COPY_VERIFY",
@@ -1274,6 +1306,7 @@ static const char *scsi_command_name(uint8_t cmd)
[ REPORT_LUNS ] = "REPORT_LUNS",
[ BLANK ] = "BLANK",
[ MOVE_MEDIUM ] = "MOVE_MEDIUM",
+ [ EXCHANGE_MEDIUM ] = "EXCHANGE MEDIUM",
[ LOAD_UNLOAD ] = "LOAD_UNLOAD",
[ READ_12 ] = "READ_12",
[ WRITE_12 ] = "WRITE_12",
diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h
index 6578bb9..ade82a4 100644
--- a/hw/scsi-defs.h
+++ b/hw/scsi-defs.h
@@ -29,6 +29,7 @@
#define REQUEST_SENSE 0x03
#define FORMAT_UNIT 0x04
#define READ_BLOCK_LIMITS 0x05
+#define INITIALIZE_ELEMENT_STATUS 0x07
#define REASSIGN_BLOCKS 0x07
#define READ_6 0x08
#define WRITE_6 0x0a
@@ -54,6 +55,7 @@
#define WRITE_10 0x2a
#define SEEK_10 0x2b
#define LOCATE_10 0x2b
+#define POSITION_TO_ELEMENT 0x2b
#define WRITE_VERIFY_10 0x2e
#define VERIFY_10 0x2f
#define SEARCH_HIGH 0x30
@@ -64,6 +66,7 @@
#define READ_POSITION 0x34
#define SYNCHRONIZE_CACHE 0x35
#define LOCK_UNLOCK_CACHE 0x36
+#define INITIALIZE_ELEMENT_STATUS_WITH_RANGE 0x37
#define READ_DEFECT_DATA 0x37
#define MEDIUM_SCAN 0x38
#define COMPARE 0x39
@@ -118,6 +121,7 @@
#define MAINTENANCE_IN 0xa3
#define MAINTENANCE_OUT 0xa4
#define MOVE_MEDIUM 0xa5
+#define EXCHANGE_MEDIUM 0xa6
#define SET_READ_AHEAD 0xa7
#define READ_12 0xa8
#define WRITE_12 0xaa
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH 14/14] scsi: Fix transfer length for READ POSITION commands.
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (12 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 13/14] scsi: Add basic support for SCSI media changer commands Paolo Bonzini
@ 2012-07-02 9:41 ` Paolo Bonzini
2012-07-09 16:48 ` [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Anthony Liguori
14 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-02 9:41 UTC (permalink / raw)
To: qemu-devel; +Cc: Christian Borntraeger, Christian Hoff
From: Christian Hoff <christian.hoff@de.ibm.com>
The transfer length depends on the specific service action
code, as defined in the SCSI stream commands spec section 7.7.
Up to now only the extended form was supported.
Signed-off-by: Christian Hoff <christian.hoff@de.ibm.com>
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
hw/scsi-bus.c | 16 +++++++++++++++-
hw/scsi-defs.h | 8 ++++++++
2 files changed, 23 insertions(+), 1 deletion(-)
diff --git a/hw/scsi-bus.c b/hw/scsi-bus.c
index 9c64e30..5ad1013 100644
--- a/hw/scsi-bus.c
+++ b/hw/scsi-bus.c
@@ -901,7 +901,21 @@ static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *bu
cmd->xfer = buf[13] | (buf[12] << 8);
break;
case READ_POSITION:
- cmd->xfer = buf[8] | (buf[7] << 8);
+ switch (buf[1] & 0x1f) /* operation code */ {
+ case SHORT_FORM_BLOCK_ID:
+ case SHORT_FORM_VENDOR_SPECIFIC:
+ cmd->xfer = 20;
+ break;
+ case LONG_FORM:
+ cmd->xfer = 32;
+ break;
+ case EXTENDED_FORM:
+ cmd->xfer = buf[8] | (buf[7] << 8);
+ break;
+ default:
+ return -1;
+ }
+
break;
case FORMAT_UNIT:
cmd->xfer = buf[4] | (buf[3] << 8);
diff --git a/hw/scsi-defs.h b/hw/scsi-defs.h
index ade82a4..8a73f74 100644
--- a/hw/scsi-defs.h
+++ b/hw/scsi-defs.h
@@ -147,6 +147,14 @@
#define SAI_READ_CAPACITY_16 0x10
/*
+ * READ POSITION service action codes
+ */
+#define SHORT_FORM_BLOCK_ID 0x00
+#define SHORT_FORM_VENDOR_SPECIFIC 0x01
+#define LONG_FORM 0x06
+#define EXTENDED_FORM 0x08
+
+/*
* SAM Status codes
*/
--
1.7.10.2
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation
2012-07-02 9:41 ` [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation Paolo Bonzini
@ 2012-07-03 19:09 ` Blue Swirl
2012-07-04 5:52 ` Hannes Reinecke
0 siblings, 1 reply; 32+ messages in thread
From: Blue Swirl @ 2012-07-03 19:09 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: qemu-devel, Hannes Reinecke
On Mon, Jul 2, 2012 at 9:41 AM, Paolo Bonzini <pbonzini@redhat.com> wrote:
> From: Hannes Reinecke <hare@suse.de>
>
> This patch adds an emulation for the LSI Megaraid SAS 8708EM2 HBA.
> I've tested it to work with Linux, Windows Vista, and Windows7.
>
> Signed-off-by: Hannes Reinecke <hare@suse.de>
> [ Squashed tracing patch (no need to keep it separate) and trivial changes
> from Andreas Faerber. Rebased over IOMMU and QBus changes. - Paolo ]
> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
> ---
> default-configs/pci.mak | 1 +
> hw/Makefile.objs | 1 +
> hw/megasas.c | 2198 +++++++++++++++++++++++++++++++++++++++++++++++
> hw/pci_ids.h | 2 +
> trace-events | 79 ++
> 5 files changed, 2281 insertions(+)
> create mode 100644 hw/megasas.c
>
> diff --git a/default-configs/pci.mak b/default-configs/pci.mak
> index 9d3e1db..4b49c00 100644
> --- a/default-configs/pci.mak
> +++ b/default-configs/pci.mak
> @@ -10,6 +10,7 @@ CONFIG_EEPRO100_PCI=y
> CONFIG_PCNET_PCI=y
> CONFIG_PCNET_COMMON=y
> CONFIG_LSI_SCSI_PCI=y
> +CONFIG_MEGASAS_SCSI_PCI=y
> CONFIG_RTL8139_PCI=y
> CONFIG_E1000_PCI=y
> CONFIG_IDE_CORE=y
> diff --git a/hw/Makefile.objs b/hw/Makefile.objs
> index 3d77259..9a350de 100644
> --- a/hw/Makefile.objs
> +++ b/hw/Makefile.objs
> @@ -86,6 +86,7 @@ hw-obj-$(CONFIG_OPENCORES_ETH) += opencores_eth.o
>
> # SCSI layer
> hw-obj-$(CONFIG_LSI_SCSI_PCI) += lsi53c895a.o
> +hw-obj-$(CONFIG_MEGASAS_SCSI_PCI) += megasas.o
> hw-obj-$(CONFIG_ESP) += esp.o
>
> hw-obj-y += sysbus.o isa-bus.o
> diff --git a/hw/megasas.c b/hw/megasas.c
> new file mode 100644
> index 0000000..b48836f
> --- /dev/null
> +++ b/hw/megasas.c
> @@ -0,0 +1,2198 @@
> +/*
> + * QEMU MegaRAID SAS 8708EM2 Host Bus Adapter emulation
> + * Based on the linux driver code at drivers/scsi/megaraid
> + *
> + * Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs
> + *
> + * This library is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU Lesser General Public
> + * License as published by the Free Software Foundation; either
> + * version 2 of the License, or (at your option) any later version.
> + *
> + * This library is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * Lesser General Public License for more details.
> + *
> + * You should have received a copy of the GNU Lesser General Public
> + * License along with this library; if not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include "hw.h"
> +#include "pci.h"
> +#include "dma.h"
> +#include "msix.h"
> +#include "iov.h"
> +#include "scsi.h"
> +#include "scsi-defs.h"
> +#include "block_int.h"
> +#include "trace.h"
> +
> +#include "mfi.h"
A pointer to chip set docs would be nice.
> +
> +#define MEGASAS_VERSION "1.70"
> +#define MEGASAS_MAX_FRAMES 2048 /* Firmware limit at 65535 */
> +#define MEGASAS_DEFAULT_FRAMES 1000 /* Windows requires this */
> +#define MEGASAS_MAX_SGE 128 /* Firmware limit */
> +#define MEGASAS_DEFAULT_SGE 80
> +#define MEGASAS_MAX_SECTORS 0xFFFF /* No real limit */
> +#define MEGASAS_MAX_ARRAYS 128
> +
> +#define MEGASAS_FLAG_USE_JBOD 0
> +#define MEGASAS_MASK_USE_JBOD (1 << MEGASAS_FLAG_USE_JBOD)
> +#define MEGASAS_FLAG_USE_MSIX 1
> +#define MEGASAS_MASK_USE_MSIX (1 << MEGASAS_FLAG_USE_MSIX)
> +#define MEGASAS_FLAG_USE_QUEUE64 2
> +#define MEGASAS_MASK_USE_QUEUE64 (1 << MEGASAS_FLAG_USE_QUEUE64)
> +
> +const char *mfi_frame_desc[] = {
Missing 'static'.
> + "MFI init", "LD Read", "LD Write", "LD SCSI", "PD SCSI",
> + "MFI Doorbell", "MFI Abort", "MFI SMP", "MFI Stop"};
> +
> +typedef struct MegasasCmd {
> + uint32_t index;
> + uint16_t flags;
> + uint16_t count;
> + uint64_t context;
> +
> + target_phys_addr_t pa;
> + target_phys_addr_t pa_size;
> + union mfi_frame *frame;
> + SCSIRequest *req;
> + QEMUSGList qsg;
> + void *iov_buf;
> + size_t iov_size;
> + size_t iov_offset;
> + struct MegasasState *state;
> +} MegasasCmd;
> +
> +typedef struct MegasasState {
> + PCIDevice dev;
> + MemoryRegion mmio_io;
> + MemoryRegion port_io;
> + MemoryRegion queue_io;
> + uint32_t frame_hi;
> +
> + int fw_state;
> + uint32_t fw_sge;
> + uint32_t fw_cmds;
> + uint32_t flags;
> + int fw_luns;
> + int intr_mask;
> + int doorbell;
> + int busy;
> +
> + MegasasCmd *event_cmd;
> + int event_locale;
> + int event_class;
> + int event_count;
> + int shutdown_event;
> + int boot_event;
> +
> + uint64_t reply_queue_pa;
> + void *reply_queue;
> + int reply_queue_len;
> + int reply_queue_head;
> + int reply_queue_tail;
> + uint64_t consumer_pa;
> + uint64_t producer_pa;
> +
> + MegasasCmd frames[MEGASAS_MAX_FRAMES];
> +
> + SCSIBus bus;
> +} MegasasState;
> +
> +#define MEGASAS_INTR_DISABLED_MASK 0xFFFFFFFF
> +
> +static bool megasas_intr_enabled(MegasasState *s)
> +{
> + if ((s->intr_mask & MEGASAS_INTR_DISABLED_MASK) !=
> + MEGASAS_INTR_DISABLED_MASK) {
> + return true;
> + }
> + return false;
> +}
> +
> +static bool megasas_use_queue64(MegasasState *s)
> +{
> + return s->flags & MEGASAS_MASK_USE_QUEUE64;
> +}
> +
> +static bool megasas_use_msix(MegasasState *s)
> +{
> + return s->flags & MEGASAS_MASK_USE_MSIX;
> +}
> +
> +static bool megasas_is_jbod(MegasasState *s)
> +{
> + return s->flags & MEGASAS_MASK_USE_JBOD;
> +}
> +
> +static void megasas_frame_set_cmd_status(unsigned long frame, uint8_t v)
> +{
> + stb_phys(frame + offsetof(struct mfi_frame_header, cmd_status), v);
> +}
> +
> +static void megasas_frame_set_scsi_status(unsigned long frame, uint8_t v)
> +{
> + stb_phys(frame + offsetof(struct mfi_frame_header, scsi_status), v);
> +}
> +
> +/*
> + * Context is considered opaque, but the HBA firmware is running
> + * in little endian mode. So convert it to little endian, too.
> + */
> +static uint64_t megasas_frame_get_context(unsigned long frame)
> +{
> + return ldq_le_phys(frame + offsetof(struct mfi_frame_header, context));
> +}
> +
> +static bool megasas_frame_is_ieee_sgl(MegasasCmd *cmd)
> +{
> + return cmd->flags & MFI_FRAME_IEEE_SGL;
> +}
> +
> +static bool megasas_frame_is_sgl64(MegasasCmd *cmd)
> +{
> + return cmd->flags & MFI_FRAME_SGL64;
> +}
> +
> +static bool megasas_frame_is_sense64(MegasasCmd *cmd)
> +{
> + return cmd->flags & MFI_FRAME_SENSE64;
> +}
> +
> +static uint64_t megasas_sgl_get_addr(MegasasCmd *cmd,
> + union mfi_sgl *sgl)
> +{
> + uint64_t addr;
> +
> + if (megasas_frame_is_ieee_sgl(cmd)) {
> + addr = le64_to_cpu(sgl->sg_skinny->addr);
> + } else if (megasas_frame_is_sgl64(cmd)) {
> + addr = le64_to_cpu(sgl->sg64->addr);
> + } else {
> + addr = le32_to_cpu(sgl->sg32->addr);
> + }
> + return addr;
> +}
> +
> +static uint32_t megasas_sgl_get_len(MegasasCmd *cmd,
> + union mfi_sgl *sgl)
> +{
> + uint32_t len;
> +
> + if (megasas_frame_is_ieee_sgl(cmd)) {
> + len = le32_to_cpu(sgl->sg_skinny->len);
> + } else if (megasas_frame_is_sgl64(cmd)) {
> + len = le32_to_cpu(sgl->sg64->len);
> + } else {
> + len = le32_to_cpu(sgl->sg32->len);
> + }
> + return len;
> +}
> +
> +static union mfi_sgl *megasas_sgl_next(MegasasCmd *cmd,
> + union mfi_sgl *sgl)
> +{
> + uint8_t *next = (uint8_t *)sgl;
> +
> + if (megasas_frame_is_ieee_sgl(cmd)) {
> + next += sizeof(struct mfi_sg_skinny);
> + } else if (megasas_frame_is_sgl64(cmd)) {
> + next += sizeof(struct mfi_sg64);
> + } else {
> + next += sizeof(struct mfi_sg32);
> + }
> +
> + if (next >= (uint8_t *)cmd->frame + cmd->pa_size) {
> + return NULL;
> + }
> + return (union mfi_sgl *)next;
> +}
> +
> +static void megasas_soft_reset(MegasasState *s);
> +
> +static int megasas_map_sgl(MegasasState *s, MegasasCmd *cmd, union mfi_sgl *sgl)
> +{
> + int i;
> + int iov_count = 0;
> + size_t iov_size = 0;
> +
> + cmd->flags = le16_to_cpu(cmd->frame->header.flags);
> + iov_count = cmd->frame->header.sge_count;
> + if (iov_count > MEGASAS_MAX_SGE) {
> + trace_megasas_iovec_sgl_overflow(cmd->index, iov_count,
> + MEGASAS_MAX_SGE);
> + return iov_count;
> + }
> + qemu_sglist_init(&cmd->qsg, iov_count, pci_dma_context(&s->dev));
> + for (i = 0; i < iov_count; i++) {
> + dma_addr_t iov_pa, iov_size_p;
> +
> + if (!sgl) {
> + trace_megasas_iovec_sgl_underflow(cmd->index, i);
> + goto unmap;
> + }
> + iov_pa = megasas_sgl_get_addr(cmd, sgl);
> + iov_size_p = megasas_sgl_get_len(cmd, sgl);
> + if (!iov_pa || !iov_size_p) {
> + trace_megasas_iovec_sgl_invalid(cmd->index, i,
> + iov_pa, iov_size_p);
> + goto unmap;
> + }
> + qemu_sglist_add(&cmd->qsg, iov_pa, iov_size_p);
> + sgl = megasas_sgl_next(cmd, sgl);
> + iov_size += (size_t)iov_size_p;
> + }
> + if (cmd->iov_size > iov_size) {
> + trace_megasas_iovec_overflow(cmd->index, iov_size, cmd->iov_size);
> + } else if (cmd->iov_size < iov_size) {
> + trace_megasas_iovec_underflow(cmd->iov_size, iov_size, cmd->iov_size);
> + }
> + cmd->iov_offset = 0;
> + return 0;
> +unmap:
> + qemu_sglist_destroy(&cmd->qsg);
> + return iov_count - i;
> +}
> +
> +static void megasas_unmap_sgl(MegasasCmd *cmd)
> +{
> + qemu_sglist_destroy(&cmd->qsg);
> + cmd->iov_offset = 0;
> +}
> +
> +/*
> + * passthrough sense and io sense are at the same offset
> + */
> +static int megasas_build_sense(MegasasCmd *cmd, uint8_t *sense_ptr,
> + uint8_t sense_len)
> +{
> + uint32_t pa_hi = 0, pa_lo;
> + target_phys_addr_t pa;
> +
> + if (sense_len > cmd->frame->header.sense_len) {
> + sense_len = cmd->frame->header.sense_len;
> + }
> + if (sense_len) {
> + pa_lo = le32_to_cpu(cmd->frame->pass.sense_addr_lo);
> + if (megasas_frame_is_sense64(cmd)) {
> + pa_hi = le32_to_cpu(cmd->frame->pass.sense_addr_hi);
> + }
> + pa = ((uint64_t) pa_hi << 32) | pa_lo;
> + cpu_physical_memory_write(pa, sense_ptr, sense_len);
> + cmd->frame->header.sense_len = sense_len;
> + }
> + return sense_len;
> +}
> +
> +static void megasas_write_sense(MegasasCmd *cmd, SCSISense sense)
> +{
> + uint8_t sense_buf[SCSI_SENSE_BUF_SIZE];
> + uint8_t sense_len = 18;
> +
> + memset(sense_buf, 0, sense_len);
> + sense_buf[0] = 0xf0;
> + sense_buf[2] = sense.key;
> + sense_buf[7] = 10;
> + sense_buf[12] = sense.asc;
> + sense_buf[13] = sense.ascq;
> + megasas_build_sense(cmd, sense_buf, sense_len);
> +}
> +
> +static void megasas_copy_sense(MegasasCmd *cmd)
> +{
> + uint8_t sense_buf[SCSI_SENSE_BUF_SIZE];
> + uint8_t sense_len;
> +
> + sense_len = scsi_req_get_sense(cmd->req, sense_buf,
> + SCSI_SENSE_BUF_SIZE);
> + megasas_build_sense(cmd, sense_buf, sense_len);
> +}
> +
> +/*
> + * Format an INQUIRY CDB
> + */
> +static int megasas_setup_inquiry(uint8_t *cdb, int pg, int len)
> +{
> + memset(cdb, 0, 6);
> + cdb[0] = INQUIRY;
> + if (pg > 0) {
> + cdb[1] = 0x1;
> + cdb[2] = pg;
> + }
> + cdb[3] = (len >> 8) & 0xff;
> + cdb[4] = (len & 0xff);
> + return len;
> +}
> +
> +/*
> + * Encode lba and len into a READ_16/WRITE_16 CDB
> + */
> +static void megasas_encode_lba(uint8_t *cdb, uint64_t lba,
> + uint32_t len, bool is_write)
> +{
> + memset(cdb, 0x0, 16);
> + if (is_write) {
> + cdb[0] = WRITE_16;
> + } else {
> + cdb[0] = READ_16;
> + }
> + cdb[2] = (lba >> 56) & 0xff;
> + cdb[3] = (lba >> 48) & 0xff;
> + cdb[4] = (lba >> 40) & 0xff;
> + cdb[5] = (lba >> 32) & 0xff;
> + cdb[6] = (lba >> 24) & 0xff;
> + cdb[7] = (lba >> 16) & 0xff;
> + cdb[8] = (lba >> 8) & 0xff;
> + cdb[9] = (lba) & 0xff;
> + cdb[10] = (len >> 24) & 0xff;
> + cdb[11] = (len >> 16) & 0xff;
> + cdb[12] = (len >> 8) & 0xff;
> + cdb[13] = (len) & 0xff;
> +}
> +
> +/*
> + * Utility functions
> + */
> +static uint64_t megasas_fw_time(void)
> +{
> + struct tm curtime;
> + uint64_t bcd_time;
> +
> + qemu_get_timedate(&curtime, 0);
> + bcd_time = ((uint64_t)curtime.tm_sec & 0xff) << 48 |
> + ((uint64_t)curtime.tm_min & 0xff) << 40 |
> + ((uint64_t)curtime.tm_hour & 0xff) << 32 |
> + ((uint64_t)curtime.tm_mday & 0xff) << 24 |
> + ((uint64_t)curtime.tm_mon & 0xff) << 16 |
> + ((uint64_t)(curtime.tm_year + 1900) & 0xffff);
> +
> + return bcd_time;
> +}
> +
> +static uint64_t megasas_gen_sas_addr(uint64_t id)
> +{
> + uint64_t addr;
> +
> + addr = 0x5001a4aULL << 36;
> + addr |= id & 0xfffffffff;
> +
> + return addr;
> +}
> +
> +/*
> + * Frame handling
> + */
> +static int megasas_next_index(MegasasState *s, int index, int limit)
> +{
> + index++;
> + if (index == limit) {
> + index = 0;
> + }
> + return index;
> +}
> +
> +static MegasasCmd *megasas_lookup_frame(MegasasState *s,
> + target_phys_addr_t frame)
> +{
> + MegasasCmd *cmd = NULL;
> + int num = 0, index;
> +
> + index = s->reply_queue_head;
> +
> + while (num < s->fw_cmds) {
> + if (s->frames[index].pa && s->frames[index].pa == frame) {
> + cmd = &s->frames[index];
> + break;
> + }
> + index = megasas_next_index(s, index, s->fw_cmds);
> + num++;
> + }
> +
> + return cmd;
> +}
> +
> +static MegasasCmd *megasas_next_frame(MegasasState *s,
> + target_phys_addr_t frame)
> +{
> + MegasasCmd *cmd = NULL;
> + int num = 0, index;
> +
> + cmd = megasas_lookup_frame(s, frame);
> + if (cmd) {
> + trace_megasas_qf_found(cmd->index, cmd->pa);
> + return cmd;
> + }
> + index = s->reply_queue_head;
> + num = 0;
> + while (num < s->fw_cmds) {
> + if (!s->frames[index].pa) {
> + cmd = &s->frames[index];
> + break;
> + }
> + index = megasas_next_index(s, index, s->fw_cmds);
> + num++;
> + }
> + if (!cmd) {
> + trace_megasas_qf_failed(frame);
> + }
> + trace_megasas_qf_new(index, cmd);
> + return cmd;
> +}
> +
> +static MegasasCmd *megasas_enqueue_frame(MegasasState *s,
> + target_phys_addr_t frame, uint64_t context, int count)
> +{
> + MegasasCmd *cmd = NULL;
> + int frame_size = MFI_FRAME_SIZE * 16;
> + target_phys_addr_t frame_size_p = frame_size;
> +
> + cmd = megasas_next_frame(s, frame);
> + /* All frames busy */
> + if (!cmd) {
> + return NULL;
> + }
> + if (!cmd->pa) {
> + cmd->pa = frame;
> + /* Map all possible frames */
> + cmd->frame = cpu_physical_memory_map(frame, &frame_size_p, 0);
> + if (frame_size_p != frame_size) {
> + trace_megasas_qf_map_failed(cmd->index, (unsigned long)frame);
> + if (cmd->frame) {
> + cpu_physical_memory_unmap(cmd->frame, frame_size_p, 0, 0);
> + cmd->frame = NULL;
> + cmd->pa = 0;
> + }
> + s->event_count++;
> + return NULL;
> + }
> + cmd->pa_size = frame_size_p;
> + cmd->context = context;
> + if (!megasas_use_queue64(s)) {
> + cmd->context &= (uint64_t)0xFFFFFFFF;
> + }
> + }
> + cmd->count = count;
> + s->busy++;
> +
> + trace_megasas_qf_enqueue(cmd->index, cmd->count, cmd->context,
> + s->reply_queue_head, s->busy);
> +
> + return cmd;
> +}
> +
> +static void megasas_complete_frame(MegasasState *s, uint64_t context)
> +{
> + int tail, queue_offset;
> +
> + /* Decrement busy count */
> + s->busy--;
> +
> + if (s->reply_queue_pa) {
> + /*
> + * Put command on the reply queue.
> + * Context is opaque, but emulation is running in
> + * little endian. So convert it.
> + */
> + tail = s->reply_queue_head;
> + if (megasas_use_queue64(s)) {
> + queue_offset = tail * sizeof(uint64_t);
> + stq_le_phys(s->reply_queue_pa + queue_offset, context);
> + } else {
> + queue_offset = tail * sizeof(uint32_t);
> + stl_le_phys(s->reply_queue_pa + queue_offset, context);
> + }
> + s->reply_queue_head = megasas_next_index(s, tail, s->fw_cmds);
> + trace_megasas_qf_complete(context, tail, queue_offset,
> + s->busy, s->doorbell);
> + }
> +
> + if (megasas_intr_enabled(s)) {
> + /* Notify HBA */
> + s->doorbell++;
> + if (s->doorbell == 1) {
> + if (msix_enabled(&s->dev)) {
> + trace_megasas_msix_raise(0);
> + msix_notify(&s->dev, 0);
> + } else {
> + trace_megasas_irq_raise();
> + qemu_irq_raise(s->dev.irq[0]);
> + }
> + }
> + } else {
> + trace_megasas_qf_complete_noirq(context);
> + }
> +}
> +
> +static void megasas_reset_frames(MegasasState *s)
> +{
> + int i;
> + MegasasCmd *cmd;
> +
> + for (i = 0; i < s->fw_cmds; i++) {
> + cmd = &s->frames[i];
> + if (cmd->pa) {
> + cpu_physical_memory_unmap(cmd->frame, cmd->pa_size, 0, 0);
> + cmd->frame = NULL;
> + cmd->pa = 0;
> + }
> + }
> +}
> +
> +static void megasas_abort_command(MegasasCmd *cmd)
> +{
> + if (cmd->req) {
> + scsi_req_abort(cmd->req, ABORTED_COMMAND);
> + cmd->req = NULL;
> + }
> +}
> +
> +static int megasas_init_firmware(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint32_t pa_hi, pa_lo;
> + target_phys_addr_t iq_pa, initq_size;
> + struct mfi_init_qinfo *initq;
> + uint32_t flags;
> + int ret = MFI_STAT_OK;
> +
> + pa_lo = le32_to_cpu(cmd->frame->init.qinfo_new_addr_lo);
> + pa_hi = le32_to_cpu(cmd->frame->init.qinfo_new_addr_hi);
> + iq_pa = (((uint64_t) pa_hi << 32) | pa_lo);
> + trace_megasas_init_firmware((uint64_t)iq_pa);
> + initq_size = sizeof(*initq);
> + initq = cpu_physical_memory_map(iq_pa, &initq_size, 0);
> + if (!initq || initq_size != sizeof(*initq)) {
> + trace_megasas_initq_map_failed(cmd->index);
> + s->event_count++;
> + ret = MFI_STAT_MEMORY_NOT_AVAILABLE;
> + goto out;
> + }
> + s->reply_queue_len = le32_to_cpu(initq->rq_entries) & 0xFFFF;
> + if (s->reply_queue_len > s->fw_cmds) {
> + trace_megasas_initq_mismatch(s->reply_queue_len, s->fw_cmds);
> + s->event_count++;
> + ret = MFI_STAT_INVALID_PARAMETER;
> + goto out;
> + }
> + pa_lo = le32_to_cpu(initq->rq_addr_lo);
> + pa_hi = le32_to_cpu(initq->rq_addr_hi);
> + s->reply_queue_pa = ((uint64_t) pa_hi << 32) | pa_lo;
> + pa_lo = le32_to_cpu(initq->ci_addr_lo);
> + pa_hi = le32_to_cpu(initq->ci_addr_hi);
> + s->consumer_pa = ((uint64_t) pa_hi << 32) | pa_lo;
> + pa_lo = le32_to_cpu(initq->pi_addr_lo);
> + pa_hi = le32_to_cpu(initq->pi_addr_hi);
> + s->producer_pa = ((uint64_t) pa_hi << 32) | pa_lo;
> + s->reply_queue_head = ldl_le_phys(s->producer_pa);
> + s->reply_queue_tail = ldl_le_phys(s->consumer_pa);
> + flags = le32_to_cpu(initq->flags);
> + if (flags & MFI_QUEUE_FLAG_CONTEXT64) {
> + s->flags |= MEGASAS_MASK_USE_QUEUE64;
> + }
> + trace_megasas_init_queue((unsigned long)s->reply_queue_pa,
> + s->reply_queue_len, s->reply_queue_head,
> + s->reply_queue_tail, flags);
> + megasas_reset_frames(s);
> + s->fw_state = MFI_FWSTATE_OPERATIONAL;
> +out:
> + if (initq) {
> + cpu_physical_memory_unmap(initq, initq_size, 0, 0);
> + }
> + return ret;
> +}
> +
> +static int megasas_map_dcmd(MegasasState *s, MegasasCmd *cmd)
> +{
> + dma_addr_t iov_pa, iov_size;
> +
> + cmd->flags = le16_to_cpu(cmd->frame->header.flags);
> + if (!cmd->frame->header.sge_count) {
> + trace_megasas_dcmd_zero_sge(cmd->index);
> + cmd->iov_size = 0;
> + return 0;
> + } else if (cmd->frame->header.sge_count > 1) {
> + trace_megasas_dcmd_invalid_sge(cmd->index,
> + cmd->frame->header.sge_count);
> + cmd->iov_size = 0;
> + return -1;
> + }
> + iov_pa = megasas_sgl_get_addr(cmd, &cmd->frame->dcmd.sgl);
> + iov_size = megasas_sgl_get_len(cmd, &cmd->frame->dcmd.sgl);
> + qemu_sglist_init(&cmd->qsg, 1, pci_dma_context(&s->dev));
> + qemu_sglist_add(&cmd->qsg, iov_pa, iov_size);
> + cmd->iov_size = iov_size;
> + return cmd->iov_size;
> +}
> +
> +static void megasas_finish_dcmd(MegasasCmd *cmd, uint32_t iov_size)
> +{
> + trace_megasas_finish_dcmd(cmd->index, iov_size);
> +
> + if (cmd->frame->header.sge_count) {
> + qemu_sglist_destroy(&cmd->qsg);
> + }
> + if (iov_size > cmd->iov_size) {
> + if (megasas_frame_is_ieee_sgl(cmd)) {
> + cmd->frame->dcmd.sgl.sg_skinny->len = cpu_to_le32(iov_size);
> + } else if (megasas_frame_is_sgl64(cmd)) {
> + cmd->frame->dcmd.sgl.sg64->len = cpu_to_le32(iov_size);
> + } else {
> + cmd->frame->dcmd.sgl.sg32->len = cpu_to_le32(iov_size);
> + }
> + }
> + cmd->iov_size = 0;
> + return;
> +}
> +
> +static int megasas_ctrl_get_info(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_ctrl_info info;
> + size_t dcmd_size = sizeof(info);
> + BusChild *kid;
> + int num_ld_disks = 0;
> +
> + QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
> + num_ld_disks++;
> + }
> +
> + memset(&info, 0x0, cmd->iov_size);
> + if (cmd->iov_size < dcmd_size) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_size);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + info.pci.vendor = cpu_to_le16(PCI_VENDOR_ID_LSI_LOGIC);
> + info.pci.device = cpu_to_le16(PCI_DEVICE_ID_LSI_SAS1078);
> + info.pci.subvendor = cpu_to_le16(PCI_VENDOR_ID_LSI_LOGIC);
> + info.pci.subdevice = cpu_to_le16(0x1013);
> +
> + info.host.type = MFI_INFO_HOST_PCIX;
> + info.device.type = MFI_INFO_DEV_SAS3G;
> + info.device.port_count = 2;
> + info.device.port_addr[0] = cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
> +
> + memcpy(info.product_name, "MegaRAID SAS 8708EM2", 20);
> + snprintf(info.serial_number, 32, "QEMU%08lx",
> + (unsigned long)s & 0xFFFFFFFF);
> + snprintf(info.package_version, 0x60, "%s-QEMU", QEMU_VERSION);
> + memcpy(info.image_component[0].name, "APP", 3);
> + memcpy(info.image_component[0].version, MEGASAS_VERSION "-QEMU", 9);
> + memcpy(info.image_component[0].build_date, __DATE__, 11);
> + memcpy(info.image_component[0].build_time, __TIME__, 8);
> + info.image_component_count = 1;
> + if (s->dev.has_rom) {
> + uint8_t biosver[32];
> + uint8_t *ptr;
> +
> + ptr = memory_region_get_ram_ptr(&s->dev.rom);
> + memcpy(biosver, ptr + 0x41, 31);
> + qemu_put_ram_ptr(ptr);
> + memcpy(info.image_component[1].name, "BIOS", 4);
> + memcpy(info.image_component[1].version, biosver,
> + strlen((const char *)biosver));
> + info.image_component_count++;
> + }
> + info.current_fw_time = cpu_to_le32(megasas_fw_time());
> + info.max_arms = 32;
> + info.max_spans = 8;
> + info.max_arrays = MEGASAS_MAX_ARRAYS;
> + info.max_lds = s->fw_luns;
> + info.max_cmds = cpu_to_le16(s->fw_cmds);
> + info.max_sg_elements = cpu_to_le16(s->fw_sge);
> + info.max_request_size = cpu_to_le32(MEGASAS_MAX_SECTORS);
> + info.lds_present = cpu_to_le16(num_ld_disks);
> + info.pd_present = cpu_to_le16(num_ld_disks);
> + info.pd_disks_present = cpu_to_le16(num_ld_disks);
> + info.hw_present = cpu_to_le32(MFI_INFO_HW_NVRAM |
> + MFI_INFO_HW_MEM |
> + MFI_INFO_HW_FLASH);
> + info.memory_size = cpu_to_le16(512);
> + info.nvram_size = cpu_to_le16(32);
> + info.flash_size = cpu_to_le16(16);
> + info.raid_levels = cpu_to_le32(MFI_INFO_RAID_0);
> + info.adapter_ops = cpu_to_le32(MFI_INFO_AOPS_RBLD_RATE |
> + MFI_INFO_AOPS_SELF_DIAGNOSTIC |
> + MFI_INFO_AOPS_MIXED_ARRAY);
> + info.ld_ops = cpu_to_le32(MFI_INFO_LDOPS_DISK_CACHE_POLICY |
> + MFI_INFO_LDOPS_ACCESS_POLICY |
> + MFI_INFO_LDOPS_IO_POLICY |
> + MFI_INFO_LDOPS_WRITE_POLICY |
> + MFI_INFO_LDOPS_READ_POLICY);
> + info.max_strips_per_io = cpu_to_le16(s->fw_sge);
> + info.stripe_sz_ops.min = 3;
> + info.stripe_sz_ops.max = ffs(MEGASAS_MAX_SECTORS + 1) - 1;
> + info.properties.pred_fail_poll_interval = cpu_to_le16(300);
> + info.properties.intr_throttle_cnt = cpu_to_le16(16);
> + info.properties.intr_throttle_timeout = cpu_to_le16(50);
> + info.properties.rebuild_rate = 30;
> + info.properties.patrol_read_rate = 30;
> + info.properties.bgi_rate = 30;
> + info.properties.cc_rate = 30;
> + info.properties.recon_rate = 30;
> + info.properties.cache_flush_interval = 4;
> + info.properties.spinup_drv_cnt = 2;
> + info.properties.spinup_delay = 6;
> + info.properties.ecc_bucket_size = 15;
> + info.properties.ecc_bucket_leak_rate = cpu_to_le16(1440);
> + info.properties.expose_encl_devices = 1;
> + info.properties.OnOffProperties = cpu_to_le32(MFI_CTRL_PROP_EnableJBOD);
> + info.pd_ops = cpu_to_le32(MFI_INFO_PDOPS_FORCE_ONLINE |
> + MFI_INFO_PDOPS_FORCE_OFFLINE);
> + info.pd_mix_support = cpu_to_le32(MFI_INFO_PDMIX_SAS |
> + MFI_INFO_PDMIX_SATA |
> + MFI_INFO_PDMIX_LD);
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_mfc_get_defaults(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_defaults info;
> + size_t dcmd_size = sizeof(struct mfi_defaults);
> +
> + memset(&info, 0x0, dcmd_size);
> + if (cmd->iov_size < dcmd_size) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_size);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + info.sas_addr = cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
> + info.stripe_size = 3;
> + info.flush_time = 4;
> + info.background_rate = 30;
> + info.allow_mix_in_enclosure = 1;
> + info.allow_mix_in_ld = 1;
> + info.direct_pd_mapping = 1;
> + /* Enable for BIOS support */
> + info.bios_enumerate_lds = 1;
> + info.disable_ctrl_r = 1;
> + info.expose_enclosure_devices = 1;
> + info.disable_preboot_cli = 1;
> + info.cluster_disable = 1;
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_get_bios_info(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_bios_data info;
> + size_t dcmd_size = sizeof(info);
> +
> + memset(&info, 0x0, dcmd_size);
> + if (cmd->iov_size < dcmd_size) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_size);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> + info.continue_on_error = 1;
> + info.verbose = 1;
> + if (megasas_is_jbod(s)) {
> + info.expose_all_drives = 1;
> + }
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_get_fw_time(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint64_t fw_time;
> + size_t dcmd_size = sizeof(fw_time);
> +
> + fw_time = cpu_to_le64(megasas_fw_time());
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&fw_time, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_set_fw_time(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint64_t fw_time;
> +
> + /* This is a dummy; setting of firmware time is not allowed */
> + memcpy(&fw_time, cmd->frame->dcmd.mbox, sizeof(fw_time));
> +
> + trace_megasas_dcmd_set_fw_time(cmd->index, fw_time);
> + fw_time = cpu_to_le64(megasas_fw_time());
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_event_info(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_evt_log_state info;
> + size_t dcmd_size = sizeof(info);
> +
> + memset(&info, 0, dcmd_size);
> +
> + info.newest_seq_num = cpu_to_le32(s->event_count);
> + info.shutdown_seq_num = cpu_to_le32(s->shutdown_event);
> + info.boot_seq_num = cpu_to_le32(s->boot_event);
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_event_wait(MegasasState *s, MegasasCmd *cmd)
> +{
> + union mfi_evt event;
> +
> + if (cmd->iov_size < sizeof(struct mfi_evt_detail)) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + sizeof(struct mfi_evt_detail));
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> + s->event_count = cpu_to_le32(cmd->frame->dcmd.mbox[0]);
> + event.word = cpu_to_le32(cmd->frame->dcmd.mbox[4]);
> + s->event_locale = event.members.locale;
> + s->event_class = event.members.class;
> + s->event_cmd = cmd;
> + /* Decrease busy count; event frame doesn't count here */
> + s->busy--;
> + cmd->iov_size = sizeof(struct mfi_evt_detail);
> + return MFI_STAT_INVALID_STATUS;
> +}
> +
> +static int megasas_dcmd_pd_get_list(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_pd_list info;
> + size_t dcmd_size = sizeof(info);
> + BusChild *kid;
> + uint32_t offset, dcmd_limit, num_pd_disks = 0, max_pd_disks;
> + uint16_t sdev_id;
> +
> + memset(&info, 0, dcmd_size);
> + offset = 8;
> + dcmd_limit = offset + sizeof(struct mfi_pd_address);
> + if (cmd->iov_size < dcmd_limit) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_limit);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + max_pd_disks = (cmd->iov_size - offset) / sizeof(struct mfi_pd_address);
> + if (max_pd_disks > s->fw_luns) {
> + max_pd_disks = s->fw_luns;
> + }
> +
> + QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
> + SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
> +
> + sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
> + info.addr[num_pd_disks].device_id = cpu_to_le16(sdev_id);
> + info.addr[num_pd_disks].encl_device_id = 0xFFFF;
> + info.addr[num_pd_disks].encl_index = 0;
> + info.addr[num_pd_disks].slot_number = (sdev->id & 0xFF);
> + info.addr[num_pd_disks].scsi_dev_type = sdev->type;
> + info.addr[num_pd_disks].connect_port_bitmap = 0x1;
> + info.addr[num_pd_disks].sas_addr[0] =
> + cpu_to_le64(megasas_gen_sas_addr((uint64_t)sdev));
> + num_pd_disks++;
> + offset += sizeof(struct mfi_pd_address);
> + }
> + trace_megasas_dcmd_pd_get_list(cmd->index, num_pd_disks,
> + max_pd_disks, offset);
> +
> + info.size = cpu_to_le32(offset);
> + info.count = cpu_to_le32(num_pd_disks);
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, offset, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_pd_list_query(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint16_t flags;
> +
> + /* mbox0 contains flags */
> + flags = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
> + trace_megasas_dcmd_pd_list_query(cmd->index, flags);
> + if (flags == MR_PD_QUERY_TYPE_ALL ||
> + megasas_is_jbod(s)) {
> + return megasas_dcmd_pd_get_list(s, cmd);
> + }
> +
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_pd_get_info_submit(SCSIDevice *sdev, int lun,
> + MegasasCmd *cmd)
> +{
> + struct mfi_pd_info *info = cmd->iov_buf;
> + size_t dcmd_size = sizeof(struct mfi_pd_info);
> + BlockConf *conf = &sdev->conf;
> + uint64_t pd_size;
> + uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
> + uint8_t cmdbuf[6];
> + SCSIRequest *req;
> + size_t len, resid;
> +
> + if (!cmd->iov_buf) {
> + cmd->iov_buf = g_malloc(dcmd_size);
> + memset(cmd->iov_buf, 0, dcmd_size);
> + info = cmd->iov_buf;
> + info->inquiry_data[0] = 0x7f; /* Force PQual 0x3, PType 0x1f */
> + info->vpd_page83[0] = 0x7f;
> + megasas_setup_inquiry(cmdbuf, 0, sizeof(info->inquiry_data));
> + req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
> + if (!req) {
> + trace_megasas_dcmd_req_alloc_failed(cmd->index,
> + "PD get info std inquiry");
> + g_free(cmd->iov_buf);
> + cmd->iov_buf = NULL;
> + return MFI_STAT_FLASH_ALLOC_FAIL;
> + }
> + trace_megasas_dcmd_internal_submit(cmd->index,
> + "PD get info std inquiry", lun);
> + len = scsi_req_enqueue(req);
> + if (len > 0) {
> + cmd->iov_size = len;
> + scsi_req_continue(req);
> + }
> + return MFI_STAT_INVALID_STATUS;
> + } else if (info->inquiry_data[0] != 0x7f && info->vpd_page83[0] == 0x7f) {
> + megasas_setup_inquiry(cmdbuf, 0x83, sizeof(info->vpd_page83));
> + req = scsi_req_new(sdev, cmd->index, lun, cmdbuf, cmd);
> + if (!req) {
> + trace_megasas_dcmd_req_alloc_failed(cmd->index,
> + "PD get info vpd inquiry");
> + return MFI_STAT_FLASH_ALLOC_FAIL;
> + }
> + trace_megasas_dcmd_internal_submit(cmd->index,
> + "PD get info vpd inquiry", lun);
> + len = scsi_req_enqueue(req);
> + if (len > 0) {
> + cmd->iov_size = len;
> + scsi_req_continue(req);
> + }
> + return MFI_STAT_INVALID_STATUS;
> + }
> + /* Finished, set FW state */
> + if ((info->inquiry_data[0] >> 5) == 0) {
> + if (megasas_is_jbod(cmd->state)) {
> + info->fw_state = cpu_to_le16(MFI_PD_STATE_SYSTEM);
> + } else {
> + info->fw_state = cpu_to_le16(MFI_PD_STATE_ONLINE);
> + }
> + } else {
> + info->fw_state = cpu_to_le16(MFI_PD_STATE_OFFLINE);
> + }
> +
> + info->ref.v.device_id = cpu_to_le16(sdev_id);
> + info->state.ddf.pd_type = cpu_to_le16(MFI_PD_DDF_TYPE_IN_VD|
> + MFI_PD_DDF_TYPE_INTF_SAS);
> + bdrv_get_geometry(conf->bs, &pd_size);
> + info->raw_size = cpu_to_le64(pd_size);
> + info->non_coerced_size = cpu_to_le64(pd_size);
> + info->coerced_size = cpu_to_le64(pd_size);
> + info->encl_device_id = 0xFFFF;
> + info->slot_number = (sdev->id & 0xFF);
> + info->path_info.count = 1;
> + info->path_info.sas_addr[0] =
> + cpu_to_le64(megasas_gen_sas_addr((uint64_t)sdev));
> + info->connected_port_bitmap = 0x1;
> + info->device_speed = 1;
> + info->link_speed = 1;
> + resid = dma_buf_read(cmd->iov_buf, dcmd_size, &cmd->qsg);
> + g_free(cmd->iov_buf);
> + cmd->iov_size = dcmd_size - resid;
> + cmd->iov_buf = NULL;
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_pd_get_info(MegasasState *s, MegasasCmd *cmd)
> +{
> + size_t dcmd_size = sizeof(struct mfi_pd_info);
> + uint16_t pd_id;
> + SCSIDevice *sdev = NULL;
> + int retval = MFI_STAT_DEVICE_NOT_FOUND;
> +
> + if (cmd->iov_size < dcmd_size) {
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + /* mbox0 has the ID */
> + pd_id = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
> + sdev = scsi_device_find(&s->bus, 0, pd_id, 0);
> + trace_megasas_dcmd_pd_get_info(cmd->index, pd_id);
> +
> + if (sdev) {
> + /* Submit inquiry */
> + retval = megasas_pd_get_info_submit(sdev, pd_id, cmd);
> + }
> +
> + return retval;
> +}
> +
> +static int megasas_dcmd_ld_get_list(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_ld_list info;
> + size_t dcmd_size = sizeof(info), resid;
> + uint32_t num_ld_disks = 0, max_ld_disks = s->fw_luns;
> + uint64_t ld_size;
> + BusChild *kid;
> +
> + memset(&info, 0, dcmd_size);
> + if (cmd->iov_size < dcmd_size) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_size);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + if (megasas_is_jbod(s)) {
> + max_ld_disks = 0;
> + }
> + QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
> + SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
> + BlockConf *conf = &sdev->conf;
> +
> + if (num_ld_disks >= max_ld_disks) {
> + break;
> + }
> + /* Logical device size is in blocks */
> + bdrv_get_geometry(conf->bs, &ld_size);
> + info.ld_list[num_ld_disks].ld.v.target_id = sdev->id;
> + info.ld_list[num_ld_disks].state = MFI_LD_STATE_OPTIMAL;
> + info.ld_list[num_ld_disks].size = cpu_to_le64(ld_size);
> + num_ld_disks++;
> + }
> + info.ld_count = cpu_to_le32(num_ld_disks);
> + trace_megasas_dcmd_ld_get_list(cmd->index, num_ld_disks, max_ld_disks);
> +
> + resid = dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + cmd->iov_size = dcmd_size - resid;
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_ld_get_info_submit(SCSIDevice *sdev, int lun,
> + MegasasCmd *cmd)
> +{
> + struct mfi_ld_info *info = cmd->iov_buf;
> + size_t dcmd_size = sizeof(struct mfi_ld_info);
> + uint8_t cdb[6];
> + SCSIRequest *req;
> + ssize_t len, resid;
> + BlockConf *conf = &sdev->conf;
> + uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (lun & 0xFF);
> + uint64_t ld_size;
> +
> + if (!cmd->iov_buf) {
> + cmd->iov_buf = g_malloc(dcmd_size);
> + memset(cmd->iov_buf, 0x0, dcmd_size);
> + info = cmd->iov_buf;
> + megasas_setup_inquiry(cdb, 0x83, sizeof(info->vpd_page83));
> + req = scsi_req_new(sdev, cmd->index, lun, cdb, cmd);
> + if (!req) {
> + trace_megasas_dcmd_req_alloc_failed(cmd->index,
> + "LD get info vpd inquiry");
> + g_free(cmd->iov_buf);
> + cmd->iov_buf = NULL;
> + return MFI_STAT_FLASH_ALLOC_FAIL;
> + }
> + trace_megasas_dcmd_internal_submit(cmd->index,
> + "LD get info vpd inquiry", lun);
> + len = scsi_req_enqueue(req);
> + if (len > 0) {
> + cmd->iov_size = len;
> + scsi_req_continue(req);
> + }
> + return MFI_STAT_INVALID_STATUS;
> + }
> +
> + info->ld_config.params.state = MFI_LD_STATE_OPTIMAL;
> + info->ld_config.properties.ld.v.target_id = lun;
> + info->ld_config.params.stripe_size = 3;
> + info->ld_config.params.num_drives = 1;
> + info->ld_config.params.is_consistent = 1;
> + /* Logical device size is in blocks */
> + bdrv_get_geometry(conf->bs, &ld_size);
> + info->size = cpu_to_le64(ld_size);
> + memset(info->ld_config.span, 0, sizeof(info->ld_config.span));
> + info->ld_config.span[0].start_block = 0;
> + info->ld_config.span[0].num_blocks = info->size;
> + info->ld_config.span[0].array_ref = cpu_to_le16(sdev_id);
> +
> + resid = dma_buf_read(cmd->iov_buf, dcmd_size, &cmd->qsg);
> + g_free(cmd->iov_buf);
> + cmd->iov_size = dcmd_size - resid;
> + cmd->iov_buf = NULL;
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_ld_get_info(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_ld_info info;
> + size_t dcmd_size = sizeof(info);
> + uint16_t ld_id;
> + uint32_t max_ld_disks = s->fw_luns;
> + SCSIDevice *sdev = NULL;
> + int retval = MFI_STAT_DEVICE_NOT_FOUND;
> +
> + if (cmd->iov_size < dcmd_size) {
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + /* mbox0 has the ID */
> + ld_id = le16_to_cpu(cmd->frame->dcmd.mbox[0]);
> + trace_megasas_dcmd_ld_get_info(cmd->index, ld_id);
> +
> + if (megasas_is_jbod(s)) {
> + return MFI_STAT_DEVICE_NOT_FOUND;
> + }
> +
> + if (ld_id < max_ld_disks) {
> + sdev = scsi_device_find(&s->bus, 0, ld_id, 0);
> + }
> +
> + if (sdev) {
> + retval = megasas_ld_get_info_submit(sdev, ld_id, cmd);
> + }
> +
> + return retval;
> +}
> +
> +static int megasas_dcmd_cfg_read(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint8_t data[4096];
> + struct mfi_config_data *info;
> + int num_pd_disks = 0, array_offset, ld_offset;
> + BusChild *kid;
> +
> + if (cmd->iov_size > 4096) {
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
> + num_pd_disks++;
> + }
> + info = (struct mfi_config_data *)&data;
> + /*
> + * Array mapping:
> + * - One array per SCSI device
> + * - One logical drive per SCSI device
> + * spanning the entire device
> + */
> + info->array_count = num_pd_disks;
> + info->array_size = sizeof(struct mfi_array) * num_pd_disks;
> + info->log_drv_count = num_pd_disks;
> + info->log_drv_size = sizeof(struct mfi_ld_config) * num_pd_disks;
> + info->spares_count = 0;
> + info->spares_size = sizeof(struct mfi_spare);
> + info->size = sizeof(struct mfi_config_data) + info->array_size +
> + info->log_drv_size;
> + if (info->size > 4096) {
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> +
> + array_offset = sizeof(struct mfi_config_data);
> + ld_offset = array_offset + sizeof(struct mfi_array) * num_pd_disks;
> +
> + QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
> + SCSIDevice *sdev = DO_UPCAST(SCSIDevice, qdev, kid->child);
> + BlockConf *conf = &sdev->conf;
> + uint16_t sdev_id = ((sdev->id & 0xFF) >> 8) | (sdev->lun & 0xFF);
> + struct mfi_array *array;
> + struct mfi_ld_config *ld;
> + uint64_t pd_size;
> + int i;
> +
> + array = (struct mfi_array *)(data + array_offset);
> + bdrv_get_geometry(conf->bs, &pd_size);
> + array->size = cpu_to_le64(pd_size);
> + array->num_drives = 1;
> + array->array_ref = cpu_to_le16(sdev_id);
> + array->pd[0].ref.v.device_id = cpu_to_le16(sdev_id);
> + array->pd[0].ref.v.seq_num = 0;
> + array->pd[0].fw_state = MFI_PD_STATE_ONLINE;
> + array->pd[0].encl.pd = 0xFF;
> + array->pd[0].encl.slot = (sdev->id & 0xFF);
> + for (i = 1; i < MFI_MAX_ROW_SIZE; i++) {
> + array->pd[i].ref.v.device_id = 0xFFFF;
> + array->pd[i].ref.v.seq_num = 0;
> + array->pd[i].fw_state = MFI_PD_STATE_UNCONFIGURED_GOOD;
> + array->pd[i].encl.pd = 0xFF;
> + array->pd[i].encl.slot = 0xFF;
> + }
> + array_offset += sizeof(struct mfi_array);
> + ld = (struct mfi_ld_config *)(data + ld_offset);
> + memset(ld, 0, sizeof(struct mfi_ld_config));
> + ld->properties.ld.v.target_id = (sdev->id & 0xFF);
> + ld->properties.default_cache_policy = MR_LD_CACHE_READ_AHEAD |
> + MR_LD_CACHE_READ_ADAPTIVE;
> + ld->properties.current_cache_policy = MR_LD_CACHE_READ_AHEAD |
> + MR_LD_CACHE_READ_ADAPTIVE;
> + ld->params.state = MFI_LD_STATE_OPTIMAL;
> + ld->params.stripe_size = 3;
> + ld->params.num_drives = 1;
> + ld->params.span_depth = 1;
> + ld->params.is_consistent = 1;
> + ld->span[0].start_block = 0;
> + ld->span[0].num_blocks = cpu_to_le64(pd_size);
> + ld->span[0].array_ref = cpu_to_le16(sdev_id);
> + ld_offset += sizeof(struct mfi_ld_config);
> + }
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)data, info->size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_get_properties(MegasasState *s, MegasasCmd *cmd)
> +{
> + struct mfi_ctrl_props info;
> + size_t dcmd_size = sizeof(info);
> +
> + memset(&info, 0x0, dcmd_size);
> + if (cmd->iov_size < dcmd_size) {
> + trace_megasas_dcmd_invalid_xfer_len(cmd->index, cmd->iov_size,
> + dcmd_size);
> + return MFI_STAT_INVALID_PARAMETER;
> + }
> + info.pred_fail_poll_interval = cpu_to_le16(300);
> + info.intr_throttle_cnt = cpu_to_le16(16);
> + info.intr_throttle_timeout = cpu_to_le16(50);
> + info.rebuild_rate = 30;
> + info.patrol_read_rate = 30;
> + info.bgi_rate = 30;
> + info.cc_rate = 30;
> + info.recon_rate = 30;
> + info.cache_flush_interval = 4;
> + info.spinup_drv_cnt = 2;
> + info.spinup_delay = 6;
> + info.ecc_bucket_size = 15;
> + info.ecc_bucket_leak_rate = cpu_to_le16(1440);
> + info.expose_encl_devices = 1;
> +
> + cmd->iov_size -= dma_buf_read((uint8_t *)&info, dcmd_size, &cmd->qsg);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_cache_flush(MegasasState *s, MegasasCmd *cmd)
> +{
> + qemu_aio_flush();
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_ctrl_shutdown(MegasasState *s, MegasasCmd *cmd)
> +{
> + s->fw_state = MFI_FWSTATE_READY;
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_cluster_reset_ld(MegasasState *s, MegasasCmd *cmd)
> +{
> + return MFI_STAT_INVALID_DCMD;
> +}
> +
> +static int megasas_dcmd_set_properties(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint8_t *dummy = g_malloc(cmd->iov_size);
> +
> + dma_buf_write(dummy, cmd->iov_size, &cmd->qsg);
> +
> + trace_megasas_dcmd_dump_frame(0,
> + dummy[0x00], dummy[0x01], dummy[0x02], dummy[0x03],
> + dummy[0x04], dummy[0x05], dummy[0x06], dummy[0x07]);
> + trace_megasas_dcmd_dump_frame(1,
> + dummy[0x08], dummy[0x09], dummy[0x0a], dummy[0x0b],
> + dummy[0x0c], dummy[0x0d], dummy[0x0e], dummy[0x0f]);
> + trace_megasas_dcmd_dump_frame(2,
> + dummy[0x10], dummy[0x11], dummy[0x12], dummy[0x13],
> + dummy[0x14], dummy[0x15], dummy[0x16], dummy[0x17]);
> + trace_megasas_dcmd_dump_frame(3,
> + dummy[0x18], dummy[0x19], dummy[0x1a], dummy[0x1b],
> + dummy[0x1c], dummy[0x1d], dummy[0x1e], dummy[0x1f]);
> + trace_megasas_dcmd_dump_frame(4,
> + dummy[0x20], dummy[0x21], dummy[0x22], dummy[0x23],
> + dummy[0x24], dummy[0x25], dummy[0x26], dummy[0x27]);
> + trace_megasas_dcmd_dump_frame(5,
> + dummy[0x28], dummy[0x29], dummy[0x2a], dummy[0x2b],
> + dummy[0x2c], dummy[0x2d], dummy[0x2e], dummy[0x2f]);
> + trace_megasas_dcmd_dump_frame(6,
> + dummy[0x30], dummy[0x31], dummy[0x32], dummy[0x33],
> + dummy[0x34], dummy[0x35], dummy[0x36], dummy[0x37]);
> + trace_megasas_dcmd_dump_frame(7,
> + dummy[0x38], dummy[0x39], dummy[0x3a], dummy[0x3b],
> + dummy[0x3c], dummy[0x3d], dummy[0x3e], dummy[0x3f]);
> + g_free(dummy);
> + return MFI_STAT_OK;
> +}
> +
> +static int megasas_dcmd_dummy(MegasasState *s, MegasasCmd *cmd)
> +{
> + trace_megasas_dcmd_dummy(cmd->index, cmd->iov_size);
> + return MFI_STAT_OK;
> +}
> +
> +static const struct dcmd_cmd_tbl_t {
> + int opcode;
> + const char *desc;
> + int (*func)(MegasasState *s, MegasasCmd *cmd);
> +} dcmd_cmd_tbl[] = {
> + { MFI_DCMD_CTRL_MFI_HOST_MEM_ALLOC, "CTRL_HOST_MEM_ALLOC",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_GET_INFO, "CTRL_GET_INFO",
> + megasas_ctrl_get_info },
> + { MFI_DCMD_CTRL_GET_PROPERTIES, "CTRL_GET_PROPERTIES",
> + megasas_dcmd_get_properties },
> + { MFI_DCMD_CTRL_SET_PROPERTIES, "CTRL_SET_PROPERTIES",
> + megasas_dcmd_set_properties },
> + { MFI_DCMD_CTRL_ALARM_GET, "CTRL_ALARM_GET",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_ALARM_ENABLE, "CTRL_ALARM_ENABLE",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_ALARM_DISABLE, "CTRL_ALARM_DISABLE",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_ALARM_SILENCE, "CTRL_ALARM_SILENCE",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_ALARM_TEST, "CTRL_ALARM_TEST",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_EVENT_GETINFO, "CTRL_EVENT_GETINFO",
> + megasas_event_info },
> + { MFI_DCMD_CTRL_EVENT_GET, "CTRL_EVENT_GET",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_EVENT_WAIT, "CTRL_EVENT_WAIT",
> + megasas_event_wait },
> + { MFI_DCMD_CTRL_SHUTDOWN, "CTRL_SHUTDOWN",
> + megasas_ctrl_shutdown },
> + { MFI_DCMD_HIBERNATE_STANDBY, "CTRL_STANDBY",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_GET_TIME, "CTRL_GET_TIME",
> + megasas_dcmd_get_fw_time },
> + { MFI_DCMD_CTRL_SET_TIME, "CTRL_SET_TIME",
> + megasas_dcmd_set_fw_time },
> + { MFI_DCMD_CTRL_BIOS_DATA_GET, "CTRL_BIOS_DATA_GET",
> + megasas_dcmd_get_bios_info },
> + { MFI_DCMD_CTRL_FACTORY_DEFAULTS, "CTRL_FACTORY_DEFAULTS",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_MFC_DEFAULTS_GET, "CTRL_MFC_DEFAULTS_GET",
> + megasas_mfc_get_defaults },
> + { MFI_DCMD_CTRL_MFC_DEFAULTS_SET, "CTRL_MFC_DEFAULTS_SET",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CTRL_CACHE_FLUSH, "CTRL_CACHE_FLUSH",
> + megasas_cache_flush },
> + { MFI_DCMD_PD_GET_LIST, "PD_GET_LIST",
> + megasas_dcmd_pd_get_list },
> + { MFI_DCMD_PD_LIST_QUERY, "PD_LIST_QUERY",
> + megasas_dcmd_pd_list_query },
> + { MFI_DCMD_PD_GET_INFO, "PD_GET_INFO",
> + megasas_dcmd_pd_get_info },
> + { MFI_DCMD_PD_STATE_SET, "PD_STATE_SET",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_PD_REBUILD, "PD_REBUILD",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_PD_BLINK, "PD_BLINK",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_PD_UNBLINK, "PD_UNBLINK",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_LD_GET_LIST, "LD_GET_LIST",
> + megasas_dcmd_ld_get_list},
> + { MFI_DCMD_LD_GET_INFO, "LD_GET_INFO",
> + megasas_dcmd_ld_get_info },
> + { MFI_DCMD_LD_GET_PROP, "LD_GET_PROP",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_LD_SET_PROP, "LD_SET_PROP",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_LD_DELETE, "LD_DELETE",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CFG_READ, "CFG_READ",
> + megasas_dcmd_cfg_read },
> + { MFI_DCMD_CFG_ADD, "CFG_ADD",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CFG_CLEAR, "CFG_CLEAR",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CFG_FOREIGN_READ, "CFG_FOREIGN_READ",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CFG_FOREIGN_IMPORT, "CFG_FOREIGN_IMPORT",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_BBU_STATUS, "BBU_STATUS",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_BBU_CAPACITY_INFO, "BBU_CAPACITY_INFO",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_BBU_DESIGN_INFO, "BBU_DESIGN_INFO",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_BBU_PROP_GET, "BBU_PROP_GET",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CLUSTER, "CLUSTER",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CLUSTER_RESET_ALL, "CLUSTER_RESET_ALL",
> + megasas_dcmd_dummy },
> + { MFI_DCMD_CLUSTER_RESET_LD, "CLUSTER_RESET_LD",
> + megasas_cluster_reset_ld },
> + { -1, NULL, NULL }
> +};
> +
> +static int megasas_handle_dcmd(MegasasState *s, MegasasCmd *cmd)
> +{
> + int opcode, len;
> + int retval = 0;
> + const struct dcmd_cmd_tbl_t *cmdptr = dcmd_cmd_tbl;
> +
> + opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
> + trace_megasas_handle_dcmd(cmd->index, opcode);
> + len = megasas_map_dcmd(s, cmd);
> + if (len < 0) {
> + return MFI_STAT_MEMORY_NOT_AVAILABLE;
> + }
> + while (cmdptr->opcode != -1 && cmdptr->opcode != opcode) {
> + cmdptr++;
> + }
> + if (cmdptr->opcode == -1) {
> + trace_megasas_dcmd_unhandled(cmd->index, opcode, len);
> + retval = megasas_dcmd_dummy(s, cmd);
> + } else {
> + trace_megasas_dcmd_enter(cmd->index, cmdptr->desc, len);
> + retval = cmdptr->func(s, cmd);
> + }
> + if (retval != MFI_STAT_INVALID_STATUS) {
> + megasas_finish_dcmd(cmd, len);
> + }
> + return retval;
> +}
> +
> +static int megasas_finish_internal_dcmd(MegasasCmd *cmd,
> + SCSIRequest *req)
> +{
> + int opcode;
> + int retval = MFI_STAT_OK;
> + int lun = req->lun;
> +
> + opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
> + scsi_req_unref(req);
> + trace_megasas_dcmd_internal_finish(cmd->index, opcode, lun);
> + switch (opcode) {
> + case MFI_DCMD_PD_GET_INFO:
> + retval = megasas_pd_get_info_submit(req->dev, lun, cmd);
> + break;
> + case MFI_DCMD_LD_GET_INFO:
> + retval = megasas_ld_get_info_submit(req->dev, lun, cmd);
> + break;
> + default:
> + trace_megasas_dcmd_internal_invalid(cmd->index, opcode);
> + retval = MFI_STAT_INVALID_DCMD;
> + break;
> + }
> + if (retval != MFI_STAT_INVALID_STATUS) {
> + megasas_finish_dcmd(cmd, cmd->iov_size);
> + }
> + return retval;
> +}
> +
> +static int megasas_enqueue_req(MegasasCmd *cmd, bool is_write)
> +{
> + int len;
> +
> + len = scsi_req_enqueue(cmd->req);
> + if (len < 0) {
> + len = -len;
> + }
> + if (len > 0) {
> + if (len > cmd->iov_size) {
> + if (is_write) {
> + trace_megasas_iov_write_overflow(cmd->index, len,
> + cmd->iov_size);
> + } else {
> + trace_megasas_iov_read_overflow(cmd->index, len,
> + cmd->iov_size);
> + }
> + }
> + if (len < cmd->iov_size) {
> + if (is_write) {
> + trace_megasas_iov_write_underflow(cmd->index, len,
> + cmd->iov_size);
> + } else {
> + trace_megasas_iov_read_underflow(cmd->index, len,
> + cmd->iov_size);
> + }
> + cmd->iov_size = len;
> + }
> + scsi_req_continue(cmd->req);
> + }
> + return len;
> +}
> +
> +static int megasas_handle_scsi(MegasasState *s, MegasasCmd *cmd,
> + bool is_logical)
> +{
> + uint8_t *cdb;
> + int len;
> + bool is_write;
> + struct SCSIDevice *sdev = NULL;
> +
> + cdb = cmd->frame->pass.cdb;
> +
> + if (cmd->frame->header.target_id < s->fw_luns) {
> + sdev = scsi_device_find(&s->bus, 0, cmd->frame->header.target_id,
> + cmd->frame->header.lun_id);
> + }
> + cmd->iov_size = le32_to_cpu(cmd->frame->header.data_len);
> + trace_megasas_handle_scsi(mfi_frame_desc[cmd->frame->header.frame_cmd],
> + is_logical, cmd->frame->header.target_id,
> + cmd->frame->header.lun_id, sdev, cmd->iov_size);
> +
> + if (!sdev || (megasas_is_jbod(s) && is_logical)) {
> + trace_megasas_scsi_target_not_present(
> + mfi_frame_desc[cmd->frame->header.frame_cmd], is_logical,
> + cmd->frame->header.target_id, cmd->frame->header.lun_id);
> + return MFI_STAT_DEVICE_NOT_FOUND;
> + }
> +
> + if (cmd->frame->header.cdb_len > 16) {
> + trace_megasas_scsi_invalid_cdb_len(
> + mfi_frame_desc[cmd->frame->header.frame_cmd], is_logical,
> + cmd->frame->header.target_id, cmd->frame->header.lun_id,
> + cmd->frame->header.cdb_len);
> + megasas_write_sense(cmd, SENSE_CODE(INVALID_OPCODE));
> + cmd->frame->header.scsi_status = CHECK_CONDITION;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> +
> + if (megasas_map_sgl(s, cmd, &cmd->frame->pass.sgl)) {
> + megasas_write_sense(cmd, SENSE_CODE(TARGET_FAILURE));
> + cmd->frame->header.scsi_status = CHECK_CONDITION;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> +
> + cmd->req = scsi_req_new(sdev, cmd->index,
> + cmd->frame->header.lun_id, cdb, cmd);
> + if (!cmd->req) {
> + trace_megasas_scsi_req_alloc_failed(
> + mfi_frame_desc[cmd->frame->header.frame_cmd],
> + cmd->frame->header.target_id, cmd->frame->header.lun_id);
> + megasas_write_sense(cmd, SENSE_CODE(NO_SENSE));
> + cmd->frame->header.scsi_status = BUSY;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> +
> + is_write = (cmd->req->cmd.mode == SCSI_XFER_TO_DEV);
> + len = megasas_enqueue_req(cmd, is_write);
> + if (len > 0) {
> + if (is_write) {
> + trace_megasas_scsi_write_start(cmd->index, len);
> + } else {
> + trace_megasas_scsi_read_start(cmd->index, len);
> + }
> + } else {
> + trace_megasas_scsi_nodata(cmd->index);
> + }
> + return MFI_STAT_INVALID_STATUS;
> +}
> +
> +static int megasas_handle_io(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint32_t lba_count, lba_start_hi, lba_start_lo;
> + uint64_t lba_start;
> + bool is_write = (cmd->frame->header.frame_cmd == MFI_CMD_LD_WRITE);
> + uint8_t cdb[16];
> + int len;
> + struct SCSIDevice *sdev = NULL;
> +
> + lba_count = le32_to_cpu(cmd->frame->io.header.data_len);
> + lba_start_lo = le32_to_cpu(cmd->frame->io.lba_lo);
> + lba_start_hi = le32_to_cpu(cmd->frame->io.lba_hi);
> + lba_start = ((uint64_t)lba_start_hi << 32) | lba_start_lo;
> +
> + if (cmd->frame->header.target_id < s->fw_luns) {
> + sdev = scsi_device_find(&s->bus, 0, cmd->frame->header.target_id,
> + cmd->frame->header.lun_id);
> + }
> +
> + trace_megasas_handle_io(cmd->index,
> + mfi_frame_desc[cmd->frame->header.frame_cmd],
> + cmd->frame->header.target_id,
> + cmd->frame->header.lun_id,
> + (unsigned long)lba_start, (unsigned long)lba_count);
> + if (!sdev) {
> + trace_megasas_io_target_not_present(cmd->index,
> + mfi_frame_desc[cmd->frame->header.frame_cmd],
> + cmd->frame->header.target_id, cmd->frame->header.lun_id);
> + return MFI_STAT_DEVICE_NOT_FOUND;
> + }
> +
> + if (cmd->frame->header.cdb_len > 16) {
> + trace_megasas_scsi_invalid_cdb_len(
> + mfi_frame_desc[cmd->frame->header.frame_cmd], 1,
> + cmd->frame->header.target_id, cmd->frame->header.lun_id,
> + cmd->frame->header.cdb_len);
> + megasas_write_sense(cmd, SENSE_CODE(INVALID_OPCODE));
> + cmd->frame->header.scsi_status = CHECK_CONDITION;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> +
> + cmd->iov_size = lba_count * sdev->blocksize;
> + if (megasas_map_sgl(s, cmd, &cmd->frame->io.sgl)) {
> + megasas_write_sense(cmd, SENSE_CODE(TARGET_FAILURE));
> + cmd->frame->header.scsi_status = CHECK_CONDITION;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> +
> + megasas_encode_lba(cdb, lba_start, lba_count, is_write);
> + cmd->req = scsi_req_new(sdev, cmd->index,
> + cmd->frame->header.lun_id, cdb, cmd);
> + if (!cmd->req) {
> + trace_megasas_scsi_req_alloc_failed(
> + mfi_frame_desc[cmd->frame->header.frame_cmd],
> + cmd->frame->header.target_id, cmd->frame->header.lun_id);
> + megasas_write_sense(cmd, SENSE_CODE(NO_SENSE));
> + cmd->frame->header.scsi_status = BUSY;
> + s->event_count++;
> + return MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> + len = megasas_enqueue_req(cmd, is_write);
> + if (len > 0) {
> + if (is_write) {
> + trace_megasas_io_write_start(cmd->index, lba_start, lba_count, len);
> + } else {
> + trace_megasas_io_read_start(cmd->index, lba_start, lba_count, len);
> + }
> + }
> + return MFI_STAT_INVALID_STATUS;
> +}
> +
> +static int megasas_finish_internal_command(MegasasCmd *cmd,
> + SCSIRequest *req, size_t resid)
> +{
> + int retval = MFI_STAT_INVALID_CMD;
> +
> + if (cmd->frame->header.frame_cmd == MFI_CMD_DCMD) {
> + cmd->iov_size -= resid;
> + retval = megasas_finish_internal_dcmd(cmd, req);
> + }
> + return retval;
> +}
> +
> +static QEMUSGList *megasas_get_sg_list(SCSIRequest *req)
> +{
> + MegasasCmd *cmd = req->hba_private;
> +
> + if (cmd->frame->header.frame_cmd == MFI_CMD_DCMD) {
> + return NULL;
> + } else {
> + return &cmd->qsg;
> + }
> +}
> +
> +static void megasas_xfer_complete(SCSIRequest *req, uint32_t len)
> +{
> + MegasasCmd *cmd = req->hba_private;
> + uint8_t *buf;
> + uint32_t opcode;
> +
> + trace_megasas_io_complete(cmd->index, len);
> +
> + if (cmd->frame->header.frame_cmd != MFI_CMD_DCMD) {
> + scsi_req_continue(req);
> + return;
> + }
> +
> + buf = scsi_req_get_buf(req);
> + opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
> + if (opcode == MFI_DCMD_PD_GET_INFO && cmd->iov_buf) {
> + struct mfi_pd_info *info = cmd->iov_buf;
> +
> + if (info->inquiry_data[0] == 0x7f) {
> + memset(info->inquiry_data, 0, sizeof(info->inquiry_data));
> + memcpy(info->inquiry_data, buf, len);
> + } else if (info->vpd_page83[0] == 0x7f) {
> + memset(info->vpd_page83, 0, sizeof(info->vpd_page83));
> + memcpy(info->vpd_page83, buf, len);
> + }
> + scsi_req_continue(req);
> + } else if (opcode == MFI_DCMD_LD_GET_INFO) {
> + struct mfi_ld_info *info = cmd->iov_buf;
> +
> + if (cmd->iov_buf) {
> + memcpy(info->vpd_page83, buf, sizeof(info->vpd_page83));
> + scsi_req_continue(req);
> + }
> + }
> +}
> +
> +static void megasas_command_complete(SCSIRequest *req, uint32_t status,
> + size_t resid)
> +{
> + MegasasCmd *cmd = req->hba_private;
> + uint8_t cmd_status = MFI_STAT_OK;
> +
> + trace_megasas_command_complete(cmd->index, status, resid);
> +
> + if (cmd->req != req) {
> + /*
> + * Internal command complete
> + */
> + cmd_status = megasas_finish_internal_command(cmd, req, resid);
> + if (cmd_status == MFI_STAT_INVALID_STATUS) {
> + return;
> + }
> + } else {
> + req->status = status;
> + trace_megasas_scsi_complete(cmd->index, req->status,
> + cmd->iov_size, req->cmd.xfer);
> + if (req->status != GOOD) {
> + cmd_status = MFI_STAT_SCSI_DONE_WITH_ERROR;
> + }
> + if (req->status == CHECK_CONDITION) {
> + megasas_copy_sense(cmd);
> + }
> +
> + megasas_unmap_sgl(cmd);
> + cmd->frame->header.scsi_status = req->status;
> + scsi_req_unref(cmd->req);
> + cmd->req = NULL;
> + }
> + cmd->frame->header.cmd_status = cmd_status;
> + megasas_complete_frame(cmd->state, cmd->context);
> +}
> +
> +static void megasas_command_cancel(SCSIRequest *req)
> +{
> + MegasasCmd *cmd = req->hba_private;
> +
> + if (cmd) {
> + megasas_abort_command(cmd);
> + } else {
> + scsi_req_unref(req);
> + }
> +}
> +
> +static int megasas_handle_abort(MegasasState *s, MegasasCmd *cmd)
> +{
> + uint64_t abort_ctx = le64_to_cpu(cmd->frame->abort.abort_context);
> + target_phys_addr_t abort_addr, addr_hi, addr_lo;
> + MegasasCmd *abort_cmd;
> +
> + addr_hi = le32_to_cpu(cmd->frame->abort.abort_mfi_addr_hi);
> + addr_lo = le32_to_cpu(cmd->frame->abort.abort_mfi_addr_lo);
> + abort_addr = ((uint64_t)addr_hi << 32) | addr_lo;
> +
> + abort_cmd = megasas_lookup_frame(s, abort_addr);
> + if (!abort_cmd) {
> + trace_megasas_abort_no_cmd(cmd->index, abort_ctx);
> + s->event_count++;
> + return MFI_STAT_OK;
> + }
> + if (!megasas_use_queue64(s)) {
> + abort_ctx &= (uint64_t)0xFFFFFFFF;
> + }
> + if (abort_cmd->context != abort_ctx) {
> + trace_megasas_abort_invalid_context(cmd->index, abort_cmd->index,
> + abort_cmd->context);
> + s->event_count++;
> + return MFI_STAT_ABORT_NOT_POSSIBLE;
> + }
> + trace_megasas_abort_frame(cmd->index, abort_cmd->index);
> + megasas_abort_command(abort_cmd);
> + if (!s->event_cmd || abort_cmd != s->event_cmd) {
> + s->event_cmd = NULL;
> + }
> + s->event_count++;
> + return MFI_STAT_OK;
> +}
> +
> +static void megasas_handle_frame(MegasasState *s, uint64_t frame_addr,
> + uint32_t frame_count)
> +{
> + uint8_t frame_status = MFI_STAT_INVALID_CMD;
> + uint64_t frame_context;
> + MegasasCmd *cmd;
> +
> + /*
> + * Always read 64bit context, top bits will be
> + * masked out if required in megasas_enqueue_frame()
> + */
> + frame_context = megasas_frame_get_context(frame_addr);
> +
> + cmd = megasas_enqueue_frame(s, frame_addr, frame_context, frame_count);
> + if (!cmd) {
> + /* reply queue full */
> + trace_megasas_frame_busy(frame_addr);
> + megasas_frame_set_scsi_status(frame_addr, BUSY);
> + megasas_frame_set_cmd_status(frame_addr, MFI_STAT_SCSI_DONE_WITH_ERROR);
> + megasas_complete_frame(s, frame_context);
> + s->event_count++;
> + return;
> + }
> + switch (cmd->frame->header.frame_cmd) {
> + case MFI_CMD_INIT:
> + frame_status = megasas_init_firmware(s, cmd);
> + break;
> + case MFI_CMD_DCMD:
> + frame_status = megasas_handle_dcmd(s, cmd);
> + break;
> + case MFI_CMD_ABORT:
> + frame_status = megasas_handle_abort(s, cmd);
> + break;
> + case MFI_CMD_PD_SCSI_IO:
> + frame_status = megasas_handle_scsi(s, cmd, 0);
> + break;
> + case MFI_CMD_LD_SCSI_IO:
> + frame_status = megasas_handle_scsi(s, cmd, 1);
> + break;
> + case MFI_CMD_LD_READ:
> + case MFI_CMD_LD_WRITE:
> + frame_status = megasas_handle_io(s, cmd);
> + break;
> + default:
> + trace_megasas_unhandled_frame_cmd(cmd->index,
> + cmd->frame->header.frame_cmd);
> + s->event_count++;
> + break;
> + }
> + if (frame_status != MFI_STAT_INVALID_STATUS) {
> + if (cmd->frame) {
> + cmd->frame->header.cmd_status = frame_status;
> + } else {
> + megasas_frame_set_cmd_status(frame_addr, frame_status);
> + }
> + megasas_complete_frame(s, cmd->context);
> + }
> +}
> +
> +static uint64_t megasas_mmio_read(void *opaque, target_phys_addr_t addr,
> + unsigned size)
> +{
> + MegasasState *s = opaque;
> + uint32_t retval = 0;
> +
> + switch (addr) {
> + case MFI_IDB:
> + retval = 0;
> + break;
> + case MFI_OMSG0:
> + case MFI_OSP0:
> + retval = (megasas_use_msix(s) ? MFI_FWSTATE_MSIX_SUPPORTED : 0) |
> + (s->fw_state & MFI_FWSTATE_MASK) |
> + ((s->fw_sge & 0xff) << 16) |
> + (s->fw_cmds & 0xFFFF);
> + break;
> + case MFI_OSTS:
> + if (megasas_intr_enabled(s) && s->doorbell) {
> + retval = MFI_1078_RM | 1;
> + }
> + break;
> + case MFI_OMSK:
> + retval = s->intr_mask;
> + break;
> + case MFI_ODCR0:
> + retval = s->doorbell;
> + break;
> + default:
> + trace_megasas_mmio_invalid_readl(addr);
> + break;
> + }
> + trace_megasas_mmio_readl(addr, retval);
> + return retval;
> +}
> +
> +static void megasas_mmio_write(void *opaque, target_phys_addr_t addr,
> + uint64_t val, unsigned size)
> +{
> + MegasasState *s = opaque;
> + uint64_t frame_addr;
> + uint32_t frame_count;
> + int i;
> +
> + trace_megasas_mmio_writel(addr, val);
> + switch (addr) {
> + case MFI_IDB:
> + if (val & MFI_FWINIT_ABORT) {
> + /* Abort all pending cmds */
> + for (i = 0; i < s->fw_cmds; i++) {
> + megasas_abort_command(&s->frames[i]);
> + }
> + }
> + if (val & MFI_FWINIT_READY) {
> + /* move to FW READY */
> + megasas_soft_reset(s);
> + }
> + if (val & MFI_FWINIT_MFIMODE) {
> + /* discard MFIs */
> + }
> + break;
> + case MFI_OMSK:
> + s->intr_mask = val;
> + if (!megasas_intr_enabled(s) && !msix_enabled(&s->dev)) {
> + trace_megasas_irq_lower();
> + qemu_irq_lower(s->dev.irq[0]);
> + }
> + if (megasas_intr_enabled(s)) {
> + trace_megasas_intr_enabled();
> + } else {
> + trace_megasas_intr_disabled();
> + }
> + break;
> + case MFI_ODCR0:
> + s->doorbell = 0;
> + if (s->producer_pa && megasas_intr_enabled(s)) {
> + /* Update reply queue pointer */
> + trace_megasas_qf_update(s->reply_queue_head, s->busy);
> + stl_le_phys(s->producer_pa, s->reply_queue_head);
> + if (!msix_enabled(&s->dev)) {
> + trace_megasas_irq_lower();
> + qemu_irq_lower(s->dev.irq[0]);
> + }
> + }
> + break;
> + case MFI_IQPH:
> + /* Received high 32 bits of a 64 bit MFI frame address */
> + s->frame_hi = val;
> + break;
> + case MFI_IQPL:
> + /* Received low 32 bits of a 64 bit MFI frame address */
> + case MFI_IQP:
> + /* Received 32 bit MFI frame address */
> + frame_addr = (val & ~0x1F);
> + /* Add possible 64 bit offset */
> + frame_addr |= ((uint64_t)s->frame_hi << 32);
> + s->frame_hi = 0;
> + frame_count = (val >> 1) & 0xF;
> + megasas_handle_frame(s, frame_addr, frame_count);
> + break;
> + default:
> + trace_megasas_mmio_invalid_writel(addr, val);
> + break;
> + }
> +}
> +
> +static const MemoryRegionOps megasas_mmio_ops = {
> + .read = megasas_mmio_read,
> + .write = megasas_mmio_write,
> + .endianness = DEVICE_LITTLE_ENDIAN,
> + .impl = {
> + .min_access_size = 8,
> + .max_access_size = 8,
> + }
> +};
> +
> +static uint64_t megasas_port_read(void *opaque, target_phys_addr_t addr,
> + unsigned size)
> +{
> + return megasas_mmio_read(opaque, addr & 0xff, size);
> +}
> +
> +static void megasas_port_write(void *opaque, target_phys_addr_t addr,
> + uint64_t val, unsigned size)
> +{
> + megasas_mmio_write(opaque, addr & 0xff, val, size);
> +}
> +
> +static const MemoryRegionOps megasas_port_ops = {
> + .read = megasas_port_read,
> + .write = megasas_port_write,
> + .endianness = DEVICE_LITTLE_ENDIAN,
> + .impl = {
> + .min_access_size = 4,
> + .max_access_size = 4,
> + }
> +};
> +
> +static uint64_t megasas_queue_read(void *opaque, target_phys_addr_t addr,
> + unsigned size)
> +{
> + return 0;
> +}
> +
> +static const MemoryRegionOps megasas_queue_ops = {
> + .read = megasas_queue_read,
> + .endianness = DEVICE_LITTLE_ENDIAN,
> + .impl = {
> + .min_access_size = 8,
> + .max_access_size = 8,
> + }
> +};
> +
> +static void megasas_soft_reset(MegasasState *s)
> +{
> + int i;
> + MegasasCmd *cmd;
> +
> + trace_megasas_reset();
> + for (i = 0; i < s->fw_cmds; i++) {
> + cmd = &s->frames[i];
> + megasas_abort_command(cmd);
> + }
> + megasas_reset_frames(s);
> + s->reply_queue_len = s->fw_cmds;
> + s->reply_queue_pa = 0;
> + s->consumer_pa = 0;
> + s->producer_pa = 0;
> + s->fw_state = MFI_FWSTATE_READY;
> + s->doorbell = 0;
> + s->intr_mask = MEGASAS_INTR_DISABLED_MASK;
> + s->frame_hi = 0;
> + s->flags &= ~MEGASAS_MASK_USE_QUEUE64;
> + s->event_count++;
> + s->boot_event = s->event_count;
> +}
> +
> +static void megasas_scsi_reset(DeviceState *dev)
> +{
> + MegasasState *s = DO_UPCAST(MegasasState, dev.qdev, dev);
> +
> + megasas_soft_reset(s);
> +}
> +
> +static const VMStateDescription vmstate_megasas = {
> + .name = "megasas",
> + .version_id = 0,
> + .minimum_version_id = 0,
> + .minimum_version_id_old = 0,
> + .fields = (VMStateField[]) {
> + VMSTATE_PCI_DEVICE(dev, MegasasState),
> +
> + VMSTATE_INT32(fw_state, MegasasState),
> + VMSTATE_INT32(intr_mask, MegasasState),
> + VMSTATE_INT32(doorbell, MegasasState),
> + VMSTATE_UINT64(reply_queue_pa, MegasasState),
> + VMSTATE_UINT64(consumer_pa, MegasasState),
> + VMSTATE_UINT64(producer_pa, MegasasState),
> + VMSTATE_END_OF_LIST()
> + }
> +};
> +
> +static int megasas_scsi_uninit(PCIDevice *d)
> +{
> + MegasasState *s = DO_UPCAST(MegasasState, dev, d);
> +
> +#ifdef USE_MSIX
> + msix_uninit(&s->dev, &s->mmio_io);
> +#endif
> + memory_region_destroy(&s->mmio_io);
> + memory_region_destroy(&s->port_io);
> + memory_region_destroy(&s->queue_io);
> + return 0;
> +}
> +
> +static const struct SCSIBusInfo megasas_scsi_info = {
> + .tcq = true,
> + .max_target = MFI_MAX_LD,
> + .max_lun = 255,
> +
> + .transfer_data = megasas_xfer_complete,
> + .get_sg_list = megasas_get_sg_list,
> + .complete = megasas_command_complete,
> + .cancel = megasas_command_cancel,
> +};
> +
> +static int megasas_scsi_init(PCIDevice *dev)
> +{
> + MegasasState *s = DO_UPCAST(MegasasState, dev, dev);
> + uint8_t *pci_conf;
> + int i, bar_type;
> +
> + pci_conf = s->dev.config;
> +
> + /* PCI latency timer = 0 */
> + pci_conf[PCI_LATENCY_TIMER] = 0;
> + /* Interrupt pin 1 */
> + pci_conf[PCI_INTERRUPT_PIN] = 0x01;
> +
> + memory_region_init_io(&s->mmio_io, &megasas_mmio_ops, s,
> + "megasas-mmio", 0x4000);
> + memory_region_init_io(&s->port_io, &megasas_port_ops, s,
> + "megasas-io", 256);
> + memory_region_init_io(&s->queue_io, &megasas_queue_ops, s,
> + "megasas-queue", 0x40000);
> +
> +#ifdef USE_MSIX
> + /* MSI-X support is currently broken */
> + if (megasas_use_msix(s) &&
> + msix_init(&s->dev, 15, &s->mmio_io, 0, 0x2000)) {
> + s->flags &= ~MEGASAS_MASK_USE_MSIX;
> + }
> +#else
> + s->flags &= ~MEGASAS_MASK_USE_MSIX;
> +#endif
> +
> + bar_type = PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64;
> + pci_register_bar(&s->dev, 0, bar_type, &s->mmio_io);
> + pci_register_bar(&s->dev, 2, PCI_BASE_ADDRESS_SPACE_IO, &s->port_io);
> + pci_register_bar(&s->dev, 3, bar_type, &s->queue_io);
> +
> + if (megasas_use_msix(s)) {
> + msix_vector_use(&s->dev, 0);
> + }
> +
> + if (s->fw_sge >= MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE) {
> + s->fw_sge = MEGASAS_MAX_SGE - MFI_PASS_FRAME_SIZE;
> + } else if (s->fw_sge >= 128 - MFI_PASS_FRAME_SIZE) {
> + s->fw_sge = 128 - MFI_PASS_FRAME_SIZE;
> + } else {
> + s->fw_sge = 64 - MFI_PASS_FRAME_SIZE;
> + }
> + if (s->fw_cmds > MEGASAS_MAX_FRAMES) {
> + s->fw_cmds = MEGASAS_MAX_FRAMES;
> + }
> + trace_megasas_init(s->fw_sge, s->fw_cmds,
> + megasas_use_msix(s) ? "MSI-X" : "INTx",
> + megasas_is_jbod(s) ? "jbod" : "raid");
> + s->fw_luns = (MFI_MAX_LD > MAX_SCSI_DEVS) ?
> + MAX_SCSI_DEVS : MFI_MAX_LD;
> + s->producer_pa = 0;
> + s->consumer_pa = 0;
> + for (i = 0; i < s->fw_cmds; i++) {
> + s->frames[i].index = i;
> + s->frames[i].context = -1;
> + s->frames[i].pa = 0;
> + s->frames[i].state = s;
> + }
> +
> + scsi_bus_new(&s->bus, &dev->qdev, &megasas_scsi_info);
> + scsi_bus_legacy_handle_cmdline(&s->bus);
> + return 0;
> +}
> +
> +static Property megasas_properties[] = {
> + DEFINE_PROP_UINT32("max_sge", MegasasState, fw_sge,
> + MEGASAS_DEFAULT_SGE),
> + DEFINE_PROP_UINT32("max_cmds", MegasasState, fw_cmds,
> + MEGASAS_DEFAULT_FRAMES),
> +#ifdef USE_MSIX
> + DEFINE_PROP_BIT("use_msix", MegasasState, flags,
> + MEGASAS_FLAG_USE_MSIX, false),
> +#endif
> + DEFINE_PROP_BIT("use_jbod", MegasasState, flags,
> + MEGASAS_FLAG_USE_JBOD, false),
> + DEFINE_PROP_END_OF_LIST(),
> +};
> +
> +static void megasas_class_init(ObjectClass *oc, void *data)
> +{
> + DeviceClass *dc = DEVICE_CLASS(oc);
> + PCIDeviceClass *pc = PCI_DEVICE_CLASS(oc);
> +
> + pc->init = megasas_scsi_init;
> + pc->exit = megasas_scsi_uninit;
> + pc->vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
> + pc->device_id = PCI_DEVICE_ID_LSI_SAS1078;
> + pc->subsystem_vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
> + pc->subsystem_id = 0x1013;
> + pc->class_id = PCI_CLASS_STORAGE_RAID;
> + dc->props = megasas_properties;
> + dc->reset = megasas_scsi_reset;
> + dc->vmsd = &vmstate_megasas;
> + dc->desc = "LSI MegaRAID SAS 1078";
> +}
> +
> +static const TypeInfo megasas_info = {
> + .name = "megasas",
> + .parent = TYPE_PCI_DEVICE,
> + .instance_size = sizeof(MegasasState),
> + .class_init = megasas_class_init,
> +};
> +
> +static void megasas_register_types(void)
> +{
> + type_register_static(&megasas_info);
> +}
> +
> +type_init(megasas_register_types)
> diff --git a/hw/pci_ids.h b/hw/pci_ids.h
> index 649e6b3..b4801d2 100644
> --- a/hw/pci_ids.h
> +++ b/hw/pci_ids.h
> @@ -15,6 +15,7 @@
>
> #define PCI_CLASS_STORAGE_SCSI 0x0100
> #define PCI_CLASS_STORAGE_IDE 0x0101
> +#define PCI_CLASS_STORAGE_RAID 0x0104
> #define PCI_CLASS_STORAGE_SATA 0x0106
> #define PCI_CLASS_STORAGE_OTHER 0x0180
>
> @@ -47,6 +48,7 @@
>
> #define PCI_VENDOR_ID_LSI_LOGIC 0x1000
> #define PCI_DEVICE_ID_LSI_53C895A 0x0012
> +#define PCI_DEVICE_ID_LSI_SAS1078 0x0060
>
> #define PCI_VENDOR_ID_DEC 0x1011
> #define PCI_DEVICE_ID_DEC_21154 0x0026
> diff --git a/trace-events b/trace-events
> index c935ba2..bd0ca7e 100644
> --- a/trace-events
> +++ b/trace-events
> @@ -512,6 +512,85 @@ lm32_uart_irq_state(int level) "irq state %d"
> # hw/lm32_sys.c
> lm32_sys_memory_write(uint32_t addr, uint32_t value) "addr 0x%08x value 0x%08x"
>
> +# hw/megasas.c
> +megasas_init_firmware(uint64_t pa) "pa %" PRIx64 " "
> +megasas_init_queue(uint64_t queue_pa, int queue_len, uint64_t head, uint64_t tail, uint32_t flags) "queue at %" PRIx64 " len %d head %" PRIx64 " tail %" PRIx64 " flags %x"
> +megasas_initq_map_failed(int frame) "scmd %d: failed to map queue"
> +megasas_initq_mismatch(int queue_len, int fw_cmds) "queue size %d max fw cmds %d"
> +megasas_qf_found(unsigned int index, uint64_t pa) "found mapped frame %x pa %" PRIx64 ""
> +megasas_qf_new(unsigned int index, void *cmd) "return new frame %x cmd %p"
> +megasas_qf_failed(unsigned long pa) "all frames busy for frame %lx"
> +megasas_qf_enqueue(unsigned int index, unsigned int count, uint64_t context, unsigned int tail, int busy) "enqueue frame %x count %d context %" PRIx64 " tail %x busy %d"
> +megasas_qf_update(unsigned int head, unsigned int busy) "update reply queue head %x busy %d"
> +megasas_qf_dequeue(unsigned int index) "dequeue frame %x"
> +megasas_qf_map_failed(int cmd, unsigned long frame) "scmd %d: frame %lu"
> +megasas_qf_complete_noirq(uint64_t context) "context %" PRIx64 " "
> +megasas_qf_complete(uint64_t context, unsigned int tail, unsigned int offset, int busy, unsigned int doorbell) "context %" PRIx64 " tail %x offset %d busy %d doorbell %x"
> +megasas_handle_frame(const char *cmd, uint64_t addr, uint64_t context, uint32_t count) "MFI cmd %s addr %" PRIx64 " context %" PRIx64 " count %d"
> +megasas_frame_busy(uint64_t addr) "frame %" PRIx64 " busy"
> +megasas_unhandled_frame_cmd(int cmd, uint8_t frame_cmd) "scmd %d: Unhandled MFI cmd %x"
> +megasas_handle_scsi(const char *frame, int bus, int dev, int lun, void *sdev, unsigned long size) "%s dev %x/%x/%x sdev %p xfer %lu"
> +megasas_scsi_target_not_present(const char *frame, int bus, int dev, int lun) "%s dev %x/%x/%x target not present"
> +megasas_scsi_invalid_cdb_len(const char *frame, int bus, int dev, int lun, int len) "%s dev %x/%x/%x invalid cdb len %d"
> +megasas_iov_read_overflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
> +megasas_iov_write_overflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
> +megasas_iov_read_underflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
> +megasas_iov_write_underflow(int cmd, int bytes, int len) "scmd %d: %d/%d bytes"
> +megasas_scsi_req_alloc_failed(const char *frame, int dev, int lun) "%s dev %x/%x req allocation failed"
> +megasas_scsi_read_start(int cmd, int len) "scmd %d: transfer %d bytes of data"
> +megasas_scsi_write_start(int cmd, int len) "scmd %d: transfer %d bytes of data"
> +megasas_scsi_nodata(int cmd) "scmd %d: no data to be transferred"
> +megasas_scsi_complete(int cmd, uint32_t status, int len, int xfer) "scmd %d: finished with status %x, len %u/%u"
> +megasas_command_complete(int cmd, uint32_t status, uint32_t resid) "scmd %d: command completed, status %x, residual %d"
> +megasas_handle_io(int cmd, const char *frame, int dev, int lun, unsigned long lba, unsigned long count) "scmd %d: %s dev %x/%x lba %lx count %lu"
> +megasas_io_target_not_present(int cmd, const char *frame, int dev, int lun) "scmd %d: %s dev 1/%x/%x LUN not present"
> +megasas_io_read_start(int cmd, unsigned long lba, unsigned long count, unsigned long len) "scmd %d: start LBA %lx %lu blocks (%lu bytes)"
> +megasas_io_write_start(int cmd, unsigned long lba, unsigned long count, unsigned long len) "scmd %d: start LBA %lx %lu blocks (%lu bytes)"
> +megasas_io_complete(int cmd, uint32_t len) "scmd %d: %d bytes completed"
> +megasas_io_read(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu"
> +megasas_io_write(int cmd, int bytes, int len, unsigned long offset) "scmd %d: %d/%d bytes, iov offset %lu"
> +megasas_io_continue(int cmd, int bytes) "scmd %d: %d bytes left"
> +megasas_iovec_map_failed(int cmd, int index, unsigned long iov_size) "scmd %d: iovec %d size %lu"
> +megasas_iovec_sgl_overflow(int cmd, int index, int limit) "scmd %d: iovec count %d limit %d"
> +megasas_iovec_sgl_underflow(int cmd, int index) "scmd %d: iovec count %d"
> +megasas_iovec_sgl_invalid(int cmd, int index, uint64_t pa, uint32_t len) "scmd %d: element %d pa %" PRIx64 " len %u"
> +megasas_iovec_overflow(int cmd, int len, int limit) "scmd %d: len %d limit %d"
> +megasas_iovec_underflow(int cmd, int len, int limit) "scmd %d: len %d limit %d"
> +megasas_handle_dcmd(int cmd, int opcode) "scmd %d: MFI DCMD opcode %x"
> +megasas_finish_dcmd(int cmd, int size) "scmd %d: MFI DCMD wrote %d bytes"
> +megasas_dcmd_req_alloc_failed(int cmd, const char *desc) "scmd %d: %s alloc failed"
> +megasas_dcmd_internal_submit(int cmd, const char *desc, int dev) "scmd %d: %s to dev %d"
> +megasas_dcmd_internal_finish(int cmd, int opcode, int lun) "scmd %d: DCMD finish internal cmd %x lun %d"
> +megasas_dcmd_internal_invalid(int cmd, int opcode) "scmd %d: Invalid internal DCMD %x"
> +megasas_dcmd_unhandled(int cmd, int opcode, int len) "scmd %d: opcode %x, len %d"
> +megasas_dcmd_zero_sge(int cmd) "scmd %d: zero DCMD sge count"
> +megasas_dcmd_invalid_sge(int cmd, int count) "scmd %d: invalid DCMD sge count %d"
> +megasas_dcmd_map_failed(int cmd) "scmd %d: Failed to map DCMD buffer"
> +megasas_dcmd_invalid_xfer_len(int cmd, unsigned long size, unsigned long max) "scmd %d: invalid xfer len %ld, max %ld"
> +megasas_dcmd_enter(int cmd, const char *dcmd, int len) "scmd %d: DCMD %s len %d"
> +megasas_dcmd_dummy(int cmd, unsigned long size) "scmd %d: DCMD dummy xfer len %ld"
> +megasas_dcmd_set_fw_time(int cmd, unsigned long time) "scmd %d: Set FW time %lx"
> +megasas_dcmd_pd_get_list(int cmd, int num, int max, int offset) "scmd %d: DCMD PD get list: %d / %d PDs, size %d"
> +megasas_dcmd_ld_get_list(int cmd, int num, int max) "scmd %d: DCMD LD get list: found %d / %d LDs"
> +megasas_dcmd_ld_get_info(int cmd, int ld_id) "scmd %d: DCMD LD get info for dev %d"
> +megasas_dcmd_pd_get_info(int cmd, int pd_id) "scmd %d: DCMD PD get info for dev %d"
> +megasas_dcmd_pd_list_query(int cmd, int flags) "scmd %d: DCMD PD list query flags %x"
> +megasas_dcmd_dump_frame(int offset, char f0, char f1, char f2, char f3, char f4, char f5, char f6, char f7) "0x%x: %02x %02x %02x %02x %02x %02x %02x %02x"
> +megasas_abort_frame(int cmd, int abort_cmd) "scmd %d: aborting frame %x"
> +megasas_abort_no_cmd(int cmd, uint64_t context) "scmd %d: no active command for frame context %" PRIx64 ""
> +megasas_abort_invalid_context(int cmd, uint64_t context, int abort_cmd) "scmd %d: invalid frame context %" PRIx64 " for abort frame %x"
> +megasas_reset(void) "Reset"
> +megasas_init(int sges, int cmds, const char *intr, const char *mode) "Using %d sges, %d cmds, %s, %s mode"
> +megasas_msix_raise(int vector) "vector %d"
> +megasas_irq_lower(void) "INTx"
> +megasas_irq_raise(void) "INTx"
> +megasas_intr_enabled(void) "Interrupts enabled"
> +megasas_intr_disabled(void) "Interrupts disabled"
> +megasas_mmio_readl(unsigned long addr, uint32_t val) "addr 0x%lx: 0x%x"
> +megasas_mmio_invalid_readl(unsigned long addr) "addr 0x%lx"
> +megasas_mmio_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x"
> +megasas_mmio_invalid_writel(uint32_t addr, uint32_t val) "addr 0x%x: 0x%x"
> +
> # hw/milkymist-ac97.c
> milkymist_ac97_memory_read(uint32_t addr, uint32_t value) "addr %08x value %08x"
> milkymist_ac97_memory_write(uint32_t addr, uint32_t value) "addr %08x value %08x"
> --
> 1.7.10.2
>
>
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-02 9:41 ` [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN Paolo Bonzini
@ 2012-07-03 19:09 ` Blue Swirl
2012-07-04 7:33 ` Paolo Bonzini
0 siblings, 1 reply; 32+ messages in thread
From: Blue Swirl @ 2012-07-03 19:09 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: qemu-devel
On Mon, Jul 2, 2012 at 9:41 AM, Paolo Bonzini <pbonzini@redhat.com> wrote:
> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
> ---
> hw/scsi-disk.c | 14 +++++++++++++-
> 1 file changed, 13 insertions(+), 1 deletion(-)
>
> diff --git a/hw/scsi-disk.c b/hw/scsi-disk.c
> index 747e756..e87e57c 100644
> --- a/hw/scsi-disk.c
> +++ b/hw/scsi-disk.c
> @@ -67,6 +67,7 @@ struct SCSIDiskState
> bool media_changed;
> bool media_event;
> bool eject_request;
> + uint64_t wwn;
> QEMUBH *bh;
> char *version;
> char *serial;
> @@ -587,9 +588,17 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
> outbuf[buflen++] = 0; // not officially assigned
> outbuf[buflen++] = 0; // reserved
> outbuf[buflen++] = id_len; // length of data following
> -
> memcpy(outbuf+buflen, str, id_len);
> buflen += id_len;
> +
> + if (s->wwn) {
> + outbuf[buflen++] = 0x1; // Binary
> + outbuf[buflen++] = 0x3; // NAA
> + outbuf[buflen++] = 0; // reserved
C99 comments.
> + outbuf[buflen++] = 8;
> + stq_be_p(&outbuf[buflen], s->wwn);
> + buflen += 8;
> + }
> break;
> }
> case 0xb0: /* block limits */
> @@ -1924,6 +1933,7 @@ static Property scsi_hd_properties[] = {
> SCSI_DISK_F_REMOVABLE, false),
> DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
> SCSI_DISK_F_DPOFUA, false),
> + DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
> DEFINE_PROP_END_OF_LIST(),
> };
>
> @@ -1968,6 +1978,7 @@ static TypeInfo scsi_hd_info = {
>
> static Property scsi_cd_properties[] = {
> DEFINE_SCSI_DISK_PROPERTIES(),
> + DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
> DEFINE_PROP_END_OF_LIST(),
> };
>
> @@ -2029,6 +2040,7 @@ static Property scsi_disk_properties[] = {
> SCSI_DISK_F_REMOVABLE, false),
> DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
> SCSI_DISK_F_DPOFUA, false),
> + DEFINE_PROP_HEX64("wwn", SCSIDiskState, wwn, 0),
> DEFINE_PROP_END_OF_LIST(),
> };
>
> --
> 1.7.10.2
>
>
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation
2012-07-03 19:09 ` Blue Swirl
@ 2012-07-04 5:52 ` Hannes Reinecke
2012-07-04 7:33 ` Paolo Bonzini
0 siblings, 1 reply; 32+ messages in thread
From: Hannes Reinecke @ 2012-07-04 5:52 UTC (permalink / raw)
To: Blue Swirl; +Cc: Paolo Bonzini, qemu-devel
On 07/03/2012 09:09 PM, Blue Swirl wrote:
> On Mon, Jul 2, 2012 at 9:41 AM, Paolo Bonzini <pbonzini@redhat.com> wrote:
>> From: Hannes Reinecke <hare@suse.de>
>>
>> This patch adds an emulation for the LSI Megaraid SAS 8708EM2 HBA.
>> I've tested it to work with Linux, Windows Vista, and Windows7.
>>
>> Signed-off-by: Hannes Reinecke <hare@suse.de>
>> [ Squashed tracing patch (no need to keep it separate) and trivial changes
>> from Andreas Faerber. Rebased over IOMMU and QBus changes. - Paolo ]
>> Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
>> ---
>> default-configs/pci.mak | 1 +
>> hw/Makefile.objs | 1 +
>> hw/megasas.c | 2198 +++++++++++++++++++++++++++++++++++++++++++++++
>> hw/pci_ids.h | 2 +
>> trace-events | 79 ++
>> 5 files changed, 2281 insertions(+)
>> create mode 100644 hw/megasas.c
>>
>> diff --git a/default-configs/pci.mak b/default-configs/pci.mak
>> index 9d3e1db..4b49c00 100644
>> --- a/default-configs/pci.mak
>> +++ b/default-configs/pci.mak
>> @@ -10,6 +10,7 @@ CONFIG_EEPRO100_PCI=y
>> CONFIG_PCNET_PCI=y
>> CONFIG_PCNET_COMMON=y
>> CONFIG_LSI_SCSI_PCI=y
>> +CONFIG_MEGASAS_SCSI_PCI=y
>> CONFIG_RTL8139_PCI=y
>> CONFIG_E1000_PCI=y
>> CONFIG_IDE_CORE=y
>> diff --git a/hw/Makefile.objs b/hw/Makefile.objs
>> index 3d77259..9a350de 100644
>> --- a/hw/Makefile.objs
>> +++ b/hw/Makefile.objs
>> @@ -86,6 +86,7 @@ hw-obj-$(CONFIG_OPENCORES_ETH) += opencores_eth.o
>>
>> # SCSI layer
>> hw-obj-$(CONFIG_LSI_SCSI_PCI) += lsi53c895a.o
>> +hw-obj-$(CONFIG_MEGASAS_SCSI_PCI) += megasas.o
>> hw-obj-$(CONFIG_ESP) += esp.o
>>
>> hw-obj-y += sysbus.o isa-bus.o
>> diff --git a/hw/megasas.c b/hw/megasas.c
>> new file mode 100644
>> index 0000000..b48836f
>> --- /dev/null
>> +++ b/hw/megasas.c
>> @@ -0,0 +1,2198 @@
>> +/*
>> + * QEMU MegaRAID SAS 8708EM2 Host Bus Adapter emulation
>> + * Based on the linux driver code at drivers/scsi/megaraid
>> + *
>> + * Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs
>> + *
>> + * This library is free software; you can redistribute it and/or
>> + * modify it under the terms of the GNU Lesser General Public
>> + * License as published by the Free Software Foundation; either
>> + * version 2 of the License, or (at your option) any later version.
>> + *
>> + * This library is distributed in the hope that it will be useful,
>> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
>> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
>> + * Lesser General Public License for more details.
>> + *
>> + * You should have received a copy of the GNU Lesser General Public
>> + * License along with this library; if not, see <http://www.gnu.org/licenses/>.
>> + */
>> +
>> +#include "hw.h"
>> +#include "pci.h"
>> +#include "dma.h"
>> +#include "msix.h"
>> +#include "iov.h"
>> +#include "scsi.h"
>> +#include "scsi-defs.h"
>> +#include "block_int.h"
>> +#include "trace.h"
>> +
>> +#include "mfi.h"
>
> A pointer to chip set docs would be nice.
>
Oh, do you have some?
I would _love_ to add it, what with me having developed this
thing without it ...
No, seriously: I haven't managed to get any documentation for
this beast. LSI hasn't been exactly forthcoming with help here.
[ .. ]
>> +
>> +const char *mfi_frame_desc[] = {
>
> Missing 'static'.
>
If you insist ...
[ .. ]
Hey, cool. Just one issue.
Paolo, can you fix it up in your tree or should I re-send the patch?
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation
2012-07-04 5:52 ` Hannes Reinecke
@ 2012-07-04 7:33 ` Paolo Bonzini
2012-07-05 6:46 ` Hannes Reinecke
0 siblings, 1 reply; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-04 7:33 UTC (permalink / raw)
To: Hannes Reinecke; +Cc: Blue Swirl, qemu-devel
Il 04/07/2012 07:52, Hannes Reinecke ha scritto:
>>> >> +const char *mfi_frame_desc[] = {
>> >
>> > Missing 'static'.
>> >
> If you insist ...
>
> [ .. ]
>
> Hey, cool. Just one issue.
>
> Paolo, can you fix it up in your tree or should I re-send the patch?
Neither. Send the fix to qemu-trivial on top of my tree.
Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-03 19:09 ` Blue Swirl
@ 2012-07-04 7:33 ` Paolo Bonzini
2012-07-05 18:03 ` Blue Swirl
0 siblings, 1 reply; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-04 7:33 UTC (permalink / raw)
To: Blue Swirl; +Cc: qemu-devel
Il 03/07/2012 21:09, Blue Swirl ha scritto:
>> > @@ -587,9 +588,17 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
>> > outbuf[buflen++] = 0; // not officially assigned
>> > outbuf[buflen++] = 0; // reserved
>> > outbuf[buflen++] = id_len; // length of data following
>> > -
>> > memcpy(outbuf+buflen, str, id_len);
>> > buflen += id_len;
>> > +
>> > + if (s->wwn) {
>> > + outbuf[buflen++] = 0x1; // Binary
>> > + outbuf[buflen++] = 0x3; // NAA
>> > + outbuf[buflen++] = 0; // reserved
> C99 comments.
>
Just following the style of this code. Feel free to send a patch to
replace with #defines.
Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation
2012-07-04 7:33 ` Paolo Bonzini
@ 2012-07-05 6:46 ` Hannes Reinecke
0 siblings, 0 replies; 32+ messages in thread
From: Hannes Reinecke @ 2012-07-05 6:46 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: Blue Swirl, qemu-devel
On 07/04/2012 09:33 AM, Paolo Bonzini wrote:
> Il 04/07/2012 07:52, Hannes Reinecke ha scritto:
>>>>>> +const char *mfi_frame_desc[] = {
>>>>
>>>> Missing 'static'.
>>>>
>> If you insist ...
>>
>> [ .. ]
>>
>> Hey, cool. Just one issue.
>>
>> Paolo, can you fix it up in your tree or should I re-send the patch?
>
> Neither. Send the fix to qemu-trivial on top of my tree.
>
Done.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-04 7:33 ` Paolo Bonzini
@ 2012-07-05 18:03 ` Blue Swirl
2012-07-06 7:05 ` Paolo Bonzini
0 siblings, 1 reply; 32+ messages in thread
From: Blue Swirl @ 2012-07-05 18:03 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: qemu-devel
On Wed, Jul 4, 2012 at 7:33 AM, Paolo Bonzini <pbonzini@redhat.com> wrote:
> Il 03/07/2012 21:09, Blue Swirl ha scritto:
>>> > @@ -587,9 +588,17 @@ static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
>>> > outbuf[buflen++] = 0; // not officially assigned
>>> > outbuf[buflen++] = 0; // reserved
>>> > outbuf[buflen++] = id_len; // length of data following
>>> > -
>>> > memcpy(outbuf+buflen, str, id_len);
>>> > buflen += id_len;
>>> > +
>>> > + if (s->wwn) {
>>> > + outbuf[buflen++] = 0x1; // Binary
>>> > + outbuf[buflen++] = 0x3; // NAA
>>> > + outbuf[buflen++] = 0; // reserved
>> C99 comments.
>>
>
> Just following the style of this code. Feel free to send a patch to
> replace with #defines.
That's not how we should work. New code should be compliant with our
goals. Pushing the responsibility for fixing issues to other people
does not scale.
>
> Paolo
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-05 18:03 ` Blue Swirl
@ 2012-07-06 7:05 ` Paolo Bonzini
2012-07-07 7:48 ` Blue Swirl
0 siblings, 1 reply; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-06 7:05 UTC (permalink / raw)
To: Blue Swirl; +Cc: qemu-devel
Il 05/07/2012 20:03, Blue Swirl ha scritto:
> > > > + if (s->wwn) {
> > > > + outbuf[buflen++] = 0x1; // Binary
> > > > + outbuf[buflen++] = 0x3; // NAA
> > > > + outbuf[buflen++] = 0; // reserved
> > >
> > > C99 comments.
> >
> > Just following the style of this code. Feel free to send a patch to
> > replace with #defines.
>
> That's not how we should work. New code should be compliant with our
> goals. Pushing the responsibility for fixing issues to other people
> does not scale.
I believe the coding style are attacking the wrong problem. It's
end-of-line comments that should be avoided in favor of #defines, packed
structs, designated initializers, etc. But for end-of-line comments,
C++ comments are superior to /* */ comments.
I do plan to fix the clarity issue with SCSI data structures and
constants. But for now, the best compromise is to keep C++ comments
IMHO. I'm not pushing the responsibility to other people in general,
but if they think C++ comments are a major issue they can send patches.
Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-06 7:05 ` Paolo Bonzini
@ 2012-07-07 7:48 ` Blue Swirl
2012-07-07 12:22 ` Paolo Bonzini
0 siblings, 1 reply; 32+ messages in thread
From: Blue Swirl @ 2012-07-07 7:48 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: qemu-devel
On Fri, Jul 6, 2012 at 7:05 AM, Paolo Bonzini <pbonzini@redhat.com> wrote:
> Il 05/07/2012 20:03, Blue Swirl ha scritto:
>> > > > + if (s->wwn) {
>> > > > + outbuf[buflen++] = 0x1; // Binary
>> > > > + outbuf[buflen++] = 0x3; // NAA
>> > > > + outbuf[buflen++] = 0; // reserved
>> > >
>> > > C99 comments.
>> >
>> > Just following the style of this code. Feel free to send a patch to
>> > replace with #defines.
>>
>> That's not how we should work. New code should be compliant with our
>> goals. Pushing the responsibility for fixing issues to other people
>> does not scale.
>
> I believe the coding style are attacking the wrong problem. It's
> end-of-line comments that should be avoided in favor of #defines, packed
> structs, designated initializers, etc.
This applies to C89 comments too. Perhaps HACKING file should mention this.
> But for end-of-line comments,
> C++ comments are superior to /* */ comments.
Well, submit a change to CODING_STYLE then. I think the only places
where C99 is better are lines like
//#define DEBUG_XYZ
>
> I do plan to fix the clarity issue with SCSI data structures and
> constants. But for now, the best compromise is to keep C++ comments
> IMHO. I'm not pushing the responsibility to other people in general,
> but if they think C++ comments are a major issue they can send patches.
When you add them in new code, that is a problem. New code should
comply with CODING_STYLE, code with other styles should be converted
as it is touched.
It shouldn't be much effort from your part to change the comments in
this patch to C89 style.
>
> Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN
2012-07-07 7:48 ` Blue Swirl
@ 2012-07-07 12:22 ` Paolo Bonzini
0 siblings, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-07 12:22 UTC (permalink / raw)
To: Blue Swirl; +Cc: qemu-devel
Il 07/07/2012 09:48, Blue Swirl ha scritto:
>> > I do plan to fix the clarity issue with SCSI data structures and
>> > constants. But for now, the best compromise is to keep C++ comments
>> > IMHO. I'm not pushing the responsibility to other people in general,
>> > but if they think C++ comments are a major issue they can send patches.
> When you add them in new code, that is a problem. New code should
> comply with CODING_STYLE, code with other styles should be converted
> as it is touched.
>
> It shouldn't be much effort from your part to change the comments in
> this patch to C89 style.
Sure, but that would be the wrong fix.
The right fix is to augment scsi-defs.h, and avoid the need for comments
completely.
Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
` (13 preceding siblings ...)
2012-07-02 9:41 ` [Qemu-devel] [PATCH 14/14] scsi: Fix transfer length for READ POSITION commands Paolo Bonzini
@ 2012-07-09 16:48 ` Anthony Liguori
2012-07-09 23:09 ` Alexander Graf
14 siblings, 1 reply; 32+ messages in thread
From: Anthony Liguori @ 2012-07-09 16:48 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: qemu-devel
On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
> Anthony,
>
> The following changes since commit 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>
> bsd-user: fix build (2012-06-28 20:28:36 +0000)
Pulled. Thanks.
Regards,
Anthony Liguori
>
> are available in the git repository at:
>
> git://github.com/bonzini/qemu.git scsi-next
>
> for you to fetch changes up to 9ce1bb2d36f24af79d2757497acbaf4dc4a2e302:
>
> scsi: Fix transfer length for READ POSITION commands. (2012-07-02 11:27:00 +0200)
>
> The MegaSAS changes are rebased and it includes improved support for
> SCSI tape and media changer commands.
>
> ----------------------------------------------------------------
> Christian Hoff (4):
> scsi: Fix data length == SCSI_SENSE_BUF_SIZE
> scsi: Fix LOAD_UNLOAD
> scsi: Add basic support for SCSI media changer commands.
> scsi: Fix transfer length for READ POSITION commands.
>
> Hannes Reinecke (2):
> megasas: Add header file
> megasas: LSI Megaraid SAS HBA emulation
>
> Paolo Bonzini (6):
> scsi: simplify handling of the VPD page length field
> scsi: add a qdev property for the disk's WWN
> atapi: implement READ DISC INFORMATION
> scsi-disk: implement READ DISC INFORMATION
> virtio-scsi: do not crash on adding buffers to the event queue
> scsi: Ensure command and transfer lengths are set for all SCSI devices
>
> Ronnie Sahlberg (2):
> ISCSI: Add SCSI passthrough via scsi-generic to libiscsi
> ISCSI: force use of sg for SMC and SSC devices
>
> block/iscsi.c | 152 ++++
> default-configs/pci.mak | 1 +
> hw/Makefile.objs | 1 +
> hw/ide/atapi.c | 31 +
> hw/megasas.c | 2198 +++++++++++++++++++++++++++++++++++++++++++++++
> hw/mfi.h | 1248 +++++++++++++++++++++++++++
> hw/pci_ids.h | 2 +
> hw/scsi-bus.c | 94 +-
> hw/scsi-defs.h | 15 +-
> hw/scsi-disk.c | 69 +-
> hw/scsi-generic.c | 13 +-
> hw/virtio-scsi.c | 6 +-
> trace-events | 79 ++
> 13 files changed, 3872 insertions(+), 37 deletions(-)
> create mode 100644 hw/megasas.c
> create mode 100644 hw/mfi.h
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-09 16:48 ` [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Anthony Liguori
@ 2012-07-09 23:09 ` Alexander Graf
2012-07-09 23:19 ` Anthony Liguori
0 siblings, 1 reply; 32+ messages in thread
From: Alexander Graf @ 2012-07-09 23:09 UTC (permalink / raw)
To: Anthony Liguori; +Cc: Paolo Bonzini, qemu-devel qemu-devel, Hannes Reinecke
On 09.07.2012, at 18:48, Anthony Liguori wrote:
> On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
>> Anthony,
>>
>> The following changes since commit 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>>
>> bsd-user: fix build (2012-06-28 20:28:36 +0000)
>
> Pulled. Thanks.
Megasas? :)
http://buildbot.b1-systems.de/qemu/builders/default_i386_rhel61/builds/304/steps/compile/logs/stdio
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-09 23:09 ` Alexander Graf
@ 2012-07-09 23:19 ` Anthony Liguori
2012-07-10 5:57 ` Hannes Reinecke
0 siblings, 1 reply; 32+ messages in thread
From: Anthony Liguori @ 2012-07-09 23:19 UTC (permalink / raw)
To: Alexander Graf; +Cc: Paolo Bonzini, qemu-devel qemu-devel, Hannes Reinecke
On 07/09/2012 06:09 PM, Alexander Graf wrote:
>
> On 09.07.2012, at 18:48, Anthony Liguori wrote:
>
>> On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
>>> Anthony,
>>>
>>> The following changes since commit 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>>>
>>> bsd-user: fix build (2012-06-28 20:28:36 +0000)
>>
>> Pulled. Thanks.
>
> Megasas? :)
So this code is really broken:
info.host.type = MFI_INFO_HOST_PCIX;
info.device.type = MFI_INFO_DEV_SAS3G;
info.device.port_count = 2;
info.device.port_addr[0] = cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
This will make migration impossible not to mention the fact that casting a
pointer to a uint64_t is really broken.
This code needs to be refactored to not do this. It's quite pervasive though
(there's a half a dozen instances like this).
I'm going to disable the build by default. I don't want to see a rash fix like
(uint64_t)(intptr_t). This needs to be fixed by not making the pointer address
guest visible. It can then be re-enabled. Should be easy enough to update your
.mak config if you want to test between now and then.
Regards,
Anthony Liguori
>
>
> http://buildbot.b1-systems.de/qemu/builders/default_i386_rhel61/builds/304/steps/compile/logs/stdio
>
>
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-09 23:19 ` Anthony Liguori
@ 2012-07-10 5:57 ` Hannes Reinecke
2012-07-10 7:06 ` Paolo Bonzini
2012-07-10 12:52 ` Anthony Liguori
0 siblings, 2 replies; 32+ messages in thread
From: Hannes Reinecke @ 2012-07-10 5:57 UTC (permalink / raw)
To: Anthony Liguori; +Cc: Paolo Bonzini, Alexander Graf, qemu-devel qemu-devel
On 07/10/2012 01:19 AM, Anthony Liguori wrote:
> On 07/09/2012 06:09 PM, Alexander Graf wrote:
>>
>> On 09.07.2012, at 18:48, Anthony Liguori wrote:
>>
>>> On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
>>>> Anthony,
>>>>
>>>> The following changes since commit
>>>> 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>>>>
>>>> bsd-user: fix build (2012-06-28 20:28:36 +0000)
>>>
>>> Pulled. Thanks.
>>
>> Megasas? :)
>
> So this code is really broken:
>
> info.host.type = MFI_INFO_HOST_PCIX;
> info.device.type = MFI_INFO_DEV_SAS3G;
> info.device.port_count = 2;
> info.device.port_addr[0] =
> cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
>
> This will make migration impossible not to mention the fact that
> casting a pointer to a uint64_t is really broken.
>
Hey, this is _NOT_ an address. It's a simple way of generating a
system-wide unique SAS address.
The whole thing is informational anyway, and can only be seen when
using the (proprietary) MegaCLI userspace command.
> This code needs to be refactored to not do this. It's quite
> pervasive though (there's a half a dozen instances like this).
>
Okay, so here's the challenge: We need to generate a system-wide
unique SAS address, one per SCSI device and one per megasas instance.
A simple counter won't work, as we might have several qemu instances
running. Which would result in all of them having the same SAS
address for the host.
> I'm going to disable the build by default. I don't want to see a
> rash fix like (uint64_t)(intptr_t). This needs to be fixed by not
> making the pointer address guest visible. It can then be
> re-enabled. Should be easy enough to update your .mak config if you
> want to test between now and then.
>
As said, it's _not_ an address. The address it just use to seed the
SAS address.
But as you object, I see to use something else for seeding the SAS
address.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-10 5:57 ` Hannes Reinecke
@ 2012-07-10 7:06 ` Paolo Bonzini
2012-07-10 12:52 ` Anthony Liguori
1 sibling, 0 replies; 32+ messages in thread
From: Paolo Bonzini @ 2012-07-10 7:06 UTC (permalink / raw)
To: Hannes Reinecke; +Cc: Alexander Graf, Anthony Liguori, qemu-devel qemu-devel
Il 10/07/2012 07:57, Hannes Reinecke ha scritto:
>> > This will make migration impossible not to mention the fact that
>> > casting a pointer to a uint64_t is really broken.
>> >
> Hey, this is _NOT_ an address. It's a simple way of generating a
> system-wide unique SAS address.
>
> The whole thing is informational anyway, and can only be seen when
> using the (proprietary) MegaCLI userspace command.
So even on real hardware it is not exported to the VPD (in the case of
the per-LUN address)? And the per-port address is also not visible in VPD?
I recently added a wwn property to scsi-{hd,cd}, a similar property
should perhaps be added to the megasas device. We can do the same thing
and add a default. Not the pointer value, though, because it is not
migratable. A counter is also problematic for migration when you have
hotplug/hotunplug. You can instead use something like a CRC32 of the
device id.
Once it's added, we can add support for it in SCSIBusInfo so that it is
exported via VPD.
> Okay, so here's the challenge: We need to generate a system-wide
> unique SAS address, one per SCSI device and one per megasas instance.
> A simple counter won't work, as we might have several qemu instances
> running. Which would result in all of them having the same SAS
> address for the host.
That's not a problem as long as we're not supporting things like
persistent reservations across guests (just like it's not a problem if
you give the same MAC address to network cards with slirp).
Paolo
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-10 5:57 ` Hannes Reinecke
2012-07-10 7:06 ` Paolo Bonzini
@ 2012-07-10 12:52 ` Anthony Liguori
2012-07-10 13:01 ` Hannes Reinecke
1 sibling, 1 reply; 32+ messages in thread
From: Anthony Liguori @ 2012-07-10 12:52 UTC (permalink / raw)
To: Hannes Reinecke; +Cc: Paolo Bonzini, Alexander Graf, qemu-devel qemu-devel
On 07/10/2012 12:57 AM, Hannes Reinecke wrote:
> On 07/10/2012 01:19 AM, Anthony Liguori wrote:
>> On 07/09/2012 06:09 PM, Alexander Graf wrote:
>>>
>>> On 09.07.2012, at 18:48, Anthony Liguori wrote:
>>>
>>>> On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
>>>>> Anthony,
>>>>>
>>>>> The following changes since commit
>>>>> 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>>>>>
>>>>> bsd-user: fix build (2012-06-28 20:28:36 +0000)
>>>>
>>>> Pulled. Thanks.
>>>
>>> Megasas? :)
>>
>> So this code is really broken:
>>
>> info.host.type = MFI_INFO_HOST_PCIX;
>> info.device.type = MFI_INFO_DEV_SAS3G;
>> info.device.port_count = 2;
>> info.device.port_addr[0] =
>> cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
>>
>> This will make migration impossible not to mention the fact that
>> casting a pointer to a uint64_t is really broken.
>>
> Hey, this is _NOT_ an address. It's a simple way of generating a
> system-wide unique SAS address.
But it's not stable across migration. That's the problem.
> The whole thing is informational anyway, and can only be seen when
> using the (proprietary) MegaCLI userspace command.
Nonetheless, it's still guest visible.
>> This code needs to be refactored to not do this. It's quite
>> pervasive though (there's a half a dozen instances like this).
>>
>
> Okay, so here's the challenge: We need to generate a system-wide
> unique SAS address, one per SCSI device and one per megasas instance.
> A simple counter won't work, as we might have several qemu instances
> running. Which would result in all of them having the same SAS
> address for the host.
You could used a hashed uuid.
Regards,
Anthony Liguori
>
>> I'm going to disable the build by default. I don't want to see a
>> rash fix like (uint64_t)(intptr_t). This needs to be fixed by not
>> making the pointer address guest visible. It can then be
>> re-enabled. Should be easy enough to update your .mak config if you
>> want to test between now and then.
>>
> As said, it's _not_ an address. The address it just use to seed the
> SAS address.
>
> But as you object, I see to use something else for seeding the SAS
> address.
>
> Cheers,
>
> Hannes
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02
2012-07-10 12:52 ` Anthony Liguori
@ 2012-07-10 13:01 ` Hannes Reinecke
0 siblings, 0 replies; 32+ messages in thread
From: Hannes Reinecke @ 2012-07-10 13:01 UTC (permalink / raw)
To: Anthony Liguori; +Cc: Paolo Bonzini, Alexander Graf, qemu-devel qemu-devel
On 07/10/2012 02:52 PM, Anthony Liguori wrote:
> On 07/10/2012 12:57 AM, Hannes Reinecke wrote:
>> On 07/10/2012 01:19 AM, Anthony Liguori wrote:
>>> On 07/09/2012 06:09 PM, Alexander Graf wrote:
>>>>
>>>> On 09.07.2012, at 18:48, Anthony Liguori wrote:
>>>>
>>>>> On 07/02/2012 04:41 AM, Paolo Bonzini wrote:
>>>>>> Anthony,
>>>>>>
>>>>>> The following changes since commit
>>>>>> 71ea2e016131a9fcde6f1ffd3e0e34a64c21f593:
>>>>>>
>>>>>> bsd-user: fix build (2012-06-28 20:28:36 +0000)
>>>>>
>>>>> Pulled. Thanks.
>>>>
>>>> Megasas? :)
>>>
>>> So this code is really broken:
>>>
>>> info.host.type = MFI_INFO_HOST_PCIX;
>>> info.device.type = MFI_INFO_DEV_SAS3G;
>>> info.device.port_count = 2;
>>> info.device.port_addr[0] =
>>> cpu_to_le64(megasas_gen_sas_addr((uint64_t)s));
>>>
>>> This will make migration impossible not to mention the fact that
>>> casting a pointer to a uint64_t is really broken.
>>>
>> Hey, this is _NOT_ an address. It's a simple way of generating a
>> system-wide unique SAS address.
>
> But it's not stable across migration. That's the problem.
>
>> The whole thing is informational anyway, and can only be seen when
>> using the (proprietary) MegaCLI userspace command.
>
> Nonetheless, it's still guest visible.
>
Okay, I see your point. I'll be reworking things to not use the
pointer here.
>>> This code needs to be refactored to not do this. It's quite
>>> pervasive though (there's a half a dozen instances like this).
>>>
>>
>> Okay, so here's the challenge: We need to generate a system-wide
>> unique SAS address, one per SCSI device and one per megasas instance.
>> A simple counter won't work, as we might have several qemu instances
>> running. Which would result in all of them having the same SAS
>> address for the host.
>
> You could used a hashed uuid.
>
Right. Will see how that'll work out.
Cheers,
Hannes
--
Dr. Hannes Reinecke zSeries & Storage
hare@suse.de +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
^ permalink raw reply [flat|nested] 32+ messages in thread
end of thread, other threads:[~2012-07-10 13:01 UTC | newest]
Thread overview: 32+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2012-07-02 9:41 [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 01/14] scsi: simplify handling of the VPD page length field Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 02/14] scsi: add a qdev property for the disk's WWN Paolo Bonzini
2012-07-03 19:09 ` Blue Swirl
2012-07-04 7:33 ` Paolo Bonzini
2012-07-05 18:03 ` Blue Swirl
2012-07-06 7:05 ` Paolo Bonzini
2012-07-07 7:48 ` Blue Swirl
2012-07-07 12:22 ` Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 03/14] atapi: implement READ DISC INFORMATION Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 04/14] scsi-disk: " Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 05/14] ISCSI: Add SCSI passthrough via scsi-generic to libiscsi Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 06/14] ISCSI: force use of sg for SMC and SSC devices Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 07/14] megasas: Add header file Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 08/14] megasas: LSI Megaraid SAS HBA emulation Paolo Bonzini
2012-07-03 19:09 ` Blue Swirl
2012-07-04 5:52 ` Hannes Reinecke
2012-07-04 7:33 ` Paolo Bonzini
2012-07-05 6:46 ` Hannes Reinecke
2012-07-02 9:41 ` [Qemu-devel] [PATCH 09/14] virtio-scsi: do not crash on adding buffers to the event queue Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 10/14] scsi: Fix data length == SCSI_SENSE_BUF_SIZE Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 11/14] scsi: Fix LOAD_UNLOAD Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 12/14] scsi: Ensure command and transfer lengths are set for all SCSI devices Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 13/14] scsi: Add basic support for SCSI media changer commands Paolo Bonzini
2012-07-02 9:41 ` [Qemu-devel] [PATCH 14/14] scsi: Fix transfer length for READ POSITION commands Paolo Bonzini
2012-07-09 16:48 ` [Qemu-devel] [PULL 00/14] SCSI updates for 2012-07-02 Anthony Liguori
2012-07-09 23:09 ` Alexander Graf
2012-07-09 23:19 ` Anthony Liguori
2012-07-10 5:57 ` Hannes Reinecke
2012-07-10 7:06 ` Paolo Bonzini
2012-07-10 12:52 ` Anthony Liguori
2012-07-10 13:01 ` Hannes Reinecke
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.