tests/libqos/pci-pc.c

   1 /*
   2  * libqos PCI bindings for PC
   3  *
   4  * Copyright IBM, Corp. 2012-2013
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "libqtest.h"
  15 #include "libqos/pci-pc.h"
  16 #include "qapi/qmp/qdict.h"
  17 #include "hw/pci/pci_regs.h"
  18
  19 #include "qemu-common.h"
  20
  21
  22 #define ACPI_PCIHP_ADDR         0xae00
  23 #define PCI_EJ_BASE             0x0008
  24
  25 typedef struct QPCIBusPC
  26 {
  27     QPCIBus bus;
  28 } QPCIBusPC;
  29
  30 static uint8_t qpci_pc_pio_readb(QPCIBus *bus, uint32_t addr)
  31 {
  32     return qtest_inb(bus->qts, addr);
  33 }
  34
  35 static void qpci_pc_pio_writeb(QPCIBus *bus, uint32_t addr, uint8_t val)
  36 {
  37     qtest_outb(bus->qts, addr, val);
  38 }
  39
  40 static uint16_t qpci_pc_pio_readw(QPCIBus *bus, uint32_t addr)
  41 {
  42     return qtest_inw(bus->qts, addr);
  43 }
  44
  45 static void qpci_pc_pio_writew(QPCIBus *bus, uint32_t addr, uint16_t val)
  46 {
  47     qtest_outw(bus->qts, addr, val);
  48 }
  49
  50 static uint32_t qpci_pc_pio_readl(QPCIBus *bus, uint32_t addr)
  51 {
  52     return qtest_inl(bus->qts, addr);
  53 }
  54
  55 static void qpci_pc_pio_writel(QPCIBus *bus, uint32_t addr, uint32_t val)
  56 {
  57     qtest_outl(bus->qts, addr, val);
  58 }
  59
  60 static uint64_t qpci_pc_pio_readq(QPCIBus *bus, uint32_t addr)
  61 {
  62     return (uint64_t)qtest_inl(bus->qts, addr) +
  63         ((uint64_t)qtest_inl(bus->qts, addr + 4) << 32);
  64 }
  65
  66 static void qpci_pc_pio_writeq(QPCIBus *bus, uint32_t addr, uint64_t val)
  67 {
  68     qtest_outl(bus->qts, addr, val & 0xffffffff);
  69     qtest_outl(bus->qts, addr + 4, val >> 32);
  70 }
  71
  72 static void qpci_pc_memread(QPCIBus *bus, uint32_t addr, void *buf, size_t len)
  73 {
  74     qtest_memread(bus->qts, addr, buf, len);
  75 }
  76
  77 static void qpci_pc_memwrite(QPCIBus *bus, uint32_t addr,
  78                              const void *buf, size_t len)
  79 {
  80     qtest_memwrite(bus->qts, addr, buf, len);
  81 }
  82
  83 static uint8_t qpci_pc_config_readb(QPCIBus *bus, int devfn, uint8_t offset)
  84 {
  85     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
  86     return qtest_inb(bus->qts, 0xcfc);
  87 }
  88
  89 static uint16_t qpci_pc_config_readw(QPCIBus *bus, int devfn, uint8_t offset)
  90 {
  91     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
  92     return qtest_inw(bus->qts, 0xcfc);
  93 }
  94
  95 static uint32_t qpci_pc_config_readl(QPCIBus *bus, int devfn, uint8_t offset)
  96 {
  97     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
  98     return qtest_inl(bus->qts, 0xcfc);
  99 }
 100
 101 static void qpci_pc_config_writeb(QPCIBus *bus, int devfn, uint8_t offset, uint8_t value)
 102 {
 103     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
 104     qtest_outb(bus->qts, 0xcfc, value);
 105 }
 106
 107 static void qpci_pc_config_writew(QPCIBus *bus, int devfn, uint8_t offset, uint16_t value)
 108 {
 109     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
 110     qtest_outw(bus->qts, 0xcfc, value);
 111 }
 112
 113 static void qpci_pc_config_writel(QPCIBus *bus, int devfn, uint8_t offset, uint32_t value)
 114 {
 115     qtest_outl(bus->qts, 0xcf8, (1U << 31) | (devfn << 8) | offset);
 116     qtest_outl(bus->qts, 0xcfc, value);
 117 }
 118
 119 QPCIBus *qpci_init_pc(QTestState *qts, QGuestAllocator *alloc)
 120 {
 121     QPCIBusPC *ret = g_new0(QPCIBusPC, 1);
 122
 123     assert(qts);
 124
 125     ret->bus.pio_readb = qpci_pc_pio_readb;
 126     ret->bus.pio_readw = qpci_pc_pio_readw;
 127     ret->bus.pio_readl = qpci_pc_pio_readl;
 128     ret->bus.pio_readq = qpci_pc_pio_readq;
 129
 130     ret->bus.pio_writeb = qpci_pc_pio_writeb;
 131     ret->bus.pio_writew = qpci_pc_pio_writew;
 132     ret->bus.pio_writel = qpci_pc_pio_writel;
 133     ret->bus.pio_writeq = qpci_pc_pio_writeq;
 134
 135     ret->bus.memread = qpci_pc_memread;
 136     ret->bus.memwrite = qpci_pc_memwrite;
 137
 138     ret->bus.config_readb = qpci_pc_config_readb;
 139     ret->bus.config_readw = qpci_pc_config_readw;
 140     ret->bus.config_readl = qpci_pc_config_readl;
 141
 142     ret->bus.config_writeb = qpci_pc_config_writeb;
 143     ret->bus.config_writew = qpci_pc_config_writew;
 144     ret->bus.config_writel = qpci_pc_config_writel;
 145
 146     ret->bus.qts = qts;
 147     ret->bus.pio_alloc_ptr = 0xc000;
 148     ret->bus.mmio_alloc_ptr = 0xE0000000;
 149     ret->bus.mmio_limit = 0x100000000ULL;
 150
 151     return &ret->bus;
 152 }
 153
 154 void qpci_free_pc(QPCIBus *bus)
 155 {
 156     QPCIBusPC *s = container_of(bus, QPCIBusPC, bus);
 157
 158     g_free(s);
 159 }
 160
 161 void qpci_unplug_acpi_device_test(const char *id, uint8_t slot)
 162 {
 163     QDict *response;
 164
 165     response = qmp("{'execute': 'device_del', 'arguments': {'id': %s}}",
 166                    id);
 167     g_assert(response);
 168     g_assert(!qdict_haskey(response, "error"));
 169     qobject_unref(response);
 170
 171     outb(ACPI_PCIHP_ADDR + PCI_EJ_BASE, 1 << slot);
 172
 173     qmp_eventwait("DEVICE_DELETED");
 174 }