2015-01-19 23:16:03 +03:00
|
|
|
/*
|
|
|
|
* libqos AHCI functions
|
|
|
|
*
|
|
|
|
* Copyright (c) 2014 John Snow <jsnow@redhat.com>
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 21:17:09 +03:00
|
|
|
#include "qemu/osdep.h"
|
2015-01-19 23:16:03 +03:00
|
|
|
|
|
|
|
#include "libqtest.h"
|
2020-08-04 21:00:40 +03:00
|
|
|
#include "ahci.h"
|
|
|
|
#include "pci-pc.h"
|
2015-01-19 23:16:03 +03:00
|
|
|
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "qemu/host-utils.h"
|
|
|
|
|
|
|
|
#include "hw/pci/pci_ids.h"
|
|
|
|
#include "hw/pci/pci_regs.h"
|
|
|
|
|
2015-02-05 20:41:22 +03:00
|
|
|
typedef struct AHCICommandProp {
|
|
|
|
uint8_t cmd; /* Command Code */
|
|
|
|
bool data; /* Data transfer command? */
|
|
|
|
bool pio;
|
|
|
|
bool dma;
|
|
|
|
bool lba28;
|
|
|
|
bool lba48;
|
|
|
|
bool read;
|
|
|
|
bool write;
|
|
|
|
bool atapi;
|
|
|
|
bool ncq;
|
|
|
|
uint64_t size; /* Static transfer size, for commands like IDENTIFY. */
|
|
|
|
uint32_t interrupts; /* Expected interrupts for this command. */
|
|
|
|
} AHCICommandProp;
|
|
|
|
|
|
|
|
AHCICommandProp ahci_command_properties[] = {
|
2015-07-04 09:06:04 +03:00
|
|
|
{ .cmd = CMD_READ_PIO, .data = true, .pio = true,
|
|
|
|
.lba28 = true, .read = true },
|
|
|
|
{ .cmd = CMD_WRITE_PIO, .data = true, .pio = true,
|
|
|
|
.lba28 = true, .write = true },
|
|
|
|
{ .cmd = CMD_READ_PIO_EXT, .data = true, .pio = true,
|
|
|
|
.lba48 = true, .read = true },
|
|
|
|
{ .cmd = CMD_WRITE_PIO_EXT, .data = true, .pio = true,
|
|
|
|
.lba48 = true, .write = true },
|
|
|
|
{ .cmd = CMD_READ_DMA, .data = true, .dma = true,
|
|
|
|
.lba28 = true, .read = true },
|
|
|
|
{ .cmd = CMD_WRITE_DMA, .data = true, .dma = true,
|
|
|
|
.lba28 = true, .write = true },
|
|
|
|
{ .cmd = CMD_READ_DMA_EXT, .data = true, .dma = true,
|
|
|
|
.lba48 = true, .read = true },
|
|
|
|
{ .cmd = CMD_WRITE_DMA_EXT, .data = true, .dma = true,
|
|
|
|
.lba48 = true, .write = true },
|
|
|
|
{ .cmd = CMD_IDENTIFY, .data = true, .pio = true,
|
|
|
|
.size = 512, .read = true },
|
|
|
|
{ .cmd = READ_FPDMA_QUEUED, .data = true, .dma = true,
|
|
|
|
.lba48 = true, .read = true, .ncq = true },
|
|
|
|
{ .cmd = WRITE_FPDMA_QUEUED, .data = true, .dma = true,
|
|
|
|
.lba48 = true, .write = true, .ncq = true },
|
|
|
|
{ .cmd = CMD_READ_MAX, .lba28 = true },
|
|
|
|
{ .cmd = CMD_READ_MAX_EXT, .lba48 = true },
|
2016-01-11 22:10:42 +03:00
|
|
|
{ .cmd = CMD_FLUSH_CACHE, .data = false },
|
|
|
|
{ .cmd = CMD_PACKET, .data = true, .size = 16,
|
2016-01-11 22:10:43 +03:00
|
|
|
.atapi = true, .pio = true },
|
2016-01-11 22:10:42 +03:00
|
|
|
{ .cmd = CMD_PACKET_ID, .data = true, .pio = true,
|
|
|
|
.size = 512, .read = true }
|
2015-02-05 20:41:22 +03:00
|
|
|
};
|
|
|
|
|
2015-07-04 09:06:03 +03:00
|
|
|
struct AHCICommand {
|
|
|
|
/* Test Management Data */
|
|
|
|
uint8_t name;
|
|
|
|
uint8_t port;
|
|
|
|
uint8_t slot;
|
2016-11-14 19:15:54 +03:00
|
|
|
uint8_t errors;
|
2015-07-04 09:06:03 +03:00
|
|
|
uint32_t interrupts;
|
|
|
|
uint64_t xbytes;
|
|
|
|
uint32_t prd_size;
|
2018-06-06 22:09:49 +03:00
|
|
|
uint32_t sector_size;
|
2015-07-04 09:06:03 +03:00
|
|
|
uint64_t buffer;
|
|
|
|
AHCICommandProp *props;
|
|
|
|
/* Data to be transferred to the guest */
|
|
|
|
AHCICommandHeader header;
|
|
|
|
RegH2DFIS fis;
|
2016-01-11 22:10:42 +03:00
|
|
|
unsigned char *atapi_cmd;
|
2015-07-04 09:06:03 +03:00
|
|
|
};
|
|
|
|
|
2015-01-19 23:16:03 +03:00
|
|
|
/**
|
|
|
|
* Allocate space in the guest using information in the AHCIQState object.
|
|
|
|
*/
|
|
|
|
uint64_t ahci_alloc(AHCIQState *ahci, size_t bytes)
|
|
|
|
{
|
|
|
|
g_assert(ahci);
|
|
|
|
g_assert(ahci->parent);
|
|
|
|
return qmalloc(ahci->parent, bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_free(AHCIQState *ahci, uint64_t addr)
|
|
|
|
{
|
|
|
|
g_assert(ahci);
|
|
|
|
g_assert(ahci->parent);
|
|
|
|
qfree(ahci->parent, addr);
|
|
|
|
}
|
|
|
|
|
2016-01-11 22:10:42 +03:00
|
|
|
bool is_atapi(AHCIQState *ahci, uint8_t port)
|
|
|
|
{
|
|
|
|
return ahci_px_rreg(ahci, port, AHCI_PX_SIG) == AHCI_SIGNATURE_CDROM;
|
|
|
|
}
|
|
|
|
|
2015-01-19 23:16:03 +03:00
|
|
|
/**
|
|
|
|
* Locate, verify, and return a handle to the AHCI device.
|
|
|
|
*/
|
2017-09-11 20:19:52 +03:00
|
|
|
QPCIDevice *get_ahci_device(QTestState *qts, uint32_t *fingerprint)
|
2015-01-19 23:16:03 +03:00
|
|
|
{
|
|
|
|
QPCIDevice *ahci;
|
|
|
|
uint32_t ahci_fingerprint;
|
|
|
|
QPCIBus *pcibus;
|
|
|
|
|
2018-07-19 14:50:27 +03:00
|
|
|
pcibus = qpci_new_pc(qts, NULL);
|
2015-01-19 23:16:03 +03:00
|
|
|
|
|
|
|
/* Find the AHCI PCI device and verify it's the right one. */
|
|
|
|
ahci = qpci_device_find(pcibus, QPCI_DEVFN(0x1F, 0x02));
|
|
|
|
g_assert(ahci != NULL);
|
|
|
|
|
|
|
|
ahci_fingerprint = qpci_config_readl(ahci, PCI_VENDOR_ID);
|
|
|
|
|
|
|
|
switch (ahci_fingerprint) {
|
|
|
|
case AHCI_INTEL_ICH9:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Unknown device. */
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fingerprint) {
|
|
|
|
*fingerprint = ahci_fingerprint;
|
|
|
|
}
|
|
|
|
return ahci;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_ahci_device(QPCIDevice *dev)
|
|
|
|
{
|
|
|
|
QPCIBus *pcibus = dev ? dev->bus : NULL;
|
|
|
|
|
|
|
|
/* libqos doesn't have a function for this, so free it manually */
|
|
|
|
g_free(dev);
|
|
|
|
qpci_free_pc(pcibus);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:28 +03:00
|
|
|
/* Free all memory in-use by the AHCI device. */
|
|
|
|
void ahci_clean_mem(AHCIQState *ahci)
|
|
|
|
{
|
|
|
|
uint8_t port, slot;
|
|
|
|
|
|
|
|
for (port = 0; port < 32; ++port) {
|
|
|
|
if (ahci->port[port].fb) {
|
|
|
|
ahci_free(ahci, ahci->port[port].fb);
|
2015-07-04 09:06:02 +03:00
|
|
|
ahci->port[port].fb = 0;
|
2015-02-05 20:41:28 +03:00
|
|
|
}
|
|
|
|
if (ahci->port[port].clb) {
|
|
|
|
for (slot = 0; slot < 32; slot++) {
|
|
|
|
ahci_destroy_command(ahci, port, slot);
|
|
|
|
}
|
|
|
|
ahci_free(ahci, ahci->port[port].clb);
|
2015-07-04 09:06:02 +03:00
|
|
|
ahci->port[port].clb = 0;
|
2015-02-05 20:41:28 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-19 23:16:03 +03:00
|
|
|
/*** Logical Device Initialization ***/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Start the PCI device and sanity-check default operation.
|
|
|
|
*/
|
|
|
|
void ahci_pci_enable(AHCIQState *ahci)
|
|
|
|
{
|
|
|
|
uint8_t reg;
|
|
|
|
|
|
|
|
start_ahci_device(ahci);
|
|
|
|
|
|
|
|
switch (ahci->fingerprint) {
|
|
|
|
case AHCI_INTEL_ICH9:
|
|
|
|
/* ICH9 has a register at PCI 0x92 that
|
|
|
|
* acts as a master port enabler mask. */
|
|
|
|
reg = qpci_config_readb(ahci->dev, 0x92);
|
|
|
|
reg |= 0x3F;
|
|
|
|
qpci_config_writeb(ahci->dev, 0x92, reg);
|
|
|
|
/* 0...0111111b -- bit significant, ports 0-5 enabled. */
|
|
|
|
ASSERT_BIT_SET(qpci_config_readb(ahci->dev, 0x92), 0x3F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Map BAR5/ABAR, and engage the PCI device.
|
|
|
|
*/
|
|
|
|
void start_ahci_device(AHCIQState *ahci)
|
|
|
|
{
|
|
|
|
/* Map AHCI's ABAR (BAR5) */
|
2016-10-24 07:52:06 +03:00
|
|
|
ahci->hba_bar = qpci_iomap(ahci->dev, 5, &ahci->barsize);
|
2015-01-19 23:16:03 +03:00
|
|
|
|
|
|
|
/* turns on pci.cmd.iose, pci.cmd.mse and pci.cmd.bme */
|
|
|
|
qpci_device_enable(ahci->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Test and initialize the AHCI's HBA memory areas.
|
|
|
|
* Initialize and start any ports with devices attached.
|
|
|
|
* Bring the HBA into the idle state.
|
|
|
|
*/
|
|
|
|
void ahci_hba_enable(AHCIQState *ahci)
|
|
|
|
{
|
|
|
|
/* Bits of interest in this section:
|
|
|
|
* GHC.AE Global Host Control / AHCI Enable
|
|
|
|
* PxCMD.ST Port Command: Start
|
|
|
|
* PxCMD.SUD "Spin Up Device"
|
|
|
|
* PxCMD.POD "Power On Device"
|
|
|
|
* PxCMD.FRE "FIS Receive Enable"
|
|
|
|
* PxCMD.FR "FIS Receive Running"
|
|
|
|
* PxCMD.CR "Command List Running"
|
|
|
|
*/
|
|
|
|
uint32_t reg, ports_impl;
|
|
|
|
uint16_t i;
|
|
|
|
uint8_t num_cmd_slots;
|
|
|
|
|
|
|
|
g_assert(ahci != NULL);
|
|
|
|
|
|
|
|
/* Set GHC.AE to 1 */
|
|
|
|
ahci_set(ahci, AHCI_GHC, AHCI_GHC_AE);
|
|
|
|
reg = ahci_rreg(ahci, AHCI_GHC);
|
|
|
|
ASSERT_BIT_SET(reg, AHCI_GHC_AE);
|
|
|
|
|
|
|
|
/* Cache CAP and CAP2. */
|
|
|
|
ahci->cap = ahci_rreg(ahci, AHCI_CAP);
|
|
|
|
ahci->cap2 = ahci_rreg(ahci, AHCI_CAP2);
|
|
|
|
|
|
|
|
/* Read CAP.NCS, how many command slots do we have? */
|
|
|
|
num_cmd_slots = ((ahci->cap & AHCI_CAP_NCS) >> ctzl(AHCI_CAP_NCS)) + 1;
|
|
|
|
g_test_message("Number of Command Slots: %u", num_cmd_slots);
|
|
|
|
|
|
|
|
/* Determine which ports are implemented. */
|
|
|
|
ports_impl = ahci_rreg(ahci, AHCI_PI);
|
|
|
|
|
|
|
|
for (i = 0; ports_impl; ports_impl >>= 1, ++i) {
|
|
|
|
if (!(ports_impl & 0x01)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_test_message("Initializing port %u", i);
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_CMD);
|
|
|
|
if (BITCLR(reg, AHCI_PX_CMD_ST | AHCI_PX_CMD_CR |
|
|
|
|
AHCI_PX_CMD_FRE | AHCI_PX_CMD_FR)) {
|
|
|
|
g_test_message("port is idle");
|
|
|
|
} else {
|
|
|
|
g_test_message("port needs to be idled");
|
|
|
|
ahci_px_clr(ahci, i, AHCI_PX_CMD,
|
|
|
|
(AHCI_PX_CMD_ST | AHCI_PX_CMD_FRE));
|
|
|
|
/* The port has 500ms to disengage. */
|
|
|
|
usleep(500000);
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_CMD);
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_CMD_CR);
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_CMD_FR);
|
|
|
|
g_test_message("port is now idle");
|
|
|
|
/* The spec does allow for possibly needing a PORT RESET
|
|
|
|
* or HBA reset if we fail to idle the port. */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate Memory for the Command List Buffer & FIS Buffer */
|
|
|
|
/* PxCLB space ... 0x20 per command, as in 4.2.2 p 36 */
|
|
|
|
ahci->port[i].clb = ahci_alloc(ahci, num_cmd_slots * 0x20);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memset(ahci->parent->qts, ahci->port[i].clb, 0x00,
|
|
|
|
num_cmd_slots * 0x20);
|
2015-01-19 23:16:03 +03:00
|
|
|
g_test_message("CLB: 0x%08" PRIx64, ahci->port[i].clb);
|
|
|
|
ahci_px_wreg(ahci, i, AHCI_PX_CLB, ahci->port[i].clb);
|
|
|
|
g_assert_cmphex(ahci->port[i].clb, ==,
|
|
|
|
ahci_px_rreg(ahci, i, AHCI_PX_CLB));
|
|
|
|
|
|
|
|
/* PxFB space ... 0x100, as in 4.2.1 p 35 */
|
|
|
|
ahci->port[i].fb = ahci_alloc(ahci, 0x100);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memset(ahci->parent->qts, ahci->port[i].fb, 0x00, 0x100);
|
2015-01-19 23:16:03 +03:00
|
|
|
g_test_message("FB: 0x%08" PRIx64, ahci->port[i].fb);
|
|
|
|
ahci_px_wreg(ahci, i, AHCI_PX_FB, ahci->port[i].fb);
|
|
|
|
g_assert_cmphex(ahci->port[i].fb, ==,
|
|
|
|
ahci_px_rreg(ahci, i, AHCI_PX_FB));
|
|
|
|
|
|
|
|
/* Clear PxSERR, PxIS, then IS.IPS[x] by writing '1's. */
|
|
|
|
ahci_px_wreg(ahci, i, AHCI_PX_SERR, 0xFFFFFFFF);
|
|
|
|
ahci_px_wreg(ahci, i, AHCI_PX_IS, 0xFFFFFFFF);
|
|
|
|
ahci_wreg(ahci, AHCI_IS, (1 << i));
|
|
|
|
|
|
|
|
/* Verify Interrupts Cleared */
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_SERR);
|
|
|
|
g_assert_cmphex(reg, ==, 0);
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_IS);
|
|
|
|
g_assert_cmphex(reg, ==, 0);
|
|
|
|
|
|
|
|
reg = ahci_rreg(ahci, AHCI_IS);
|
|
|
|
ASSERT_BIT_CLEAR(reg, (1 << i));
|
|
|
|
|
|
|
|
/* Enable All Interrupts: */
|
|
|
|
ahci_px_wreg(ahci, i, AHCI_PX_IE, 0xFFFFFFFF);
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_IE);
|
|
|
|
g_assert_cmphex(reg, ==, ~((uint32_t)AHCI_PX_IE_RESERVED));
|
|
|
|
|
|
|
|
/* Enable the FIS Receive Engine. */
|
|
|
|
ahci_px_set(ahci, i, AHCI_PX_CMD, AHCI_PX_CMD_FRE);
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_CMD);
|
|
|
|
ASSERT_BIT_SET(reg, AHCI_PX_CMD_FR);
|
|
|
|
|
|
|
|
/* AHCI 1.3 spec: if !STS.BSY, !STS.DRQ and PxSSTS.DET indicates
|
|
|
|
* physical presence, a device is present and may be started. However,
|
|
|
|
* PxSERR.DIAG.X /may/ need to be cleared a priori. */
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_SERR);
|
|
|
|
if (BITSET(reg, AHCI_PX_SERR_DIAG_X)) {
|
|
|
|
ahci_px_set(ahci, i, AHCI_PX_SERR, AHCI_PX_SERR_DIAG_X);
|
|
|
|
}
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_TFD);
|
|
|
|
if (BITCLR(reg, AHCI_PX_TFD_STS_BSY | AHCI_PX_TFD_STS_DRQ)) {
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_SSTS);
|
|
|
|
if ((reg & AHCI_PX_SSTS_DET) == SSTS_DET_ESTABLISHED) {
|
|
|
|
/* Device Found: set PxCMD.ST := 1 */
|
|
|
|
ahci_px_set(ahci, i, AHCI_PX_CMD, AHCI_PX_CMD_ST);
|
|
|
|
ASSERT_BIT_SET(ahci_px_rreg(ahci, i, AHCI_PX_CMD),
|
|
|
|
AHCI_PX_CMD_CR);
|
|
|
|
g_test_message("Started Device %u", i);
|
|
|
|
} else if ((reg & AHCI_PX_SSTS_DET)) {
|
|
|
|
/* Device present, but in some unknown state. */
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable GHC.IE */
|
|
|
|
ahci_set(ahci, AHCI_GHC, AHCI_GHC_IE);
|
|
|
|
reg = ahci_rreg(ahci, AHCI_GHC);
|
|
|
|
ASSERT_BIT_SET(reg, AHCI_GHC_IE);
|
|
|
|
|
2016-10-24 07:50:22 +03:00
|
|
|
ahci->enabled = true;
|
2015-01-19 23:16:03 +03:00
|
|
|
/* TODO: The device should now be idling and waiting for commands.
|
|
|
|
* In the future, a small test-case to inspect the Register D2H FIS
|
|
|
|
* and clear the initial interrupts might be good. */
|
|
|
|
}
|
2015-02-05 20:41:12 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Pick the first implemented and running port
|
|
|
|
*/
|
|
|
|
unsigned ahci_port_select(AHCIQState *ahci)
|
|
|
|
{
|
|
|
|
uint32_t ports, reg;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
ports = ahci_rreg(ahci, AHCI_PI);
|
|
|
|
for (i = 0; i < 32; ports >>= 1, ++i) {
|
|
|
|
if (ports == 0) {
|
|
|
|
i = 32;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ports & 0x01)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, i, AHCI_PX_CMD);
|
|
|
|
if (BITSET(reg, AHCI_PX_CMD_ST)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_assert(i < 32);
|
|
|
|
return i;
|
|
|
|
}
|
2015-02-05 20:41:13 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear a port's interrupts and status information prior to a test.
|
|
|
|
*/
|
|
|
|
void ahci_port_clear(AHCIQState *ahci, uint8_t port)
|
|
|
|
{
|
|
|
|
uint32_t reg;
|
|
|
|
|
|
|
|
/* Clear out this port's interrupts (ignore the init register d2h fis) */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_IS);
|
|
|
|
ahci_px_wreg(ahci, port, AHCI_PX_IS, reg);
|
|
|
|
g_assert_cmphex(ahci_px_rreg(ahci, port, AHCI_PX_IS), ==, 0);
|
|
|
|
|
2015-04-09 21:32:39 +03:00
|
|
|
/* Wipe the FIS-Receive Buffer */
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memset(ahci->parent->qts, ahci->port[port].fb, 0x00, 0x100);
|
2015-02-05 20:41:13 +03:00
|
|
|
}
|
2015-02-05 20:41:15 +03:00
|
|
|
|
2015-02-05 20:41:16 +03:00
|
|
|
/**
|
|
|
|
* Check a port for errors.
|
|
|
|
*/
|
2016-11-14 19:15:54 +03:00
|
|
|
void ahci_port_check_error(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint32_t imask, uint8_t emask)
|
2015-02-05 20:41:16 +03:00
|
|
|
{
|
|
|
|
uint32_t reg;
|
|
|
|
|
|
|
|
/* The upper 9 bits of the IS register all indicate errors. */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_IS);
|
2016-11-14 19:15:54 +03:00
|
|
|
reg &= ~imask;
|
2015-02-05 20:41:16 +03:00
|
|
|
reg >>= 23;
|
|
|
|
g_assert_cmphex(reg, ==, 0);
|
|
|
|
|
|
|
|
/* The Sata Error Register should be empty. */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_SERR);
|
|
|
|
g_assert_cmphex(reg, ==, 0);
|
|
|
|
|
|
|
|
/* The TFD also has two error sections. */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_TFD);
|
2016-11-14 19:15:54 +03:00
|
|
|
if (!emask) {
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_STS_ERR);
|
|
|
|
} else {
|
|
|
|
ASSERT_BIT_SET(reg, AHCI_PX_TFD_STS_ERR);
|
|
|
|
}
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_ERR & (~emask << 8));
|
|
|
|
ASSERT_BIT_SET(reg, AHCI_PX_TFD_ERR & (emask << 8));
|
2015-02-05 20:41:16 +03:00
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:17 +03:00
|
|
|
void ahci_port_check_interrupts(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint32_t intr_mask)
|
|
|
|
{
|
|
|
|
uint32_t reg;
|
|
|
|
|
|
|
|
/* Check for expected interrupts */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_IS);
|
|
|
|
ASSERT_BIT_SET(reg, intr_mask);
|
|
|
|
|
|
|
|
/* Clear expected interrupts and assert all interrupts now cleared. */
|
|
|
|
ahci_px_wreg(ahci, port, AHCI_PX_IS, intr_mask);
|
|
|
|
g_assert_cmphex(ahci_px_rreg(ahci, port, AHCI_PX_IS), ==, 0);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:18 +03:00
|
|
|
void ahci_port_check_nonbusy(AHCIQState *ahci, uint8_t port, uint8_t slot)
|
|
|
|
{
|
|
|
|
uint32_t reg;
|
|
|
|
|
|
|
|
/* Assert that the command slot is no longer busy (NCQ) */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_SACT);
|
|
|
|
ASSERT_BIT_CLEAR(reg, (1 << slot));
|
|
|
|
|
|
|
|
/* Non-NCQ */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_CI);
|
|
|
|
ASSERT_BIT_CLEAR(reg, (1 << slot));
|
|
|
|
|
|
|
|
/* And assert that we are generally not busy. */
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_TFD);
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_STS_BSY);
|
|
|
|
ASSERT_BIT_CLEAR(reg, AHCI_PX_TFD_STS_DRQ);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:19 +03:00
|
|
|
void ahci_port_check_d2h_sanity(AHCIQState *ahci, uint8_t port, uint8_t slot)
|
|
|
|
{
|
|
|
|
RegD2HFIS *d2h = g_malloc0(0x20);
|
|
|
|
uint32_t reg;
|
|
|
|
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memread(ahci->parent->qts, ahci->port[port].fb + 0x40, d2h, 0x20);
|
2015-02-05 20:41:19 +03:00
|
|
|
g_assert_cmphex(d2h->fis_type, ==, 0x34);
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_TFD);
|
|
|
|
g_assert_cmphex((reg & AHCI_PX_TFD_ERR) >> 8, ==, d2h->error);
|
|
|
|
g_assert_cmphex((reg & AHCI_PX_TFD_STS), ==, d2h->status);
|
|
|
|
|
|
|
|
g_free(d2h);
|
|
|
|
}
|
|
|
|
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
void ahci_port_check_pio_sanity(AHCIQState *ahci, AHCICommand *cmd)
|
2015-02-05 20:41:19 +03:00
|
|
|
{
|
|
|
|
PIOSetupFIS *pio = g_malloc0(0x20);
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
uint8_t port = cmd->port;
|
2015-02-05 20:41:19 +03:00
|
|
|
|
2015-04-09 21:32:39 +03:00
|
|
|
/* We cannot check the Status or E_Status registers, because
|
2015-02-05 20:41:19 +03:00
|
|
|
* the status may have again changed between the PIO Setup FIS
|
|
|
|
* and the conclusion of the command with the D2H Register FIS. */
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memread(ahci->parent->qts, ahci->port[port].fb + 0x20, pio, 0x20);
|
2015-02-05 20:41:19 +03:00
|
|
|
g_assert_cmphex(pio->fis_type, ==, 0x5f);
|
|
|
|
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
/* Data transferred by PIO will either be:
|
|
|
|
* (1) 12 or 16 bytes for an ATAPI command packet (QEMU always uses 12), or
|
|
|
|
* (2) Actual data from the drive.
|
|
|
|
* If we do both, (2) winds up erasing any evidence of (1).
|
|
|
|
*/
|
|
|
|
if (cmd->props->atapi && (cmd->xbytes == 0 || cmd->props->dma)) {
|
|
|
|
g_assert(le16_to_cpu(pio->tx_count) == 12 ||
|
|
|
|
le16_to_cpu(pio->tx_count) == 16);
|
|
|
|
} else {
|
|
|
|
/* The AHCI test suite here does not test any PIO command that specifies
|
|
|
|
* a DRQ block larger than one sector (like 0xC4), so this should always
|
|
|
|
* be one sector or less. */
|
|
|
|
size_t pio_len = ((cmd->xbytes % cmd->sector_size) ?
|
|
|
|
(cmd->xbytes % cmd->sector_size) : cmd->sector_size);
|
|
|
|
g_assert_cmphex(le16_to_cpu(pio->tx_count), ==, pio_len);
|
2015-02-05 20:41:19 +03:00
|
|
|
}
|
|
|
|
g_free(pio);
|
|
|
|
}
|
|
|
|
|
2015-07-04 09:06:03 +03:00
|
|
|
void ahci_port_check_cmd_sanity(AHCIQState *ahci, AHCICommand *cmd)
|
2015-02-05 20:41:19 +03:00
|
|
|
{
|
2015-07-04 09:06:03 +03:00
|
|
|
AHCICommandHeader cmdh;
|
2015-02-05 20:41:19 +03:00
|
|
|
|
2015-07-04 09:06:03 +03:00
|
|
|
ahci_get_command_header(ahci, cmd->port, cmd->slot, &cmdh);
|
|
|
|
/* Physical Region Descriptor Byte Count is not required to work for NCQ. */
|
|
|
|
if (!cmd->props->ncq) {
|
|
|
|
g_assert_cmphex(cmd->xbytes, ==, cmdh.prdbc);
|
|
|
|
}
|
2015-02-05 20:41:19 +03:00
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:15 +03:00
|
|
|
/* Get the command in #slot of port #port. */
|
|
|
|
void ahci_get_command_header(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint8_t slot, AHCICommandHeader *cmd)
|
|
|
|
{
|
|
|
|
uint64_t ba = ahci->port[port].clb;
|
|
|
|
ba += slot * sizeof(AHCICommandHeader);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memread(ahci->parent->qts, ba, cmd, sizeof(AHCICommandHeader));
|
2015-02-05 20:41:15 +03:00
|
|
|
|
|
|
|
cmd->flags = le16_to_cpu(cmd->flags);
|
|
|
|
cmd->prdtl = le16_to_cpu(cmd->prdtl);
|
|
|
|
cmd->prdbc = le32_to_cpu(cmd->prdbc);
|
|
|
|
cmd->ctba = le64_to_cpu(cmd->ctba);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the command in #slot of port #port. */
|
|
|
|
void ahci_set_command_header(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint8_t slot, AHCICommandHeader *cmd)
|
|
|
|
{
|
2015-02-26 02:06:35 +03:00
|
|
|
AHCICommandHeader tmp = { .flags = 0 };
|
2015-02-05 20:41:15 +03:00
|
|
|
uint64_t ba = ahci->port[port].clb;
|
|
|
|
ba += slot * sizeof(AHCICommandHeader);
|
|
|
|
|
|
|
|
tmp.flags = cpu_to_le16(cmd->flags);
|
|
|
|
tmp.prdtl = cpu_to_le16(cmd->prdtl);
|
|
|
|
tmp.prdbc = cpu_to_le32(cmd->prdbc);
|
|
|
|
tmp.ctba = cpu_to_le64(cmd->ctba);
|
|
|
|
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memwrite(ahci->parent->qts, ba, &tmp, sizeof(AHCICommandHeader));
|
2015-02-05 20:41:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_destroy_command(AHCIQState *ahci, uint8_t port, uint8_t slot)
|
|
|
|
{
|
|
|
|
AHCICommandHeader cmd;
|
|
|
|
|
|
|
|
/* Obtain the Nth Command Header */
|
|
|
|
ahci_get_command_header(ahci, port, slot, &cmd);
|
|
|
|
if (cmd.ctba == 0) {
|
|
|
|
/* No address in it, so just return -- it's empty. */
|
|
|
|
goto tidy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the Table */
|
|
|
|
ahci_free(ahci, cmd.ctba);
|
|
|
|
|
|
|
|
tidy:
|
|
|
|
/* NULL the header. */
|
|
|
|
memset(&cmd, 0x00, sizeof(cmd));
|
|
|
|
ahci_set_command_header(ahci, port, slot, &cmd);
|
|
|
|
ahci->port[port].ctba[slot] = 0;
|
|
|
|
ahci->port[port].prdtl[slot] = 0;
|
|
|
|
}
|
|
|
|
|
2015-07-06 22:17:09 +03:00
|
|
|
void ahci_write_fis(AHCIQState *ahci, AHCICommand *cmd)
|
2015-02-05 20:41:21 +03:00
|
|
|
{
|
2015-07-06 22:17:09 +03:00
|
|
|
RegH2DFIS tmp = cmd->fis;
|
|
|
|
uint64_t addr = cmd->header.ctba;
|
2015-02-05 20:41:21 +03:00
|
|
|
|
2015-07-06 22:17:09 +03:00
|
|
|
/* NCQ commands use exclusively 8 bit fields and needs no adjustment.
|
|
|
|
* Only the count field needs to be adjusted for non-NCQ commands.
|
|
|
|
* The auxiliary FIS fields are defined per-command and are not currently
|
2020-08-04 21:00:40 +03:00
|
|
|
* implemented in ahci.o, but may or may not need to be flipped. */
|
2015-07-06 22:17:09 +03:00
|
|
|
if (!cmd->props->ncq) {
|
|
|
|
tmp.count = cpu_to_le16(tmp.count);
|
|
|
|
}
|
2015-02-05 20:41:21 +03:00
|
|
|
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memwrite(ahci->parent->qts, addr, &tmp, sizeof(tmp));
|
2015-02-05 20:41:21 +03:00
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:15 +03:00
|
|
|
unsigned ahci_pick_cmd(AHCIQState *ahci, uint8_t port)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
unsigned j;
|
|
|
|
uint32_t reg;
|
|
|
|
|
|
|
|
reg = ahci_px_rreg(ahci, port, AHCI_PX_CI);
|
|
|
|
|
|
|
|
/* Pick the least recently used command slot that's available */
|
|
|
|
for (i = 0; i < 32; ++i) {
|
|
|
|
j = ((ahci->port[port].next + i) % 32);
|
|
|
|
if (reg & (1 << j)) {
|
|
|
|
continue;
|
|
|
|
}
|
2015-07-04 09:06:02 +03:00
|
|
|
ahci_destroy_command(ahci, port, j);
|
2015-02-05 20:41:15 +03:00
|
|
|
ahci->port[port].next = (j + 1) % 32;
|
|
|
|
return j;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_test_message("All command slots were busy.");
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2015-02-05 20:41:23 +03:00
|
|
|
|
|
|
|
inline unsigned size_to_prdtl(unsigned bytes, unsigned bytes_per_prd)
|
|
|
|
{
|
|
|
|
/* Each PRD can describe up to 4MiB */
|
|
|
|
g_assert_cmphex(bytes_per_prd, <=, 4096 * 1024);
|
|
|
|
g_assert_cmphex(bytes_per_prd & 0x01, ==, 0x00);
|
|
|
|
return (bytes + bytes_per_prd - 1) / bytes_per_prd;
|
|
|
|
}
|
|
|
|
|
2016-01-11 22:10:43 +03:00
|
|
|
const AHCIOpts default_opts = { .size = 0 };
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ahci_exec: execute a given command on a specific
|
|
|
|
* AHCI port.
|
|
|
|
*
|
|
|
|
* @ahci: The device to send the command to
|
|
|
|
* @port: The port number of the SATA device we wish
|
|
|
|
* to have execute this command
|
|
|
|
* @op: The S/ATA command to execute, or if opts.atapi
|
|
|
|
* is true, the SCSI command code.
|
|
|
|
* @opts: Optional arguments to modify execution behavior.
|
|
|
|
*/
|
|
|
|
void ahci_exec(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint8_t op, const AHCIOpts *opts_in)
|
|
|
|
{
|
|
|
|
AHCICommand *cmd;
|
|
|
|
int rc;
|
|
|
|
AHCIOpts *opts;
|
|
|
|
|
|
|
|
opts = g_memdup((opts_in == NULL ? &default_opts : opts_in),
|
|
|
|
sizeof(AHCIOpts));
|
|
|
|
|
|
|
|
/* No guest buffer provided, create one. */
|
|
|
|
if (opts->size && !opts->buffer) {
|
|
|
|
opts->buffer = ahci_alloc(ahci, opts->size);
|
|
|
|
g_assert(opts->buffer);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memset(ahci->parent->qts, opts->buffer, 0x00, opts->size);
|
2016-01-11 22:10:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Command creation */
|
|
|
|
if (opts->atapi) {
|
2016-11-14 19:15:54 +03:00
|
|
|
uint16_t bcl = opts->set_bcl ? opts->bcl : ATAPI_SECTOR_SIZE;
|
2018-06-25 23:50:48 +03:00
|
|
|
cmd = ahci_atapi_command_create(op, bcl, opts->atapi_dma);
|
2016-01-11 22:10:43 +03:00
|
|
|
} else {
|
|
|
|
cmd = ahci_command_create(op);
|
|
|
|
}
|
|
|
|
ahci_command_adjust(cmd, opts->lba, opts->buffer,
|
|
|
|
opts->size, opts->prd_size);
|
|
|
|
|
|
|
|
if (opts->pre_cb) {
|
|
|
|
rc = opts->pre_cb(ahci, cmd, opts);
|
|
|
|
g_assert_cmpint(rc, ==, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write command to memory and issue it */
|
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue_async(ahci, cmd);
|
|
|
|
if (opts->error) {
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_qmp_eventwait(ahci->parent->qts, "STOP");
|
2016-01-11 22:10:43 +03:00
|
|
|
}
|
|
|
|
if (opts->mid_cb) {
|
|
|
|
rc = opts->mid_cb(ahci, cmd, opts);
|
|
|
|
g_assert_cmpint(rc, ==, 0);
|
|
|
|
}
|
|
|
|
if (opts->error) {
|
2018-08-06 09:53:22 +03:00
|
|
|
qtest_qmp_send(ahci->parent->qts, "{'execute':'cont' }");
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_qmp_eventwait(ahci->parent->qts, "RESUME");
|
2016-01-11 22:10:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for command to complete and verify sanity */
|
|
|
|
ahci_command_wait(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
if (opts->post_cb) {
|
|
|
|
rc = opts->post_cb(ahci, cmd, opts);
|
|
|
|
g_assert_cmpint(rc, ==, 0);
|
|
|
|
}
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
if (opts->buffer != opts_in->buffer) {
|
|
|
|
ahci_free(ahci, opts->buffer);
|
|
|
|
}
|
|
|
|
g_free(opts);
|
|
|
|
}
|
|
|
|
|
2015-05-22 21:13:42 +03:00
|
|
|
/* Issue a command, expecting it to fail and STOP the VM */
|
|
|
|
AHCICommand *ahci_guest_io_halt(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint8_t ide_cmd, uint64_t buffer,
|
|
|
|
size_t bufsize, uint64_t sector)
|
|
|
|
{
|
|
|
|
AHCICommand *cmd;
|
|
|
|
|
|
|
|
cmd = ahci_command_create(ide_cmd);
|
|
|
|
ahci_command_adjust(cmd, sector, buffer, bufsize, 0);
|
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue_async(ahci, cmd);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_qmp_eventwait(ahci->parent->qts, "STOP");
|
2015-05-22 21:13:42 +03:00
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Resume a previously failed command and verify/finalize */
|
|
|
|
void ahci_guest_io_resume(AHCIQState *ahci, AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
/* Complete the command */
|
2018-08-06 09:53:22 +03:00
|
|
|
qtest_qmp_send(ahci->parent->qts, "{'execute':'cont' }");
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_qmp_eventwait(ahci->parent->qts, "RESUME");
|
2015-05-22 21:13:42 +03:00
|
|
|
ahci_command_wait(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:26 +03:00
|
|
|
/* Given a guest buffer address, perform an IO operation */
|
|
|
|
void ahci_guest_io(AHCIQState *ahci, uint8_t port, uint8_t ide_cmd,
|
2015-04-28 22:27:51 +03:00
|
|
|
uint64_t buffer, size_t bufsize, uint64_t sector)
|
2015-02-05 20:41:26 +03:00
|
|
|
{
|
|
|
|
AHCICommand *cmd;
|
|
|
|
cmd = ahci_command_create(ide_cmd);
|
|
|
|
ahci_command_set_buffer(cmd, buffer);
|
|
|
|
ahci_command_set_size(cmd, bufsize);
|
2015-04-28 22:27:51 +03:00
|
|
|
if (sector) {
|
|
|
|
ahci_command_set_offset(cmd, sector);
|
|
|
|
}
|
2015-02-05 20:41:26 +03:00
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
static AHCICommandProp *ahci_command_find(uint8_t command_name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ahci_command_properties); i++) {
|
|
|
|
if (ahci_command_properties[i].cmd == command_name) {
|
|
|
|
return &ahci_command_properties[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:27 +03:00
|
|
|
/* Given a HOST buffer, create a buffer address and perform an IO operation. */
|
|
|
|
void ahci_io(AHCIQState *ahci, uint8_t port, uint8_t ide_cmd,
|
2015-04-28 22:27:51 +03:00
|
|
|
void *buffer, size_t bufsize, uint64_t sector)
|
2015-02-05 20:41:27 +03:00
|
|
|
{
|
|
|
|
uint64_t ptr;
|
|
|
|
AHCICommandProp *props;
|
|
|
|
|
|
|
|
props = ahci_command_find(ide_cmd);
|
|
|
|
g_assert(props);
|
|
|
|
ptr = ahci_alloc(ahci, bufsize);
|
2016-01-11 22:10:43 +03:00
|
|
|
g_assert(!bufsize || ptr);
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memset(ahci->parent->qts, ptr, 0x00, bufsize);
|
2015-02-05 20:41:27 +03:00
|
|
|
|
2016-01-11 22:10:43 +03:00
|
|
|
if (bufsize && props->write) {
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_bufwrite(ahci->parent->qts, ptr, buffer, bufsize);
|
2015-02-05 20:41:27 +03:00
|
|
|
}
|
|
|
|
|
2015-04-28 22:27:51 +03:00
|
|
|
ahci_guest_io(ahci, port, ide_cmd, ptr, bufsize, sector);
|
2015-02-05 20:41:27 +03:00
|
|
|
|
2016-01-11 22:10:43 +03:00
|
|
|
if (bufsize && props->read) {
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_bufread(ahci->parent->qts, ptr, buffer, bufsize);
|
2015-02-05 20:41:27 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
ahci_free(ahci, ptr);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
/**
|
|
|
|
* Initializes a basic command header in memory.
|
|
|
|
* We assume that this is for an ATA command using RegH2DFIS.
|
|
|
|
*/
|
|
|
|
static void command_header_init(AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
AHCICommandHeader *hdr = &cmd->header;
|
|
|
|
AHCICommandProp *props = cmd->props;
|
|
|
|
|
|
|
|
hdr->flags = 5; /* RegH2DFIS is 5 DW long. Must be < 32 */
|
|
|
|
hdr->flags |= CMDH_CLR_BSY; /* Clear the BSY bit when done */
|
|
|
|
if (props->write) {
|
|
|
|
hdr->flags |= CMDH_WRITE;
|
|
|
|
}
|
|
|
|
if (props->atapi) {
|
|
|
|
hdr->flags |= CMDH_ATAPI;
|
|
|
|
}
|
|
|
|
/* Other flags: PREFETCH, RESET, and BIST */
|
|
|
|
hdr->prdtl = size_to_prdtl(cmd->xbytes, cmd->prd_size);
|
|
|
|
hdr->prdbc = 0;
|
|
|
|
hdr->ctba = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void command_table_init(AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
RegH2DFIS *fis = &(cmd->fis);
|
2018-06-06 22:09:49 +03:00
|
|
|
uint16_t sect_count = (cmd->xbytes / cmd->sector_size);
|
2015-02-05 20:41:23 +03:00
|
|
|
|
|
|
|
fis->fis_type = REG_H2D_FIS;
|
|
|
|
fis->flags = REG_H2D_FIS_CMD; /* "Command" bit */
|
|
|
|
fis->command = cmd->name;
|
2015-07-04 09:06:03 +03:00
|
|
|
|
|
|
|
if (cmd->props->ncq) {
|
|
|
|
NCQFIS *ncqfis = (NCQFIS *)fis;
|
|
|
|
/* NCQ is weird and re-uses FIS frames for unrelated data.
|
|
|
|
* See SATA 3.2, 13.6.4.1 READ FPDMA QUEUED for an example. */
|
|
|
|
ncqfis->sector_low = sect_count & 0xFF;
|
|
|
|
ncqfis->sector_hi = (sect_count >> 8) & 0xFF;
|
|
|
|
ncqfis->device = NCQ_DEVICE_MAGIC;
|
|
|
|
/* Force Unit Access is bit 7 in the device register */
|
|
|
|
ncqfis->tag = 0; /* bits 3-7 are the NCQ tag */
|
|
|
|
ncqfis->prio = 0; /* bits 6,7 are a prio tag */
|
|
|
|
/* RARC bit is bit 0 of TAG field */
|
|
|
|
} else {
|
|
|
|
fis->feature_low = 0x00;
|
|
|
|
fis->feature_high = 0x00;
|
|
|
|
if (cmd->props->lba28 || cmd->props->lba48) {
|
|
|
|
fis->device = ATA_DEVICE_LBA;
|
|
|
|
}
|
2018-06-06 22:09:49 +03:00
|
|
|
fis->count = (cmd->xbytes / cmd->sector_size);
|
2015-02-05 20:41:23 +03:00
|
|
|
}
|
2015-07-04 09:06:03 +03:00
|
|
|
fis->icc = 0x00;
|
|
|
|
fis->control = 0x00;
|
|
|
|
memset(fis->aux, 0x00, ARRAY_SIZE(fis->aux));
|
2015-02-05 20:41:23 +03:00
|
|
|
}
|
|
|
|
|
2016-01-11 22:10:42 +03:00
|
|
|
void ahci_command_enable_atapi_dma(AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
RegH2DFIS *fis = &(cmd->fis);
|
|
|
|
g_assert(cmd->props->atapi);
|
|
|
|
fis->feature_low |= 0x01;
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
/* PIO is still used to transfer the ATAPI command */
|
|
|
|
g_assert(cmd->props->pio);
|
2016-01-11 22:10:43 +03:00
|
|
|
cmd->props->dma = true;
|
|
|
|
/* BUG: We expect the DMA Setup interrupt for DMA commands */
|
|
|
|
/* cmd->interrupts |= AHCI_PX_IS_DSS; */
|
2016-01-11 22:10:42 +03:00
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
AHCICommand *ahci_command_create(uint8_t command_name)
|
|
|
|
{
|
|
|
|
AHCICommandProp *props = ahci_command_find(command_name);
|
|
|
|
AHCICommand *cmd;
|
|
|
|
|
|
|
|
g_assert(props);
|
2017-10-07 02:49:56 +03:00
|
|
|
cmd = g_new0(AHCICommand, 1);
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
g_assert(!(props->dma && props->pio) || props->atapi);
|
2015-02-05 20:41:23 +03:00
|
|
|
g_assert(!(props->lba28 && props->lba48));
|
|
|
|
g_assert(!(props->read && props->write));
|
|
|
|
g_assert(!props->size || props->data);
|
2015-10-05 19:00:55 +03:00
|
|
|
g_assert(!props->ncq || props->lba48);
|
2015-02-05 20:41:23 +03:00
|
|
|
|
|
|
|
/* Defaults and book-keeping */
|
2016-01-11 22:10:43 +03:00
|
|
|
cmd->props = g_memdup(props, sizeof(AHCICommandProp));
|
2015-02-05 20:41:23 +03:00
|
|
|
cmd->name = command_name;
|
|
|
|
cmd->xbytes = props->size;
|
|
|
|
cmd->prd_size = 4096;
|
|
|
|
cmd->buffer = 0xabad1dea;
|
2018-06-06 22:09:49 +03:00
|
|
|
cmd->sector_size = props->atapi ? ATAPI_SECTOR_SIZE : AHCI_SECTOR_SIZE;
|
2015-02-05 20:41:23 +03:00
|
|
|
|
2015-07-04 09:06:04 +03:00
|
|
|
if (!cmd->props->ncq) {
|
|
|
|
cmd->interrupts = AHCI_PX_IS_DHRS;
|
|
|
|
}
|
2015-02-05 20:41:23 +03:00
|
|
|
/* BUG: We expect the DPS interrupt for data commands */
|
|
|
|
/* cmd->interrupts |= props->data ? AHCI_PX_IS_DPS : 0; */
|
|
|
|
/* BUG: We expect the DMA Setup interrupt for DMA commands */
|
|
|
|
/* cmd->interrupts |= props->dma ? AHCI_PX_IS_DSS : 0; */
|
2015-07-04 09:06:04 +03:00
|
|
|
cmd->interrupts |= props->ncq ? AHCI_PX_IS_SDBS : 0;
|
2015-02-05 20:41:23 +03:00
|
|
|
|
|
|
|
command_header_init(cmd);
|
|
|
|
command_table_init(cmd);
|
|
|
|
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2018-06-25 23:50:48 +03:00
|
|
|
AHCICommand *ahci_atapi_command_create(uint8_t scsi_cmd, uint16_t bcl, bool dma)
|
2016-01-11 22:10:42 +03:00
|
|
|
{
|
|
|
|
AHCICommand *cmd = ahci_command_create(CMD_PACKET);
|
|
|
|
cmd->atapi_cmd = g_malloc0(16);
|
|
|
|
cmd->atapi_cmd[0] = scsi_cmd;
|
2016-11-14 19:15:54 +03:00
|
|
|
stw_le_p(&cmd->fis.lba_lo[1], bcl);
|
2018-06-25 23:50:48 +03:00
|
|
|
if (dma) {
|
|
|
|
ahci_command_enable_atapi_dma(cmd);
|
|
|
|
} else {
|
|
|
|
cmd->interrupts |= bcl ? AHCI_PX_IS_PSS : 0;
|
|
|
|
}
|
2016-01-11 22:10:42 +03:00
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2016-11-14 19:15:55 +03:00
|
|
|
void ahci_atapi_test_ready(AHCIQState *ahci, uint8_t port,
|
|
|
|
bool ready, uint8_t expected_sense)
|
|
|
|
{
|
2018-06-25 23:50:48 +03:00
|
|
|
AHCICommand *cmd = ahci_atapi_command_create(CMD_ATAPI_TEST_UNIT_READY, 0, false);
|
2016-11-14 19:15:55 +03:00
|
|
|
ahci_command_set_size(cmd, 0);
|
|
|
|
if (!ready) {
|
|
|
|
cmd->interrupts |= AHCI_PX_IS_TFES;
|
|
|
|
cmd->errors |= expected_sense << 4;
|
|
|
|
}
|
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int copy_buffer(AHCIQState *ahci, AHCICommand *cmd,
|
|
|
|
const AHCIOpts *opts)
|
|
|
|
{
|
|
|
|
unsigned char *rx = opts->opaque;
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_bufread(ahci->parent->qts, opts->buffer, rx, opts->size);
|
2016-11-14 19:15:55 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_atapi_get_sense(AHCIQState *ahci, uint8_t port,
|
|
|
|
uint8_t *sense, uint8_t *asc)
|
|
|
|
{
|
|
|
|
unsigned char *rx;
|
|
|
|
AHCIOpts opts = {
|
|
|
|
.size = 18,
|
|
|
|
.atapi = true,
|
|
|
|
.post_cb = copy_buffer,
|
|
|
|
};
|
|
|
|
rx = g_malloc(18);
|
|
|
|
opts.opaque = rx;
|
|
|
|
|
|
|
|
ahci_exec(ahci, port, CMD_ATAPI_REQUEST_SENSE, &opts);
|
|
|
|
|
|
|
|
*sense = rx[2];
|
|
|
|
*asc = rx[12];
|
|
|
|
|
|
|
|
g_free(rx);
|
|
|
|
}
|
|
|
|
|
2016-11-14 19:15:55 +03:00
|
|
|
void ahci_atapi_eject(AHCIQState *ahci, uint8_t port)
|
|
|
|
{
|
2018-06-25 23:50:48 +03:00
|
|
|
AHCICommand *cmd = ahci_atapi_command_create(CMD_ATAPI_START_STOP_UNIT, 0, false);
|
2016-11-14 19:15:55 +03:00
|
|
|
ahci_command_set_size(cmd, 0);
|
|
|
|
|
|
|
|
cmd->atapi_cmd[4] = 0x02; /* loej = true */
|
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_atapi_load(AHCIQState *ahci, uint8_t port)
|
|
|
|
{
|
2018-06-25 23:50:48 +03:00
|
|
|
AHCICommand *cmd = ahci_atapi_command_create(CMD_ATAPI_START_STOP_UNIT, 0, false);
|
2016-11-14 19:15:55 +03:00
|
|
|
ahci_command_set_size(cmd, 0);
|
|
|
|
|
|
|
|
cmd->atapi_cmd[4] = 0x03; /* loej,start = true */
|
|
|
|
ahci_command_commit(ahci, cmd, port);
|
|
|
|
ahci_command_issue(ahci, cmd);
|
|
|
|
ahci_command_verify(ahci, cmd);
|
|
|
|
ahci_command_free(cmd);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
void ahci_command_free(AHCICommand *cmd)
|
|
|
|
{
|
2016-01-11 22:10:42 +03:00
|
|
|
g_free(cmd->atapi_cmd);
|
2016-01-11 22:10:43 +03:00
|
|
|
g_free(cmd->props);
|
2015-02-05 20:41:23 +03:00
|
|
|
g_free(cmd);
|
|
|
|
}
|
|
|
|
|
2015-02-26 02:06:37 +03:00
|
|
|
void ahci_command_set_flags(AHCICommand *cmd, uint16_t cmdh_flags)
|
|
|
|
{
|
|
|
|
cmd->header.flags |= cmdh_flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_clr_flags(AHCICommand *cmd, uint16_t cmdh_flags)
|
|
|
|
{
|
|
|
|
cmd->header.flags &= ~cmdh_flags;
|
|
|
|
}
|
|
|
|
|
2016-01-11 22:10:42 +03:00
|
|
|
static void ahci_atapi_command_set_offset(AHCICommand *cmd, uint64_t lba)
|
|
|
|
{
|
|
|
|
unsigned char *cbd = cmd->atapi_cmd;
|
|
|
|
g_assert(cbd);
|
|
|
|
|
|
|
|
switch (cbd[0]) {
|
|
|
|
case CMD_ATAPI_READ_10:
|
2016-11-14 19:15:54 +03:00
|
|
|
case CMD_ATAPI_READ_CD:
|
2016-01-11 22:10:42 +03:00
|
|
|
g_assert_cmpuint(lba, <=, UINT32_MAX);
|
|
|
|
stl_be_p(&cbd[2], lba);
|
|
|
|
break;
|
2016-11-14 19:15:55 +03:00
|
|
|
case CMD_ATAPI_REQUEST_SENSE:
|
|
|
|
case CMD_ATAPI_TEST_UNIT_READY:
|
2016-11-14 19:15:55 +03:00
|
|
|
case CMD_ATAPI_START_STOP_UNIT:
|
|
|
|
g_assert_cmpuint(lba, ==, 0x00);
|
|
|
|
break;
|
2016-01-11 22:10:42 +03:00
|
|
|
default:
|
|
|
|
/* SCSI doesn't have uniform packet formats,
|
|
|
|
* so you have to add support for it manually. Sorry! */
|
2016-11-14 19:15:54 +03:00
|
|
|
fprintf(stderr, "The Libqos AHCI driver does not support the "
|
|
|
|
"set_offset operation for ATAPI command 0x%02x, "
|
|
|
|
"please add support.\n",
|
|
|
|
cbd[0]);
|
2016-01-11 22:10:42 +03:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-26 02:06:37 +03:00
|
|
|
void ahci_command_set_offset(AHCICommand *cmd, uint64_t lba_sect)
|
|
|
|
{
|
|
|
|
RegH2DFIS *fis = &(cmd->fis);
|
2016-01-11 22:10:42 +03:00
|
|
|
|
|
|
|
if (cmd->props->atapi) {
|
|
|
|
ahci_atapi_command_set_offset(cmd, lba_sect);
|
|
|
|
return;
|
2016-01-11 22:10:43 +03:00
|
|
|
} else if (!cmd->props->data && !lba_sect) {
|
|
|
|
/* Not meaningful, ignore. */
|
|
|
|
return;
|
2016-01-11 22:10:42 +03:00
|
|
|
} else if (cmd->props->lba28) {
|
2015-02-26 02:06:37 +03:00
|
|
|
g_assert_cmphex(lba_sect, <=, 0xFFFFFFF);
|
2015-07-04 09:06:04 +03:00
|
|
|
} else if (cmd->props->lba48 || cmd->props->ncq) {
|
2015-02-26 02:06:37 +03:00
|
|
|
g_assert_cmphex(lba_sect, <=, 0xFFFFFFFFFFFF);
|
|
|
|
} else {
|
|
|
|
/* Can't set offset if we don't know the format. */
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* LBA28 uses the low nibble of the device/control register for LBA24:27 */
|
|
|
|
fis->lba_lo[0] = (lba_sect & 0xFF);
|
|
|
|
fis->lba_lo[1] = (lba_sect >> 8) & 0xFF;
|
|
|
|
fis->lba_lo[2] = (lba_sect >> 16) & 0xFF;
|
|
|
|
if (cmd->props->lba28) {
|
2015-05-22 21:13:42 +03:00
|
|
|
fis->device = (fis->device & 0xF0) | ((lba_sect >> 24) & 0x0F);
|
2015-02-26 02:06:37 +03:00
|
|
|
}
|
|
|
|
fis->lba_hi[0] = (lba_sect >> 24) & 0xFF;
|
|
|
|
fis->lba_hi[1] = (lba_sect >> 32) & 0xFF;
|
|
|
|
fis->lba_hi[2] = (lba_sect >> 40) & 0xFF;
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
void ahci_command_set_buffer(AHCICommand *cmd, uint64_t buffer)
|
|
|
|
{
|
|
|
|
cmd->buffer = buffer;
|
|
|
|
}
|
|
|
|
|
2016-01-11 22:10:42 +03:00
|
|
|
static void ahci_atapi_set_size(AHCICommand *cmd, uint64_t xbytes)
|
|
|
|
{
|
|
|
|
unsigned char *cbd = cmd->atapi_cmd;
|
2018-06-06 22:09:49 +03:00
|
|
|
uint64_t nsectors = xbytes / ATAPI_SECTOR_SIZE;
|
2016-11-14 19:15:54 +03:00
|
|
|
uint32_t tmp;
|
2016-01-11 22:10:42 +03:00
|
|
|
g_assert(cbd);
|
|
|
|
|
|
|
|
switch (cbd[0]) {
|
|
|
|
case CMD_ATAPI_READ_10:
|
|
|
|
g_assert_cmpuint(nsectors, <=, UINT16_MAX);
|
|
|
|
stw_be_p(&cbd[7], nsectors);
|
|
|
|
break;
|
2016-11-14 19:15:54 +03:00
|
|
|
case CMD_ATAPI_READ_CD:
|
|
|
|
/* 24bit BE store */
|
|
|
|
g_assert_cmpuint(nsectors, <, 1ULL << 24);
|
|
|
|
tmp = nsectors;
|
|
|
|
cbd[6] = (tmp & 0xFF0000) >> 16;
|
|
|
|
cbd[7] = (tmp & 0xFF00) >> 8;
|
|
|
|
cbd[8] = (tmp & 0xFF);
|
|
|
|
break;
|
2016-11-14 19:15:55 +03:00
|
|
|
case CMD_ATAPI_REQUEST_SENSE:
|
|
|
|
g_assert_cmpuint(xbytes, <=, UINT8_MAX);
|
|
|
|
cbd[4] = (uint8_t)xbytes;
|
|
|
|
break;
|
|
|
|
case CMD_ATAPI_TEST_UNIT_READY:
|
2016-11-14 19:15:55 +03:00
|
|
|
case CMD_ATAPI_START_STOP_UNIT:
|
|
|
|
g_assert_cmpuint(xbytes, ==, 0);
|
|
|
|
break;
|
2016-01-11 22:10:42 +03:00
|
|
|
default:
|
|
|
|
/* SCSI doesn't have uniform packet formats,
|
|
|
|
* so you have to add support for it manually. Sorry! */
|
2016-11-14 19:15:54 +03:00
|
|
|
fprintf(stderr, "The Libqos AHCI driver does not support the set_size "
|
|
|
|
"operation for ATAPI command 0x%02x, please add support.\n",
|
|
|
|
cbd[0]);
|
2016-01-11 22:10:42 +03:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:25 +03:00
|
|
|
void ahci_command_set_sizes(AHCICommand *cmd, uint64_t xbytes,
|
|
|
|
unsigned prd_size)
|
|
|
|
{
|
2015-07-04 09:06:03 +03:00
|
|
|
uint16_t sect_count;
|
|
|
|
|
2015-02-05 20:41:25 +03:00
|
|
|
/* Each PRD can describe up to 4MiB, and must not be odd. */
|
|
|
|
g_assert_cmphex(prd_size, <=, 4096 * 1024);
|
|
|
|
g_assert_cmphex(prd_size & 0x01, ==, 0x00);
|
2015-05-22 21:13:42 +03:00
|
|
|
if (prd_size) {
|
|
|
|
cmd->prd_size = prd_size;
|
|
|
|
}
|
2015-02-05 20:41:25 +03:00
|
|
|
cmd->xbytes = xbytes;
|
2018-06-06 22:09:49 +03:00
|
|
|
sect_count = (cmd->xbytes / cmd->sector_size);
|
2015-07-04 09:06:03 +03:00
|
|
|
|
|
|
|
if (cmd->props->ncq) {
|
|
|
|
NCQFIS *nfis = (NCQFIS *)&(cmd->fis);
|
|
|
|
nfis->sector_low = sect_count & 0xFF;
|
|
|
|
nfis->sector_hi = (sect_count >> 8) & 0xFF;
|
2016-01-11 22:10:42 +03:00
|
|
|
} else if (cmd->props->atapi) {
|
|
|
|
ahci_atapi_set_size(cmd, xbytes);
|
2015-07-04 09:06:03 +03:00
|
|
|
} else {
|
2018-06-25 23:50:48 +03:00
|
|
|
/* For writes, the PIO Setup FIS interrupt only comes from DRQs
|
|
|
|
* after the first.
|
|
|
|
*/
|
|
|
|
if (cmd->props->pio && sect_count > (cmd->props->read ? 0 : 1)) {
|
|
|
|
cmd->interrupts |= AHCI_PX_IS_PSS;
|
|
|
|
}
|
2015-07-04 09:06:03 +03:00
|
|
|
cmd->fis.count = sect_count;
|
|
|
|
}
|
2015-02-05 20:41:25 +03:00
|
|
|
cmd->header.prdtl = size_to_prdtl(cmd->xbytes, cmd->prd_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_set_size(AHCICommand *cmd, uint64_t xbytes)
|
|
|
|
{
|
|
|
|
ahci_command_set_sizes(cmd, xbytes, cmd->prd_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_set_prd_size(AHCICommand *cmd, unsigned prd_size)
|
|
|
|
{
|
|
|
|
ahci_command_set_sizes(cmd, cmd->xbytes, prd_size);
|
|
|
|
}
|
|
|
|
|
2015-02-26 02:06:37 +03:00
|
|
|
void ahci_command_adjust(AHCICommand *cmd, uint64_t offset, uint64_t buffer,
|
|
|
|
uint64_t xbytes, unsigned prd_size)
|
|
|
|
{
|
|
|
|
ahci_command_set_sizes(cmd, xbytes, prd_size);
|
|
|
|
ahci_command_set_buffer(cmd, buffer);
|
|
|
|
ahci_command_set_offset(cmd, offset);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
void ahci_command_commit(AHCIQState *ahci, AHCICommand *cmd, uint8_t port)
|
|
|
|
{
|
|
|
|
uint16_t i, prdtl;
|
|
|
|
uint64_t table_size, table_ptr, remaining;
|
|
|
|
PRD prd;
|
|
|
|
|
|
|
|
/* This command is now tied to this port/command slot */
|
|
|
|
cmd->port = port;
|
|
|
|
cmd->slot = ahci_pick_cmd(ahci, port);
|
|
|
|
|
2015-07-04 09:06:04 +03:00
|
|
|
if (cmd->props->ncq) {
|
|
|
|
NCQFIS *nfis = (NCQFIS *)&cmd->fis;
|
|
|
|
nfis->tag = (cmd->slot << 3) & 0xFC;
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
/* Create a buffer for the command table */
|
|
|
|
prdtl = size_to_prdtl(cmd->xbytes, cmd->prd_size);
|
|
|
|
table_size = CMD_TBL_SIZ(prdtl);
|
|
|
|
table_ptr = ahci_alloc(ahci, table_size);
|
|
|
|
g_assert(table_ptr);
|
|
|
|
/* AHCI 1.3: Must be aligned to 0x80 */
|
|
|
|
g_assert((table_ptr & 0x7F) == 0x00);
|
|
|
|
cmd->header.ctba = table_ptr;
|
|
|
|
|
2016-01-11 22:10:42 +03:00
|
|
|
/* Commit the command header (part of the Command List Buffer) */
|
2015-02-05 20:41:23 +03:00
|
|
|
ahci_set_command_header(ahci, port, cmd->slot, &(cmd->header));
|
2016-01-11 22:10:42 +03:00
|
|
|
/* Now, write the command table (FIS, ACMD, and PRDT) -- FIS first, */
|
2015-07-06 22:17:09 +03:00
|
|
|
ahci_write_fis(ahci, cmd);
|
2016-01-11 22:10:42 +03:00
|
|
|
/* Then ATAPI CMD, if needed */
|
|
|
|
if (cmd->props->atapi) {
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memwrite(ahci->parent->qts, table_ptr + 0x40, cmd->atapi_cmd, 16);
|
2016-01-11 22:10:42 +03:00
|
|
|
}
|
2015-02-05 20:41:23 +03:00
|
|
|
|
|
|
|
/* Construct and write the PRDs to the command table */
|
|
|
|
g_assert_cmphex(prdtl, ==, cmd->header.prdtl);
|
|
|
|
remaining = cmd->xbytes;
|
|
|
|
for (i = 0; i < prdtl; ++i) {
|
|
|
|
prd.dba = cpu_to_le64(cmd->buffer + (cmd->prd_size * i));
|
|
|
|
prd.res = 0;
|
|
|
|
if (remaining > cmd->prd_size) {
|
|
|
|
/* Note that byte count is 0-based. */
|
|
|
|
prd.dbc = cpu_to_le32(cmd->prd_size - 1);
|
|
|
|
remaining -= cmd->prd_size;
|
|
|
|
} else {
|
|
|
|
/* Again, dbc is 0-based. */
|
|
|
|
prd.dbc = cpu_to_le32(remaining - 1);
|
|
|
|
remaining = 0;
|
|
|
|
}
|
|
|
|
prd.dbc |= cpu_to_le32(0x80000000); /* Request DPS Interrupt */
|
|
|
|
|
|
|
|
/* Commit the PRD entry to the Command Table */
|
2017-09-11 20:20:00 +03:00
|
|
|
qtest_memwrite(ahci->parent->qts, table_ptr + 0x80 + (i * sizeof(PRD)),
|
|
|
|
&prd, sizeof(PRD));
|
2015-02-05 20:41:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Bookmark the PRDTL and CTBA values */
|
|
|
|
ahci->port[port].ctba[cmd->slot] = table_ptr;
|
|
|
|
ahci->port[port].prdtl[cmd->slot] = prdtl;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_issue_async(AHCIQState *ahci, AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
if (cmd->props->ncq) {
|
|
|
|
ahci_px_wreg(ahci, cmd->port, AHCI_PX_SACT, (1 << cmd->slot));
|
|
|
|
}
|
|
|
|
|
|
|
|
ahci_px_wreg(ahci, cmd->port, AHCI_PX_CI, (1 << cmd->slot));
|
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_wait(AHCIQState *ahci, AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
/* We can't rely on STS_BSY until the command has started processing.
|
|
|
|
* Therefore, we also use the Command Issue bit as indication of
|
|
|
|
* a command in-flight. */
|
2015-07-04 09:06:03 +03:00
|
|
|
|
|
|
|
#define RSET(REG, MASK) (BITSET(ahci_px_rreg(ahci, cmd->port, (REG)), (MASK)))
|
|
|
|
|
|
|
|
while (RSET(AHCI_PX_TFD, AHCI_PX_TFD_STS_BSY) ||
|
|
|
|
RSET(AHCI_PX_CI, 1 << cmd->slot) ||
|
|
|
|
(cmd->props->ncq && RSET(AHCI_PX_SACT, 1 << cmd->slot))) {
|
2015-02-05 20:41:23 +03:00
|
|
|
usleep(50);
|
|
|
|
}
|
2015-07-04 09:06:03 +03:00
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void ahci_command_issue(AHCIQState *ahci, AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
ahci_command_issue_async(ahci, cmd);
|
|
|
|
ahci_command_wait(ahci, cmd);
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:24 +03:00
|
|
|
void ahci_command_verify(AHCIQState *ahci, AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
uint8_t slot = cmd->slot;
|
|
|
|
uint8_t port = cmd->port;
|
|
|
|
|
2016-11-14 19:15:54 +03:00
|
|
|
ahci_port_check_error(ahci, port, cmd->interrupts, cmd->errors);
|
2015-02-05 20:41:24 +03:00
|
|
|
ahci_port_check_interrupts(ahci, port, cmd->interrupts);
|
|
|
|
ahci_port_check_nonbusy(ahci, port, slot);
|
2015-07-04 09:06:03 +03:00
|
|
|
ahci_port_check_cmd_sanity(ahci, cmd);
|
2015-07-04 09:06:04 +03:00
|
|
|
if (cmd->interrupts & AHCI_PX_IS_DHRS) {
|
|
|
|
ahci_port_check_d2h_sanity(ahci, port, slot);
|
|
|
|
}
|
2015-02-05 20:41:24 +03:00
|
|
|
if (cmd->props->pio) {
|
ahci: move PIO Setup FIS before transfer, fix it for ATAPI commands
The PIO Setup FIS is written in the PIO:Entry state, which comes before
the ATA and ATAPI data transfer states. As a result, the PIO Setup FIS
interrupt is now raised before DMA ends for ATAPI commands, and tests have
to be adjusted.
This is also hinted by the description of the command header in the AHCI
specification, where the "A" bit is described as
When ‘1’, indicates that a PIO setup FIS shall be sent by the device
indicating a transfer for the ATAPI command.
and also by the description of the ACMD (ATAPI command region):
The ATAPI command must be either 12 or 16 bytes in length. The length
transmitted by the HBA is determined by the PIO setup FIS that is sent
by the device requesting the ATAPI command.
QEMU, which conflates the "generator" and the "receiver" of the FIS into
one device, always uses ATAPI_PACKET_SIZE, aka 12, for the length.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20180606190955.20845-3-jsnow@redhat.com
Signed-off-by: John Snow <jsnow@redhat.com>
2018-06-06 22:09:50 +03:00
|
|
|
ahci_port_check_pio_sanity(ahci, cmd);
|
2015-02-05 20:41:24 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-05 20:41:23 +03:00
|
|
|
uint8_t ahci_command_slot(AHCICommand *cmd)
|
|
|
|
{
|
|
|
|
return cmd->slot;
|
|
|
|
}
|