hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
/*
|
|
|
|
* QEMU LSI SAS1068 Host Bus Adapter emulation
|
|
|
|
* Based on the QEMU Megaraid emulator
|
|
|
|
*
|
|
|
|
* Copyright (c) 2009-2012 Hannes Reinecke, SUSE Labs
|
|
|
|
* Copyright (c) 2012 Verizon, Inc.
|
|
|
|
* Copyright (c) 2016 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* Authors: Don Slutz, Paolo Bonzini
|
|
|
|
*
|
|
|
|
* 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 "qemu/osdep.h"
|
|
|
|
#include "hw/hw.h"
|
|
|
|
#include "hw/pci/pci.h"
|
|
|
|
#include "sysemu/dma.h"
|
|
|
|
#include "sysemu/block-backend.h"
|
|
|
|
#include "hw/pci/msi.h"
|
|
|
|
#include "qemu/iov.h"
|
|
|
|
#include "hw/scsi/scsi.h"
|
2017-08-22 09:23:55 +02:00
|
|
|
#include "scsi/constants.h"
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
#include "trace.h"
|
2016-06-20 08:13:39 +02:00
|
|
|
#include "qapi/error.h"
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
#include "mptsas.h"
|
|
|
|
#include "mpi.h"
|
|
|
|
|
|
|
|
#define NAA_LOCALLY_ASSIGNED_ID 0x3ULL
|
|
|
|
#define IEEE_COMPANY_LOCALLY_ASSIGNED 0x525400
|
|
|
|
|
|
|
|
#define TYPE_MPTSAS1068 "mptsas1068"
|
|
|
|
|
|
|
|
#define MPT_SAS(obj) \
|
|
|
|
OBJECT_CHECK(MPTSASState, (obj), TYPE_MPTSAS1068)
|
|
|
|
|
|
|
|
#define MPTSAS1068_PRODUCT_ID \
|
|
|
|
(MPI_FW_HEADER_PID_FAMILY_1068_SAS | \
|
|
|
|
MPI_FW_HEADER_PID_PROD_INITIATOR_SCSI | \
|
|
|
|
MPI_FW_HEADER_PID_TYPE_SAS)
|
|
|
|
|
|
|
|
struct MPTSASRequest {
|
|
|
|
MPIMsgSCSIIORequest scsi_io;
|
|
|
|
SCSIRequest *sreq;
|
|
|
|
QEMUSGList qsg;
|
|
|
|
MPTSASState *dev;
|
|
|
|
|
|
|
|
QTAILQ_ENTRY(MPTSASRequest) next;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void mptsas_update_interrupt(MPTSASState *s)
|
|
|
|
{
|
|
|
|
PCIDevice *pci = (PCIDevice *) s;
|
|
|
|
uint32_t state = s->intr_status & ~(s->intr_mask | MPI_HIS_IOP_DOORBELL_STATUS);
|
|
|
|
|
2016-06-20 08:13:41 +02:00
|
|
|
if (msi_enabled(pci)) {
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
if (state) {
|
|
|
|
trace_mptsas_irq_msi(s);
|
|
|
|
msi_notify(pci, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_mptsas_irq_intx(s, !!state);
|
|
|
|
pci_set_irq(pci, !!state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_set_fault(MPTSASState *s, uint32_t code)
|
|
|
|
{
|
|
|
|
if ((s->state & MPI_IOC_STATE_FAULT) == 0) {
|
|
|
|
s->state = MPI_IOC_STATE_FAULT | code;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MPTSAS_FIFO_INVALID(s, name) \
|
|
|
|
((s)->name##_head > ARRAY_SIZE((s)->name) || \
|
|
|
|
(s)->name##_tail > ARRAY_SIZE((s)->name))
|
|
|
|
|
|
|
|
#define MPTSAS_FIFO_EMPTY(s, name) \
|
|
|
|
((s)->name##_head == (s)->name##_tail)
|
|
|
|
|
|
|
|
#define MPTSAS_FIFO_FULL(s, name) \
|
|
|
|
((s)->name##_head == ((s)->name##_tail + 1) % ARRAY_SIZE((s)->name))
|
|
|
|
|
|
|
|
#define MPTSAS_FIFO_GET(s, name) ({ \
|
|
|
|
uint32_t _val = (s)->name[(s)->name##_head++]; \
|
|
|
|
(s)->name##_head %= ARRAY_SIZE((s)->name); \
|
|
|
|
_val; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define MPTSAS_FIFO_PUT(s, name, val) do { \
|
|
|
|
(s)->name[(s)->name##_tail++] = (val); \
|
|
|
|
(s)->name##_tail %= ARRAY_SIZE((s)->name); \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
static void mptsas_post_reply(MPTSASState *s, MPIDefaultReply *reply)
|
|
|
|
{
|
|
|
|
PCIDevice *pci = (PCIDevice *) s;
|
|
|
|
uint32_t addr_lo;
|
|
|
|
|
|
|
|
if (MPTSAS_FIFO_EMPTY(s, reply_free) || MPTSAS_FIFO_FULL(s, reply_post)) {
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_lo = MPTSAS_FIFO_GET(s, reply_free);
|
|
|
|
|
|
|
|
pci_dma_write(pci, addr_lo | s->host_mfa_high_addr, reply,
|
|
|
|
MIN(s->reply_frame_size, 4 * reply->MsgLength));
|
|
|
|
|
|
|
|
MPTSAS_FIFO_PUT(s, reply_post, MPI_ADDRESS_REPLY_A_BIT | (addr_lo >> 1));
|
|
|
|
|
|
|
|
s->intr_status |= MPI_HIS_REPLY_MESSAGE_INTERRUPT;
|
|
|
|
if (s->doorbell_state == DOORBELL_WRITE) {
|
|
|
|
s->doorbell_state = DOORBELL_NONE;
|
|
|
|
s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT;
|
|
|
|
}
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void mptsas_reply(MPTSASState *s, MPIDefaultReply *reply)
|
|
|
|
{
|
|
|
|
if (s->doorbell_state == DOORBELL_WRITE) {
|
|
|
|
/* The reply is sent out in 16 bit chunks, while the size
|
|
|
|
* in the reply is in 32 bit units.
|
|
|
|
*/
|
|
|
|
s->doorbell_state = DOORBELL_READ;
|
|
|
|
s->doorbell_reply_idx = 0;
|
|
|
|
s->doorbell_reply_size = reply->MsgLength * 2;
|
|
|
|
memcpy(s->doorbell_reply, reply, s->doorbell_reply_size * 2);
|
|
|
|
s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT;
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
} else {
|
|
|
|
mptsas_post_reply(s, reply);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_turbo_reply(MPTSASState *s, uint32_t msgctx)
|
|
|
|
{
|
|
|
|
if (MPTSAS_FIFO_FULL(s, reply_post)) {
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The reply is just the message context ID (bit 31 = clear). */
|
|
|
|
MPTSAS_FIFO_PUT(s, reply_post, msgctx);
|
|
|
|
|
|
|
|
s->intr_status |= MPI_HIS_REPLY_MESSAGE_INTERRUPT;
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MPTSAS_MAX_REQUEST_SIZE 52
|
|
|
|
|
|
|
|
static const int mpi_request_sizes[] = {
|
|
|
|
[MPI_FUNCTION_SCSI_IO_REQUEST] = sizeof(MPIMsgSCSIIORequest),
|
|
|
|
[MPI_FUNCTION_SCSI_TASK_MGMT] = sizeof(MPIMsgSCSITaskMgmt),
|
|
|
|
[MPI_FUNCTION_IOC_INIT] = sizeof(MPIMsgIOCInit),
|
|
|
|
[MPI_FUNCTION_IOC_FACTS] = sizeof(MPIMsgIOCFacts),
|
|
|
|
[MPI_FUNCTION_CONFIG] = sizeof(MPIMsgConfig),
|
|
|
|
[MPI_FUNCTION_PORT_FACTS] = sizeof(MPIMsgPortFacts),
|
|
|
|
[MPI_FUNCTION_PORT_ENABLE] = sizeof(MPIMsgPortEnable),
|
|
|
|
[MPI_FUNCTION_EVENT_NOTIFICATION] = sizeof(MPIMsgEventNotify),
|
|
|
|
};
|
|
|
|
|
|
|
|
static dma_addr_t mptsas_ld_sg_base(MPTSASState *s, uint32_t flags_and_length,
|
|
|
|
dma_addr_t *sgaddr)
|
|
|
|
{
|
|
|
|
PCIDevice *pci = (PCIDevice *) s;
|
|
|
|
dma_addr_t addr;
|
|
|
|
|
|
|
|
if (flags_and_length & MPI_SGE_FLAGS_64_BIT_ADDRESSING) {
|
|
|
|
addr = ldq_le_pci_dma(pci, *sgaddr + 4);
|
|
|
|
*sgaddr += 12;
|
|
|
|
} else {
|
|
|
|
addr = ldl_le_pci_dma(pci, *sgaddr + 4);
|
|
|
|
*sgaddr += 8;
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mptsas_build_sgl(MPTSASState *s, MPTSASRequest *req, hwaddr addr)
|
|
|
|
{
|
|
|
|
PCIDevice *pci = (PCIDevice *) s;
|
|
|
|
hwaddr next_chain_addr;
|
|
|
|
uint32_t left;
|
|
|
|
hwaddr sgaddr;
|
|
|
|
uint32_t chain_offset;
|
|
|
|
|
|
|
|
chain_offset = req->scsi_io.ChainOffset;
|
|
|
|
next_chain_addr = addr + chain_offset * sizeof(uint32_t);
|
|
|
|
sgaddr = addr + sizeof(MPIMsgSCSIIORequest);
|
|
|
|
pci_dma_sglist_init(&req->qsg, pci, 4);
|
|
|
|
left = req->scsi_io.DataLength;
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
dma_addr_t addr, len;
|
|
|
|
uint32_t flags_and_length;
|
|
|
|
|
|
|
|
flags_and_length = ldl_le_pci_dma(pci, sgaddr);
|
|
|
|
len = flags_and_length & MPI_SGE_LENGTH_MASK;
|
|
|
|
if ((flags_and_length & MPI_SGE_FLAGS_ELEMENT_TYPE_MASK)
|
|
|
|
!= MPI_SGE_FLAGS_SIMPLE_ELEMENT ||
|
|
|
|
(!len &&
|
|
|
|
!(flags_and_length & MPI_SGE_FLAGS_END_OF_LIST) &&
|
|
|
|
!(flags_and_length & MPI_SGE_FLAGS_END_OF_BUFFER))) {
|
|
|
|
return MPI_IOCSTATUS_INVALID_SGL;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = MIN(len, left);
|
|
|
|
if (!len) {
|
|
|
|
/* We reached the desired transfer length, ignore extra
|
|
|
|
* elements of the s/g list.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr = mptsas_ld_sg_base(s, flags_and_length, &sgaddr);
|
|
|
|
qemu_sglist_add(&req->qsg, addr, len);
|
|
|
|
left -= len;
|
|
|
|
|
|
|
|
if (flags_and_length & MPI_SGE_FLAGS_END_OF_LIST) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags_and_length & MPI_SGE_FLAGS_LAST_ELEMENT) {
|
|
|
|
if (!chain_offset) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
flags_and_length = ldl_le_pci_dma(pci, next_chain_addr);
|
|
|
|
if ((flags_and_length & MPI_SGE_FLAGS_ELEMENT_TYPE_MASK)
|
|
|
|
!= MPI_SGE_FLAGS_CHAIN_ELEMENT) {
|
|
|
|
return MPI_IOCSTATUS_INVALID_SGL;
|
|
|
|
}
|
|
|
|
|
|
|
|
sgaddr = mptsas_ld_sg_base(s, flags_and_length, &next_chain_addr);
|
|
|
|
chain_offset =
|
|
|
|
(flags_and_length & MPI_SGE_CHAIN_OFFSET_MASK) >> MPI_SGE_CHAIN_OFFSET_SHIFT;
|
|
|
|
next_chain_addr = sgaddr + chain_offset * sizeof(uint32_t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_free_request(MPTSASRequest *req)
|
|
|
|
{
|
|
|
|
MPTSASState *s = req->dev;
|
|
|
|
|
|
|
|
if (req->sreq != NULL) {
|
|
|
|
req->sreq->hba_private = NULL;
|
|
|
|
scsi_req_unref(req->sreq);
|
|
|
|
req->sreq = NULL;
|
|
|
|
QTAILQ_REMOVE(&s->pending, req, next);
|
|
|
|
}
|
|
|
|
qemu_sglist_destroy(&req->qsg);
|
|
|
|
g_free(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mptsas_scsi_device_find(MPTSASState *s, int bus, int target,
|
|
|
|
uint8_t *lun, SCSIDevice **sdev)
|
|
|
|
{
|
|
|
|
if (bus != 0) {
|
|
|
|
return MPI_IOCSTATUS_SCSI_INVALID_BUS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (target >= s->max_devices) {
|
|
|
|
return MPI_IOCSTATUS_SCSI_INVALID_TARGETID;
|
|
|
|
}
|
|
|
|
|
|
|
|
*sdev = scsi_device_find(&s->bus, bus, target, lun[1]);
|
|
|
|
if (!*sdev) {
|
|
|
|
return MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mptsas_process_scsi_io_request(MPTSASState *s,
|
|
|
|
MPIMsgSCSIIORequest *scsi_io,
|
|
|
|
hwaddr addr)
|
|
|
|
{
|
|
|
|
MPTSASRequest *req;
|
|
|
|
MPIMsgSCSIIOReply reply;
|
|
|
|
SCSIDevice *sdev;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
mptsas_fix_scsi_io_endianness(scsi_io);
|
|
|
|
|
|
|
|
trace_mptsas_process_scsi_io_request(s, scsi_io->Bus, scsi_io->TargetID,
|
|
|
|
scsi_io->LUN[1], scsi_io->DataLength);
|
|
|
|
|
|
|
|
status = mptsas_scsi_device_find(s, scsi_io->Bus, scsi_io->TargetID,
|
|
|
|
scsi_io->LUN, &sdev);
|
|
|
|
if (status) {
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
2016-09-12 14:44:11 +02:00
|
|
|
req = g_new0(MPTSASRequest, 1);
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
QTAILQ_INSERT_TAIL(&s->pending, req, next);
|
|
|
|
req->scsi_io = *scsi_io;
|
|
|
|
req->dev = s;
|
|
|
|
|
|
|
|
status = mptsas_build_sgl(s, req, addr);
|
|
|
|
if (status) {
|
|
|
|
goto free_bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (req->qsg.size < scsi_io->DataLength) {
|
|
|
|
trace_mptsas_sgl_overflow(s, scsi_io->MsgContext, scsi_io->DataLength,
|
|
|
|
req->qsg.size);
|
|
|
|
status = MPI_IOCSTATUS_INVALID_SGL;
|
|
|
|
goto free_bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->sreq = scsi_req_new(sdev, scsi_io->MsgContext,
|
|
|
|
scsi_io->LUN[1], scsi_io->CDB, req);
|
|
|
|
|
|
|
|
if (req->sreq->cmd.xfer > scsi_io->DataLength) {
|
|
|
|
goto overrun;
|
|
|
|
}
|
|
|
|
switch (scsi_io->Control & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK) {
|
|
|
|
case MPI_SCSIIO_CONTROL_NODATATRANSFER:
|
|
|
|
if (req->sreq->cmd.mode != SCSI_XFER_NONE) {
|
|
|
|
goto overrun;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSIIO_CONTROL_WRITE:
|
|
|
|
if (req->sreq->cmd.mode != SCSI_XFER_TO_DEV) {
|
|
|
|
goto overrun;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSIIO_CONTROL_READ:
|
|
|
|
if (req->sreq->cmd.mode != SCSI_XFER_FROM_DEV) {
|
|
|
|
goto overrun;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scsi_req_enqueue(req->sreq)) {
|
|
|
|
scsi_req_continue(req->sreq);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
overrun:
|
|
|
|
trace_mptsas_scsi_overflow(s, scsi_io->MsgContext, req->sreq->cmd.xfer,
|
|
|
|
scsi_io->DataLength);
|
|
|
|
status = MPI_IOCSTATUS_SCSI_DATA_OVERRUN;
|
|
|
|
free_bad:
|
|
|
|
mptsas_free_request(req);
|
|
|
|
bad:
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.TargetID = scsi_io->TargetID;
|
|
|
|
reply.Bus = scsi_io->Bus;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = scsi_io->Function;
|
|
|
|
reply.CDBLength = scsi_io->CDBLength;
|
|
|
|
reply.SenseBufferLength = scsi_io->SenseBufferLength;
|
|
|
|
reply.MsgContext = scsi_io->MsgContext;
|
|
|
|
reply.SCSIState = MPI_SCSI_STATE_NO_SCSI_STATUS;
|
|
|
|
reply.IOCStatus = status;
|
|
|
|
|
|
|
|
mptsas_fix_scsi_io_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
Notifier notifier;
|
|
|
|
MPTSASState *s;
|
|
|
|
MPIMsgSCSITaskMgmtReply *reply;
|
|
|
|
} MPTSASCancelNotifier;
|
|
|
|
|
|
|
|
static void mptsas_cancel_notify(Notifier *notifier, void *data)
|
|
|
|
{
|
|
|
|
MPTSASCancelNotifier *n = container_of(notifier,
|
|
|
|
MPTSASCancelNotifier,
|
|
|
|
notifier);
|
|
|
|
|
|
|
|
/* Abusing IOCLogInfo to store the expected number of requests... */
|
|
|
|
if (++n->reply->TerminationCount == n->reply->IOCLogInfo) {
|
|
|
|
n->reply->IOCLogInfo = 0;
|
|
|
|
mptsas_fix_scsi_task_mgmt_reply_endianness(n->reply);
|
|
|
|
mptsas_post_reply(n->s, (MPIDefaultReply *)n->reply);
|
|
|
|
g_free(n->reply);
|
|
|
|
}
|
|
|
|
g_free(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_scsi_task_mgmt(MPTSASState *s, MPIMsgSCSITaskMgmt *req)
|
|
|
|
{
|
|
|
|
MPIMsgSCSITaskMgmtReply reply;
|
|
|
|
MPIMsgSCSITaskMgmtReply *reply_async;
|
|
|
|
int status, count;
|
|
|
|
SCSIDevice *sdev;
|
|
|
|
SCSIRequest *r, *next;
|
|
|
|
BusChild *kid;
|
|
|
|
|
|
|
|
mptsas_fix_scsi_task_mgmt_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.TargetID = req->TargetID;
|
|
|
|
reply.Bus = req->Bus;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
reply.TaskType = req->TaskType;
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
|
|
|
|
switch (req->TaskType) {
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
|
|
|
|
status = mptsas_scsi_device_find(s, req->Bus, req->TargetID,
|
|
|
|
req->LUN, &sdev);
|
|
|
|
if (status) {
|
|
|
|
reply.IOCStatus = status;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (sdev->lun != req->LUN[1]) {
|
|
|
|
reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) {
|
|
|
|
MPTSASRequest *cmd_req = r->hba_private;
|
|
|
|
if (cmd_req && cmd_req->scsi_io.MsgContext == req->TaskMsgContext) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (r) {
|
|
|
|
/*
|
|
|
|
* Assert that the request has not been completed yet, we
|
|
|
|
* check for it in the loop above.
|
|
|
|
*/
|
|
|
|
assert(r->hba_private);
|
|
|
|
if (req->TaskType == MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK) {
|
|
|
|
/* "If the specified command is present in the task set, then
|
|
|
|
* return a service response set to FUNCTION SUCCEEDED".
|
|
|
|
*/
|
|
|
|
reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED;
|
|
|
|
} else {
|
|
|
|
MPTSASCancelNotifier *notifier;
|
|
|
|
|
|
|
|
reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply));
|
|
|
|
reply_async->IOCLogInfo = INT_MAX;
|
|
|
|
|
|
|
|
count = 1;
|
|
|
|
notifier = g_new(MPTSASCancelNotifier, 1);
|
|
|
|
notifier->s = s;
|
|
|
|
notifier->reply = reply_async;
|
|
|
|
notifier->notifier.notify = mptsas_cancel_notify;
|
|
|
|
scsi_req_cancel_async(r, ¬ifier->notifier);
|
|
|
|
goto reply_maybe_async;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET:
|
|
|
|
status = mptsas_scsi_device_find(s, req->Bus, req->TargetID,
|
|
|
|
req->LUN, &sdev);
|
|
|
|
if (status) {
|
|
|
|
reply.IOCStatus = status;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (sdev->lun != req->LUN[1]) {
|
|
|
|
reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
reply_async = g_memdup(&reply, sizeof(MPIMsgSCSITaskMgmtReply));
|
|
|
|
reply_async->IOCLogInfo = INT_MAX;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
QTAILQ_FOREACH_SAFE(r, &sdev->requests, next, next) {
|
|
|
|
if (r->hba_private) {
|
|
|
|
MPTSASCancelNotifier *notifier;
|
|
|
|
|
|
|
|
count++;
|
|
|
|
notifier = g_new(MPTSASCancelNotifier, 1);
|
|
|
|
notifier->s = s;
|
|
|
|
notifier->reply = reply_async;
|
|
|
|
notifier->notifier.notify = mptsas_cancel_notify;
|
|
|
|
scsi_req_cancel_async(r, ¬ifier->notifier);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
reply_maybe_async:
|
|
|
|
if (reply_async->TerminationCount < count) {
|
|
|
|
reply_async->IOCLogInfo = count;
|
|
|
|
return;
|
|
|
|
}
|
2016-02-16 08:41:52 +01:00
|
|
|
g_free(reply_async);
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
reply.TerminationCount = count;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
|
|
|
|
status = mptsas_scsi_device_find(s, req->Bus, req->TargetID,
|
|
|
|
req->LUN, &sdev);
|
|
|
|
if (status) {
|
|
|
|
reply.IOCStatus = status;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (sdev->lun != req->LUN[1]) {
|
|
|
|
reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
qdev_reset_all(&sdev->qdev);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
|
|
|
|
if (req->Bus != 0) {
|
|
|
|
reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_BUS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (req->TargetID > s->max_devices) {
|
|
|
|
reply.IOCStatus = MPI_IOCSTATUS_SCSI_INVALID_TARGETID;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
|
|
|
|
sdev = SCSI_DEVICE(kid->child);
|
|
|
|
if (sdev->channel == 0 && sdev->id == req->TargetID) {
|
|
|
|
qdev_reset_all(kid->child);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS:
|
|
|
|
qbus_reset_all(&s->bus.qbus);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
reply.ResponseCode = MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
mptsas_fix_scsi_task_mgmt_reply_endianness(&reply);
|
|
|
|
mptsas_post_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_ioc_init(MPTSASState *s, MPIMsgIOCInit *req)
|
|
|
|
{
|
|
|
|
MPIMsgIOCInitReply reply;
|
|
|
|
|
|
|
|
mptsas_fix_ioc_init_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
s->who_init = req->WhoInit;
|
|
|
|
s->reply_frame_size = req->ReplyFrameSize;
|
|
|
|
s->max_buses = req->MaxBuses;
|
|
|
|
s->max_devices = req->MaxDevices ? req->MaxDevices : 256;
|
|
|
|
s->host_mfa_high_addr = (hwaddr)req->HostMfaHighAddr << 32;
|
|
|
|
s->sense_buffer_high_addr = (hwaddr)req->SenseBufferHighAddr << 32;
|
|
|
|
|
|
|
|
if (s->state == MPI_IOC_STATE_READY) {
|
|
|
|
s->state = MPI_IOC_STATE_OPERATIONAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.WhoInit = s->who_init;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
reply.MaxDevices = s->max_devices;
|
|
|
|
reply.MaxBuses = s->max_buses;
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
|
|
|
|
mptsas_fix_ioc_init_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_ioc_facts(MPTSASState *s,
|
|
|
|
MPIMsgIOCFacts *req)
|
|
|
|
{
|
|
|
|
MPIMsgIOCFactsReply reply;
|
|
|
|
|
|
|
|
mptsas_fix_ioc_facts_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.MsgVersion = 0x0105;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
reply.MaxChainDepth = MPTSAS_MAXIMUM_CHAIN_DEPTH;
|
|
|
|
reply.WhoInit = s->who_init;
|
|
|
|
reply.BlockSize = MPTSAS_MAX_REQUEST_SIZE / sizeof(uint32_t);
|
|
|
|
reply.ReplyQueueDepth = ARRAY_SIZE(s->reply_post) - 1;
|
|
|
|
QEMU_BUILD_BUG_ON(ARRAY_SIZE(s->reply_post) != ARRAY_SIZE(s->reply_free));
|
|
|
|
|
|
|
|
reply.RequestFrameSize = 128;
|
|
|
|
reply.ProductID = MPTSAS1068_PRODUCT_ID;
|
|
|
|
reply.CurrentHostMfaHighAddr = s->host_mfa_high_addr >> 32;
|
|
|
|
reply.GlobalCredits = ARRAY_SIZE(s->request_post) - 1;
|
|
|
|
reply.NumberOfPorts = MPTSAS_NUM_PORTS;
|
|
|
|
reply.CurrentSenseBufferHighAddr = s->sense_buffer_high_addr >> 32;
|
|
|
|
reply.CurReplyFrameSize = s->reply_frame_size;
|
|
|
|
reply.MaxDevices = s->max_devices;
|
|
|
|
reply.MaxBuses = s->max_buses;
|
|
|
|
reply.FWVersionDev = 0;
|
|
|
|
reply.FWVersionUnit = 0x92;
|
|
|
|
reply.FWVersionMinor = 0x32;
|
|
|
|
reply.FWVersionMajor = 0x1;
|
|
|
|
|
|
|
|
mptsas_fix_ioc_facts_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_port_facts(MPTSASState *s,
|
|
|
|
MPIMsgPortFacts *req)
|
|
|
|
{
|
|
|
|
MPIMsgPortFactsReply reply;
|
|
|
|
|
|
|
|
mptsas_fix_port_facts_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
reply.PortNumber = req->PortNumber;
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
|
|
|
|
if (req->PortNumber < MPTSAS_NUM_PORTS) {
|
|
|
|
reply.PortType = MPI_PORTFACTS_PORTTYPE_SAS;
|
|
|
|
reply.MaxDevices = MPTSAS_NUM_PORTS;
|
|
|
|
reply.PortSCSIID = MPTSAS_NUM_PORTS;
|
|
|
|
reply.ProtocolFlags = MPI_PORTFACTS_PROTOCOL_LOGBUSADDR | MPI_PORTFACTS_PROTOCOL_INITIATOR;
|
|
|
|
}
|
|
|
|
|
|
|
|
mptsas_fix_port_facts_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_port_enable(MPTSASState *s,
|
|
|
|
MPIMsgPortEnable *req)
|
|
|
|
{
|
|
|
|
MPIMsgPortEnableReply reply;
|
|
|
|
|
|
|
|
mptsas_fix_port_enable_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.PortNumber = req->PortNumber;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
|
|
|
|
mptsas_fix_port_enable_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_event_notification(MPTSASState *s,
|
|
|
|
MPIMsgEventNotify *req)
|
|
|
|
{
|
|
|
|
MPIMsgEventNotifyReply reply;
|
|
|
|
|
|
|
|
mptsas_fix_event_notification_endianness(req);
|
|
|
|
|
|
|
|
QEMU_BUILD_BUG_ON(MPTSAS_MAX_REQUEST_SIZE < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_msg) < sizeof(*req));
|
|
|
|
QEMU_BUILD_BUG_ON(sizeof(s->doorbell_reply) < sizeof(reply));
|
|
|
|
|
|
|
|
/* Don't even bother storing whether event notification is enabled,
|
|
|
|
* since it is not accessible.
|
|
|
|
*/
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.EventDataLength = sizeof(reply.Data) / 4;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->Function;
|
|
|
|
|
|
|
|
/* This is set because events are sent through the reply FIFOs. */
|
|
|
|
reply.MsgFlags = MPI_MSGFLAGS_CONTINUATION_REPLY;
|
|
|
|
|
|
|
|
reply.MsgContext = req->MsgContext;
|
|
|
|
reply.Event = MPI_EVENT_EVENT_CHANGE;
|
|
|
|
reply.Data[0] = !!req->Switch;
|
|
|
|
|
|
|
|
mptsas_fix_event_notification_reply_endianness(&reply);
|
|
|
|
mptsas_reply(s, (MPIDefaultReply *)&reply);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_process_message(MPTSASState *s, MPIRequestHeader *req)
|
|
|
|
{
|
|
|
|
trace_mptsas_process_message(s, req->Function, req->MsgContext);
|
|
|
|
switch (req->Function) {
|
|
|
|
case MPI_FUNCTION_SCSI_TASK_MGMT:
|
|
|
|
mptsas_process_scsi_task_mgmt(s, (MPIMsgSCSITaskMgmt *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_IOC_INIT:
|
|
|
|
mptsas_process_ioc_init(s, (MPIMsgIOCInit *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_IOC_FACTS:
|
|
|
|
mptsas_process_ioc_facts(s, (MPIMsgIOCFacts *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_PORT_FACTS:
|
|
|
|
mptsas_process_port_facts(s, (MPIMsgPortFacts *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_PORT_ENABLE:
|
|
|
|
mptsas_process_port_enable(s, (MPIMsgPortEnable *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_EVENT_NOTIFICATION:
|
|
|
|
mptsas_process_event_notification(s, (MPIMsgEventNotify *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_FUNCTION_CONFIG:
|
|
|
|
mptsas_process_config(s, (MPIMsgConfig *)req);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
trace_mptsas_unhandled_cmd(s, req->Function, 0);
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INVALID_FUNCTION);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_fetch_request(MPTSASState *s)
|
|
|
|
{
|
|
|
|
PCIDevice *pci = (PCIDevice *) s;
|
|
|
|
char req[MPTSAS_MAX_REQUEST_SIZE];
|
|
|
|
MPIRequestHeader *hdr = (MPIRequestHeader *)req;
|
|
|
|
hwaddr addr;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
/* Read the message header from the guest first. */
|
|
|
|
addr = s->host_mfa_high_addr | MPTSAS_FIFO_GET(s, request_post);
|
2017-03-14 11:56:20 +01:00
|
|
|
pci_dma_read(pci, addr, req, sizeof(*hdr));
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
|
|
|
|
if (hdr->Function < ARRAY_SIZE(mpi_request_sizes) &&
|
|
|
|
mpi_request_sizes[hdr->Function]) {
|
|
|
|
/* Read the rest of the request based on the type. Do not
|
|
|
|
* reread everything, as that could cause a TOC/TOU mismatch
|
|
|
|
* and leak data from the QEMU stack.
|
|
|
|
*/
|
|
|
|
size = mpi_request_sizes[hdr->Function];
|
|
|
|
assert(size <= MPTSAS_MAX_REQUEST_SIZE);
|
2017-03-14 11:56:20 +01:00
|
|
|
pci_dma_read(pci, addr + sizeof(*hdr), &req[sizeof(*hdr)],
|
|
|
|
size - sizeof(*hdr));
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hdr->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
|
|
|
|
/* SCSI I/O requests are separate from mptsas_process_message
|
|
|
|
* because they cannot be sent through the doorbell yet.
|
|
|
|
*/
|
|
|
|
mptsas_process_scsi_io_request(s, (MPIMsgSCSIIORequest *)req, addr);
|
|
|
|
} else {
|
|
|
|
mptsas_process_message(s, (MPIRequestHeader *)req);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_fetch_requests(void *opaque)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
|
2016-05-24 10:07:44 +02:00
|
|
|
if (s->state != MPI_IOC_STATE_OPERATIONAL) {
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INVALID_STATE);
|
|
|
|
return;
|
|
|
|
}
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
while (!MPTSAS_FIFO_EMPTY(s, request_post)) {
|
|
|
|
mptsas_fetch_request(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_soft_reset(MPTSASState *s)
|
|
|
|
{
|
|
|
|
uint32_t save_mask;
|
|
|
|
|
|
|
|
trace_mptsas_reset(s);
|
|
|
|
|
|
|
|
/* Temporarily disable interrupts */
|
|
|
|
save_mask = s->intr_mask;
|
|
|
|
s->intr_mask = MPI_HIM_DIM | MPI_HIM_RIM;
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
|
|
|
|
qbus_reset_all(&s->bus.qbus);
|
|
|
|
s->intr_status = 0;
|
|
|
|
s->intr_mask = save_mask;
|
|
|
|
|
|
|
|
s->reply_free_tail = 0;
|
|
|
|
s->reply_free_head = 0;
|
|
|
|
s->reply_post_tail = 0;
|
|
|
|
s->reply_post_head = 0;
|
|
|
|
s->request_post_tail = 0;
|
|
|
|
s->request_post_head = 0;
|
|
|
|
qemu_bh_cancel(s->request_bh);
|
|
|
|
|
|
|
|
s->state = MPI_IOC_STATE_READY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t mptsas_doorbell_read(MPTSASState *s)
|
|
|
|
{
|
|
|
|
uint32_t ret;
|
|
|
|
|
2016-02-16 08:49:15 +01:00
|
|
|
ret = (s->who_init << MPI_DOORBELL_WHO_INIT_SHIFT) & MPI_DOORBELL_WHO_INIT_MASK;
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
ret |= s->state;
|
|
|
|
switch (s->doorbell_state) {
|
|
|
|
case DOORBELL_NONE:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DOORBELL_WRITE:
|
|
|
|
ret |= MPI_DOORBELL_ACTIVE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DOORBELL_READ:
|
|
|
|
/* Get rid of the IOC fault code. */
|
|
|
|
ret &= ~MPI_DOORBELL_DATA_MASK;
|
|
|
|
|
|
|
|
assert(s->intr_status & MPI_HIS_DOORBELL_INTERRUPT);
|
|
|
|
assert(s->doorbell_reply_idx <= s->doorbell_reply_size);
|
|
|
|
|
|
|
|
ret |= MPI_DOORBELL_ACTIVE;
|
|
|
|
if (s->doorbell_reply_idx < s->doorbell_reply_size) {
|
|
|
|
/* For more information about this endian switch, see the
|
|
|
|
* commit message for commit 36b62ae ("fw_cfg: fix endianness in
|
|
|
|
* fw_cfg_data_mem_read() / _write()", 2015-01-16).
|
|
|
|
*/
|
|
|
|
ret |= le16_to_cpu(s->doorbell_reply[s->doorbell_reply_idx++]);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_doorbell_write(MPTSASState *s, uint32_t val)
|
|
|
|
{
|
|
|
|
if (s->doorbell_state == DOORBELL_WRITE) {
|
|
|
|
if (s->doorbell_idx < s->doorbell_cnt) {
|
|
|
|
/* For more information about this endian switch, see the
|
|
|
|
* commit message for commit 36b62ae ("fw_cfg: fix endianness in
|
|
|
|
* fw_cfg_data_mem_read() / _write()", 2015-01-16).
|
|
|
|
*/
|
|
|
|
s->doorbell_msg[s->doorbell_idx++] = cpu_to_le32(val);
|
|
|
|
if (s->doorbell_idx == s->doorbell_cnt) {
|
|
|
|
mptsas_process_message(s, (MPIRequestHeader *)s->doorbell_msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ((val & MPI_DOORBELL_FUNCTION_MASK) >> MPI_DOORBELL_FUNCTION_SHIFT) {
|
|
|
|
case MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET:
|
|
|
|
mptsas_soft_reset(s);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_IO_UNIT_RESET:
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_HANDSHAKE:
|
|
|
|
s->doorbell_state = DOORBELL_WRITE;
|
|
|
|
s->doorbell_idx = 0;
|
|
|
|
s->doorbell_cnt = (val & MPI_DOORBELL_ADD_DWORDS_MASK)
|
|
|
|
>> MPI_DOORBELL_ADD_DWORDS_SHIFT;
|
|
|
|
s->intr_status |= MPI_HIS_DOORBELL_INTERRUPT;
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
trace_mptsas_unhandled_doorbell_cmd(s, val);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_write_sequence_write(MPTSASState *s, uint32_t val)
|
|
|
|
{
|
|
|
|
/* If the diagnostic register is enabled, any write to this register
|
|
|
|
* will disable it. Otherwise, the guest has to do a magic five-write
|
|
|
|
* sequence.
|
|
|
|
*/
|
|
|
|
if (s->diagnostic & MPI_DIAG_DRWE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (s->diagnostic_idx) {
|
|
|
|
case 0:
|
|
|
|
if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_1ST_KEY_VALUE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_2ND_KEY_VALUE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_3RD_KEY_VALUE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_4TH_KEY_VALUE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
if ((val & MPI_WRSEQ_KEY_VALUE_MASK) != MPI_WRSEQ_5TH_KEY_VALUE) {
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
/* Prepare Spaceball One for departure, and change the
|
|
|
|
* combination on my luggage!
|
|
|
|
*/
|
|
|
|
s->diagnostic |= MPI_DIAG_DRWE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
s->diagnostic_idx++;
|
|
|
|
return;
|
|
|
|
|
|
|
|
disable:
|
|
|
|
s->diagnostic &= ~MPI_DIAG_DRWE;
|
|
|
|
s->diagnostic_idx = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mptsas_hard_reset(MPTSASState *s)
|
|
|
|
{
|
|
|
|
mptsas_soft_reset(s);
|
|
|
|
|
|
|
|
s->intr_mask = MPI_HIM_DIM | MPI_HIM_RIM;
|
|
|
|
|
|
|
|
s->host_mfa_high_addr = 0;
|
|
|
|
s->sense_buffer_high_addr = 0;
|
|
|
|
s->reply_frame_size = 0;
|
|
|
|
s->max_devices = MPTSAS_NUM_PORTS;
|
|
|
|
s->max_buses = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_interrupt_status_write(MPTSASState *s)
|
|
|
|
{
|
|
|
|
switch (s->doorbell_state) {
|
|
|
|
case DOORBELL_NONE:
|
|
|
|
case DOORBELL_WRITE:
|
|
|
|
s->intr_status &= ~MPI_HIS_DOORBELL_INTERRUPT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DOORBELL_READ:
|
|
|
|
/* The reply can be read continuously, so leave the interrupt up. */
|
|
|
|
assert(s->intr_status & MPI_HIS_DOORBELL_INTERRUPT);
|
|
|
|
if (s->doorbell_reply_idx == s->doorbell_reply_size) {
|
|
|
|
s->doorbell_state = DOORBELL_NONE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t mptsas_reply_post_read(MPTSASState *s)
|
|
|
|
{
|
|
|
|
uint32_t ret;
|
|
|
|
|
|
|
|
if (!MPTSAS_FIFO_EMPTY(s, reply_post)) {
|
|
|
|
ret = MPTSAS_FIFO_GET(s, reply_post);
|
|
|
|
} else {
|
|
|
|
ret = -1;
|
|
|
|
s->intr_status &= ~MPI_HIS_REPLY_MESSAGE_INTERRUPT;
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t mptsas_mmio_read(void *opaque, hwaddr addr,
|
|
|
|
unsigned size)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
uint32_t ret = 0;
|
|
|
|
|
|
|
|
switch (addr & ~3) {
|
|
|
|
case MPI_DOORBELL_OFFSET:
|
|
|
|
ret = mptsas_doorbell_read(s);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_DIAGNOSTIC_OFFSET:
|
|
|
|
ret = s->diagnostic;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_HOST_INTERRUPT_STATUS_OFFSET:
|
|
|
|
ret = s->intr_status;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_HOST_INTERRUPT_MASK_OFFSET:
|
|
|
|
ret = s->intr_mask;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_REPLY_POST_FIFO_OFFSET:
|
|
|
|
ret = mptsas_reply_post_read(s);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
trace_mptsas_mmio_unhandled_read(s, addr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
trace_mptsas_mmio_read(s, addr, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_mmio_write(void *opaque, hwaddr addr,
|
|
|
|
uint64_t val, unsigned size)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
|
|
|
|
trace_mptsas_mmio_write(s, addr, val);
|
|
|
|
switch (addr) {
|
|
|
|
case MPI_DOORBELL_OFFSET:
|
|
|
|
mptsas_doorbell_write(s, val);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_WRITE_SEQUENCE_OFFSET:
|
|
|
|
mptsas_write_sequence_write(s, val);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_DIAGNOSTIC_OFFSET:
|
|
|
|
if (val & MPI_DIAG_RESET_ADAPTER) {
|
|
|
|
mptsas_hard_reset(s);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_HOST_INTERRUPT_STATUS_OFFSET:
|
|
|
|
mptsas_interrupt_status_write(s);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_HOST_INTERRUPT_MASK_OFFSET:
|
|
|
|
s->intr_mask = val & (MPI_HIM_RIM | MPI_HIM_DIM);
|
|
|
|
mptsas_update_interrupt(s);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_REQUEST_POST_FIFO_OFFSET:
|
|
|
|
if (MPTSAS_FIFO_FULL(s, request_post)) {
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
} else {
|
|
|
|
MPTSAS_FIFO_PUT(s, request_post, val & ~0x03);
|
|
|
|
qemu_bh_schedule(s->request_bh);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_REPLY_FREE_FIFO_OFFSET:
|
|
|
|
if (MPTSAS_FIFO_FULL(s, reply_free)) {
|
|
|
|
mptsas_set_fault(s, MPI_IOCSTATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
} else {
|
|
|
|
MPTSAS_FIFO_PUT(s, reply_free, val);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
trace_mptsas_mmio_unhandled_write(s, addr, val);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const MemoryRegionOps mptsas_mmio_ops = {
|
|
|
|
.read = mptsas_mmio_read,
|
|
|
|
.write = mptsas_mmio_write,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const MemoryRegionOps mptsas_port_ops = {
|
|
|
|
.read = mptsas_mmio_read,
|
|
|
|
.write = mptsas_mmio_write,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static uint64_t mptsas_diag_read(void *opaque, hwaddr addr,
|
|
|
|
unsigned size)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
trace_mptsas_diag_read(s, addr, 0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_diag_write(void *opaque, hwaddr addr,
|
|
|
|
uint64_t val, unsigned size)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
trace_mptsas_diag_write(s, addr, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const MemoryRegionOps mptsas_diag_ops = {
|
|
|
|
.read = mptsas_diag_read,
|
|
|
|
.write = mptsas_diag_write,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static QEMUSGList *mptsas_get_sg_list(SCSIRequest *sreq)
|
|
|
|
{
|
|
|
|
MPTSASRequest *req = sreq->hba_private;
|
|
|
|
|
|
|
|
return &req->qsg;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_command_complete(SCSIRequest *sreq,
|
|
|
|
uint32_t status, size_t resid)
|
|
|
|
{
|
|
|
|
MPTSASRequest *req = sreq->hba_private;
|
|
|
|
MPTSASState *s = req->dev;
|
|
|
|
uint8_t sense_buf[SCSI_SENSE_BUF_SIZE];
|
|
|
|
uint8_t sense_len;
|
|
|
|
|
|
|
|
hwaddr sense_buffer_addr = req->dev->sense_buffer_high_addr |
|
|
|
|
req->scsi_io.SenseBufferLowAddr;
|
|
|
|
|
|
|
|
trace_mptsas_command_complete(s, req->scsi_io.MsgContext, status, resid);
|
|
|
|
|
|
|
|
sense_len = scsi_req_get_sense(sreq, sense_buf, SCSI_SENSE_BUF_SIZE);
|
|
|
|
if (sense_len > 0) {
|
|
|
|
pci_dma_write(PCI_DEVICE(s), sense_buffer_addr, sense_buf,
|
|
|
|
MIN(req->scsi_io.SenseBufferLength, sense_len));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sreq->status != GOOD || resid ||
|
|
|
|
req->dev->doorbell_state == DOORBELL_WRITE) {
|
|
|
|
MPIMsgSCSIIOReply reply;
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.TargetID = req->scsi_io.TargetID;
|
|
|
|
reply.Bus = req->scsi_io.Bus;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->scsi_io.Function;
|
|
|
|
reply.CDBLength = req->scsi_io.CDBLength;
|
|
|
|
reply.SenseBufferLength = req->scsi_io.SenseBufferLength;
|
|
|
|
reply.MsgFlags = req->scsi_io.MsgFlags;
|
|
|
|
reply.MsgContext = req->scsi_io.MsgContext;
|
|
|
|
reply.SCSIStatus = sreq->status;
|
|
|
|
if (sreq->status == GOOD) {
|
|
|
|
reply.TransferCount = req->scsi_io.DataLength - resid;
|
|
|
|
if (resid) {
|
|
|
|
reply.IOCStatus = MPI_IOCSTATUS_SCSI_DATA_UNDERRUN;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
reply.SCSIState = MPI_SCSI_STATE_AUTOSENSE_VALID;
|
|
|
|
reply.SenseCount = sense_len;
|
|
|
|
reply.IOCStatus = MPI_IOCSTATUS_SCSI_DATA_UNDERRUN;
|
|
|
|
}
|
|
|
|
|
|
|
|
mptsas_fix_scsi_io_reply_endianness(&reply);
|
|
|
|
mptsas_post_reply(req->dev, (MPIDefaultReply *)&reply);
|
|
|
|
} else {
|
|
|
|
mptsas_turbo_reply(req->dev, req->scsi_io.MsgContext);
|
|
|
|
}
|
|
|
|
|
|
|
|
mptsas_free_request(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_request_cancelled(SCSIRequest *sreq)
|
|
|
|
{
|
|
|
|
MPTSASRequest *req = sreq->hba_private;
|
|
|
|
MPIMsgSCSIIOReply reply;
|
|
|
|
|
|
|
|
memset(&reply, 0, sizeof(reply));
|
|
|
|
reply.TargetID = req->scsi_io.TargetID;
|
|
|
|
reply.Bus = req->scsi_io.Bus;
|
|
|
|
reply.MsgLength = sizeof(reply) / 4;
|
|
|
|
reply.Function = req->scsi_io.Function;
|
|
|
|
reply.CDBLength = req->scsi_io.CDBLength;
|
|
|
|
reply.SenseBufferLength = req->scsi_io.SenseBufferLength;
|
|
|
|
reply.MsgFlags = req->scsi_io.MsgFlags;
|
|
|
|
reply.MsgContext = req->scsi_io.MsgContext;
|
|
|
|
reply.SCSIState = MPI_SCSI_STATE_NO_SCSI_STATUS;
|
|
|
|
reply.IOCStatus = MPI_IOCSTATUS_SCSI_TASK_TERMINATED;
|
|
|
|
|
|
|
|
mptsas_fix_scsi_io_reply_endianness(&reply);
|
|
|
|
mptsas_post_reply(req->dev, (MPIDefaultReply *)&reply);
|
|
|
|
mptsas_free_request(req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_save_request(QEMUFile *f, SCSIRequest *sreq)
|
|
|
|
{
|
|
|
|
MPTSASRequest *req = sreq->hba_private;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
qemu_put_buffer(f, (unsigned char *)&req->scsi_io, sizeof(req->scsi_io));
|
|
|
|
qemu_put_be32(f, req->qsg.nsg);
|
|
|
|
for (i = 0; i < req->qsg.nsg; i++) {
|
|
|
|
qemu_put_be64(f, req->qsg.sg[i].base);
|
|
|
|
qemu_put_be64(f, req->qsg.sg[i].len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *mptsas_load_request(QEMUFile *f, SCSIRequest *sreq)
|
|
|
|
{
|
|
|
|
SCSIBus *bus = sreq->bus;
|
|
|
|
MPTSASState *s = container_of(bus, MPTSASState, bus);
|
|
|
|
PCIDevice *pci = PCI_DEVICE(s);
|
|
|
|
MPTSASRequest *req;
|
|
|
|
int i, n;
|
|
|
|
|
|
|
|
req = g_new(MPTSASRequest, 1);
|
|
|
|
qemu_get_buffer(f, (unsigned char *)&req->scsi_io, sizeof(req->scsi_io));
|
|
|
|
|
|
|
|
n = qemu_get_be32(f);
|
|
|
|
/* TODO: add a way for SCSIBusInfo's load_request to fail,
|
|
|
|
* and fail migration instead of asserting here.
|
osdep.h: Prohibit disabling assert() in supported builds
We already have several files that knowingly require assert()
to work, sometimes because refactoring the code for proper
error handling has not been tackled yet; there are probably
other files that have a similar situation but with no comments
documenting the same. In fact, we have places in migration
that handle untrusted input with assertions, where disabling
the assertions risks a worse security hole than the current
behavior of losing the guest to SIGABRT when migration fails
because of the assertion. Promote our current per-file
safety-valve to instead be project-wide, and expand it to also
cover glib's g_assert().
Note that we do NOT want to encourage 'assert(side-effects);'
(that is a bad practice that prevents copy-and-paste of code to
other projects that CAN disable assertions; plus it costs
unnecessary reviewer mental cycles to remember whether a project
special-cases the crippling of asserts); and we would LIKE to
fix migration to not rely on asserts (but that takes a big code
audit). But in the meantime, we DO want to send a message
that anyone that disables assertions has to tweak code in order
to compile, making it obvious that they are taking on additional
risk that we are not going to support. At the same time, leave
comments mentioning NDEBUG in files that we know still need to
be scrubbed, so there is at least something to grep for.
It would be possible to come up with some other mechanism for
doing runtime checking by default, but which does not abort
the program on failure, while leaving side effects in place
(unlike how crippling assert() avoids even the side effects),
perhaps under the name q_verify(); but it was not deemed worth
the effort (developers should not have to learn a replacement
when the standard C macro works just fine, and it would be a lot
of churn for little gain). The patch specifically uses #error
rather than #warn so that a user is forced to tweak the header
to acknowledge the issue, even when not using a -Werror
compilation.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20170911211320.25385-1-eblake@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-09-11 23:13:20 +02:00
|
|
|
* This is just one thing (there are probably more) that must be
|
|
|
|
* fixed before we can allow NDEBUG compilation.
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
*/
|
|
|
|
assert(n >= 0);
|
|
|
|
|
|
|
|
pci_dma_sglist_init(&req->qsg, pci, n);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
uint64_t base = qemu_get_be64(f);
|
|
|
|
uint64_t len = qemu_get_be64(f);
|
|
|
|
qemu_sglist_add(&req->qsg, base, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
scsi_req_ref(sreq);
|
|
|
|
req->sreq = sreq;
|
|
|
|
req->dev = s;
|
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct SCSIBusInfo mptsas_scsi_info = {
|
|
|
|
.tcq = true,
|
|
|
|
.max_target = MPTSAS_NUM_PORTS,
|
|
|
|
.max_lun = 1,
|
|
|
|
|
|
|
|
.get_sg_list = mptsas_get_sg_list,
|
|
|
|
.complete = mptsas_command_complete,
|
|
|
|
.cancel = mptsas_request_cancelled,
|
|
|
|
.save_request = mptsas_save_request,
|
|
|
|
.load_request = mptsas_load_request,
|
|
|
|
};
|
|
|
|
|
2016-06-20 08:13:33 +02:00
|
|
|
static void mptsas_scsi_realize(PCIDevice *dev, Error **errp)
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
{
|
|
|
|
MPTSASState *s = MPT_SAS(dev);
|
2016-06-20 08:13:39 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
int ret;
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
|
|
|
|
dev->config[PCI_LATENCY_TIMER] = 0;
|
|
|
|
dev->config[PCI_INTERRUPT_PIN] = 0x01;
|
|
|
|
|
2016-06-20 08:13:39 +02:00
|
|
|
if (s->msi != ON_OFF_AUTO_OFF) {
|
|
|
|
ret = msi_init(dev, 0, 1, true, false, &err);
|
|
|
|
/* Any error other than -ENOTSUP(board's MSI support is broken)
|
|
|
|
* is a programming error */
|
|
|
|
assert(!ret || ret == -ENOTSUP);
|
|
|
|
if (ret && s->msi == ON_OFF_AUTO_ON) {
|
|
|
|
/* Can't satisfy user's explicit msi=on request, fail */
|
|
|
|
error_append_hint(&err, "You have to use msi=auto (default) or "
|
|
|
|
"msi=off with this machine type.\n");
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
2016-06-20 08:13:41 +02:00
|
|
|
assert(!err || s->msi == ON_OFF_AUTO_AUTO);
|
|
|
|
/* With msi=auto, we fall back to MSI off silently */
|
|
|
|
error_free(err);
|
|
|
|
|
2016-08-01 10:25:05 +02:00
|
|
|
/* Only used for migration. */
|
|
|
|
s->msi_in_use = (ret == 0);
|
2016-06-20 08:13:39 +02:00
|
|
|
}
|
|
|
|
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
memory_region_init_io(&s->mmio_io, OBJECT(s), &mptsas_mmio_ops, s,
|
|
|
|
"mptsas-mmio", 0x4000);
|
|
|
|
memory_region_init_io(&s->port_io, OBJECT(s), &mptsas_port_ops, s,
|
|
|
|
"mptsas-io", 256);
|
|
|
|
memory_region_init_io(&s->diag_io, OBJECT(s), &mptsas_diag_ops, s,
|
|
|
|
"mptsas-diag", 0x10000);
|
|
|
|
|
|
|
|
pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_IO, &s->port_io);
|
|
|
|
pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY |
|
|
|
|
PCI_BASE_ADDRESS_MEM_TYPE_32, &s->mmio_io);
|
|
|
|
pci_register_bar(dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY |
|
|
|
|
PCI_BASE_ADDRESS_MEM_TYPE_32, &s->diag_io);
|
|
|
|
|
|
|
|
if (!s->sas_addr) {
|
|
|
|
s->sas_addr = ((NAA_LOCALLY_ASSIGNED_ID << 24) |
|
|
|
|
IEEE_COMPANY_LOCALLY_ASSIGNED) << 36;
|
|
|
|
s->sas_addr |= (pci_bus_num(dev->bus) << 16);
|
|
|
|
s->sas_addr |= (PCI_SLOT(dev->devfn) << 8);
|
|
|
|
s->sas_addr |= PCI_FUNC(dev->devfn);
|
|
|
|
}
|
|
|
|
s->max_devices = MPTSAS_NUM_PORTS;
|
|
|
|
|
|
|
|
s->request_bh = qemu_bh_new(mptsas_fetch_requests, s);
|
|
|
|
|
|
|
|
QTAILQ_INIT(&s->pending);
|
|
|
|
|
|
|
|
scsi_bus_new(&s->bus, sizeof(s->bus), &dev->qdev, &mptsas_scsi_info, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_scsi_uninit(PCIDevice *dev)
|
|
|
|
{
|
|
|
|
MPTSASState *s = MPT_SAS(dev);
|
|
|
|
|
|
|
|
qemu_bh_delete(s->request_bh);
|
2016-06-20 08:13:41 +02:00
|
|
|
msi_uninit(dev);
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mptsas_reset(DeviceState *dev)
|
|
|
|
{
|
|
|
|
MPTSASState *s = MPT_SAS(dev);
|
|
|
|
|
|
|
|
mptsas_hard_reset(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mptsas_post_load(void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
MPTSASState *s = opaque;
|
|
|
|
|
|
|
|
if (s->doorbell_idx > s->doorbell_cnt ||
|
|
|
|
s->doorbell_cnt > ARRAY_SIZE(s->doorbell_msg) ||
|
|
|
|
s->doorbell_reply_idx > s->doorbell_reply_size ||
|
|
|
|
s->doorbell_reply_size > ARRAY_SIZE(s->doorbell_reply) ||
|
|
|
|
MPTSAS_FIFO_INVALID(s, request_post) ||
|
|
|
|
MPTSAS_FIFO_INVALID(s, reply_post) ||
|
|
|
|
MPTSAS_FIFO_INVALID(s, reply_free) ||
|
|
|
|
s->diagnostic_idx > 4) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const VMStateDescription vmstate_mptsas = {
|
|
|
|
.name = "mptsas",
|
|
|
|
.version_id = 0,
|
|
|
|
.minimum_version_id = 0,
|
|
|
|
.minimum_version_id_old = 0,
|
|
|
|
.post_load = mptsas_post_load,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_PCI_DEVICE(dev, MPTSASState),
|
2016-08-01 10:25:05 +02:00
|
|
|
VMSTATE_BOOL(msi_in_use, MPTSASState),
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
VMSTATE_UINT32(state, MPTSASState),
|
|
|
|
VMSTATE_UINT8(who_init, MPTSASState),
|
|
|
|
VMSTATE_UINT8(doorbell_state, MPTSASState),
|
|
|
|
VMSTATE_UINT32_ARRAY(doorbell_msg, MPTSASState, 256),
|
|
|
|
VMSTATE_INT32(doorbell_idx, MPTSASState),
|
|
|
|
VMSTATE_INT32(doorbell_cnt, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT16_ARRAY(doorbell_reply, MPTSASState, 256),
|
|
|
|
VMSTATE_INT32(doorbell_reply_idx, MPTSASState),
|
|
|
|
VMSTATE_INT32(doorbell_reply_size, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT32(diagnostic, MPTSASState),
|
|
|
|
VMSTATE_UINT8(diagnostic_idx, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT32(intr_status, MPTSASState),
|
|
|
|
VMSTATE_UINT32(intr_mask, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT32_ARRAY(request_post, MPTSASState,
|
|
|
|
MPTSAS_REQUEST_QUEUE_DEPTH + 1),
|
|
|
|
VMSTATE_UINT16(request_post_head, MPTSASState),
|
|
|
|
VMSTATE_UINT16(request_post_tail, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT32_ARRAY(reply_post, MPTSASState,
|
|
|
|
MPTSAS_REPLY_QUEUE_DEPTH + 1),
|
|
|
|
VMSTATE_UINT16(reply_post_head, MPTSASState),
|
|
|
|
VMSTATE_UINT16(reply_post_tail, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT32_ARRAY(reply_free, MPTSASState,
|
|
|
|
MPTSAS_REPLY_QUEUE_DEPTH + 1),
|
|
|
|
VMSTATE_UINT16(reply_free_head, MPTSASState),
|
|
|
|
VMSTATE_UINT16(reply_free_tail, MPTSASState),
|
|
|
|
|
|
|
|
VMSTATE_UINT16(max_buses, MPTSASState),
|
|
|
|
VMSTATE_UINT16(max_devices, MPTSASState),
|
|
|
|
VMSTATE_UINT16(reply_frame_size, MPTSASState),
|
|
|
|
VMSTATE_UINT64(host_mfa_high_addr, MPTSASState),
|
|
|
|
VMSTATE_UINT64(sense_buffer_high_addr, MPTSASState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static Property mptsas_properties[] = {
|
|
|
|
DEFINE_PROP_UINT64("sas_address", MPTSASState, sas_addr, 0),
|
|
|
|
/* TODO: test MSI support under Windows */
|
2016-06-20 08:13:36 +02:00
|
|
|
DEFINE_PROP_ON_OFF_AUTO("msi", MPTSASState, msi, ON_OFF_AUTO_AUTO),
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void mptsas1068_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(oc);
|
|
|
|
PCIDeviceClass *pc = PCI_DEVICE_CLASS(oc);
|
|
|
|
|
2016-06-20 08:13:33 +02:00
|
|
|
pc->realize = mptsas_scsi_realize;
|
hw: Add support for LSI SAS1068 (mptsas) device
This adds the SAS1068 device, a SAS disk controller used in VMware that
is oldish but widely supported and has decent performance. Unlike
megasas, it presents itself as a SAS controller and not as a RAID
controller. The device corresponds to the mptsas kernel driver in
Linux.
A few small things in the device setup are based on Don Slutz's old
patch, but the device emulation was written from scratch based on Don's
SeaBIOS patch and on the FreeBSD and Linux drivers. It is 2400 lines
shorter than Don's patch (and roughly the same size as MegaSAS---also
because it doesn't support the similar SPI controller), implements SCSI
task management functions (with asynchronous cancellation), supports
big-endian hosts, has complete support for migration and follows the
QEMU coding standards much more closely.
To write the driver, I first split Don's patch in two parts, with
the configuration bits in one file and the rest in a separate file.
I first left mptconfig.c in place and rewrote the rest, then deleted
mptconfig.c as well. The configuration pages are still based mostly on
VirtualBox's, though not exactly the same. However, the implementation
is completely different. The contents of the pages themselves should
not be copyrightable.
Signed-off-by: Don Slutz <Don@CloudSwitch.com>
Message-Id: <1347382813-5662-1-git-send-email-Don@CloudSwitch.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-10-27 18:26:06 +01:00
|
|
|
pc->exit = mptsas_scsi_uninit;
|
|
|
|
pc->romfile = 0;
|
|
|
|
pc->vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
|
|
|
|
pc->device_id = PCI_DEVICE_ID_LSI_SAS1068;
|
|
|
|
pc->subsystem_vendor_id = PCI_VENDOR_ID_LSI_LOGIC;
|
|
|
|
pc->subsystem_id = 0x8000;
|
|
|
|
pc->class_id = PCI_CLASS_STORAGE_SCSI;
|
|
|
|
dc->props = mptsas_properties;
|
|
|
|
dc->reset = mptsas_reset;
|
|
|
|
dc->vmsd = &vmstate_mptsas;
|
|
|
|
dc->desc = "LSI SAS 1068";
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo mptsas_info = {
|
|
|
|
.name = TYPE_MPTSAS1068,
|
|
|
|
.parent = TYPE_PCI_DEVICE,
|
|
|
|
.instance_size = sizeof(MPTSASState),
|
|
|
|
.class_init = mptsas1068_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void mptsas_register_types(void)
|
|
|
|
{
|
|
|
|
type_register(&mptsas_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(mptsas_register_types)
|