Archipelago » qemu

/*

 * QEMU PCI bus manager

 *

 * Copyright (c) 2004 Fabrice Bellard

 *

 * 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.

 */

#include "hw.h"

#include "pci.h"

#include "pci_bridge.h"

#include "pci_internals.h"

#include "monitor.h"

#include "net.h"

#include "sysemu.h"

#include "loader.h"

#include "range.h"

#include "qmp-commands.h"

//#define DEBUG_PCI

#ifdef DEBUG_PCI

# define PCI_DPRINTF(format, ...)       printf(format, ## __VA_ARGS__)

#else

# define PCI_DPRINTF(format, ...)       do { } while (0)

#endif

static void pcibus_dev_print(Monitor *mon, DeviceState *dev, int indent);

static char *pcibus_get_dev_path(DeviceState *dev);

static char *pcibus_get_fw_dev_path(DeviceState *dev);

static int pcibus_reset(BusState *qbus);

struct BusInfo pci_bus_info = {

    .name       = "PCI",

    .size       = sizeof(PCIBus),

    .print_dev  = pcibus_dev_print,

    .get_dev_path = pcibus_get_dev_path,

    .get_fw_dev_path = pcibus_get_fw_dev_path,

    .reset      = pcibus_reset,

    .props      = (Property[]) {

        DEFINE_PROP_PCI_DEVFN("addr", PCIDevice, devfn, -1),

        DEFINE_PROP_STRING("romfile", PCIDevice, romfile),

        DEFINE_PROP_UINT32("rombar",  PCIDevice, rom_bar, 1),

        DEFINE_PROP_BIT("multifunction", PCIDevice, cap_present,

                        QEMU_PCI_CAP_MULTIFUNCTION_BITNR, false),

        DEFINE_PROP_BIT("command_serr_enable", PCIDevice, cap_present,

                        QEMU_PCI_CAP_SERR_BITNR, true),

        DEFINE_PROP_END_OF_LIST()

    }

};

static PCIBus *pci_find_bus_nr(PCIBus *bus, int bus_num);

static void pci_update_mappings(PCIDevice *d);

static void pci_set_irq(void *opaque, int irq_num, int level);

static int pci_add_option_rom(PCIDevice *pdev, bool is_default_rom);

static void pci_del_option_rom(PCIDevice *pdev);

static uint16_t pci_default_sub_vendor_id = PCI_SUBVENDOR_ID_REDHAT_QUMRANET;

static uint16_t pci_default_sub_device_id = PCI_SUBDEVICE_ID_QEMU;

struct PCIHostBus {

    int domain;

    struct PCIBus *bus;

    QLIST_ENTRY(PCIHostBus) next;

};

static QLIST_HEAD(, PCIHostBus) host_buses;

static const VMStateDescription vmstate_pcibus = {

    .name = "PCIBUS",

    .version_id = 1,

    .minimum_version_id = 1,

    .minimum_version_id_old = 1,

    .fields      = (VMStateField []) {

        VMSTATE_INT32_EQUAL(nirq, PCIBus),

        VMSTATE_VARRAY_INT32(irq_count, PCIBus, nirq, 0, vmstate_info_int32, int32_t),

        VMSTATE_END_OF_LIST()

    }

};

static int pci_bar(PCIDevice *d, int reg)

{

    uint8_t type;

    if (reg != PCI_ROM_SLOT)

        return PCI_BASE_ADDRESS_0 + reg * 4;

    type = d->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION;

    return type == PCI_HEADER_TYPE_BRIDGE ? PCI_ROM_ADDRESS1 : PCI_ROM_ADDRESS;

}

static inline int pci_irq_state(PCIDevice *d, int irq_num)

{

        return (d->irq_state >> irq_num) & 0x1;

}

static inline void pci_set_irq_state(PCIDevice *d, int irq_num, int level)

{

        d->irq_state &= ~(0x1 << irq_num);

        d->irq_state |= level << irq_num;

}

static void pci_change_irq_level(PCIDevice *pci_dev, int irq_num, int change)

{

    PCIBus *bus;

    for (;;) {

        bus = pci_dev->bus;

        irq_num = bus->map_irq(pci_dev, irq_num);

        if (bus->set_irq)

            break;

        pci_dev = bus->parent_dev;

    }

    bus->irq_count[irq_num] += change;

    bus->set_irq(bus->irq_opaque, irq_num, bus->irq_count[irq_num] != 0);

}

int pci_bus_get_irq_level(PCIBus *bus, int irq_num)

{

    assert(irq_num >= 0);

    assert(irq_num < bus->nirq);

    return !!bus->irq_count[irq_num];

}

/* Update interrupt status bit in config space on interrupt

 * state change. */

static void pci_update_irq_status(PCIDevice *dev)

{

    if (dev->irq_state) {

        dev->config[PCI_STATUS] |= PCI_STATUS_INTERRUPT;

    } else {

        dev->config[PCI_STATUS] &= ~PCI_STATUS_INTERRUPT;

    }

}

void pci_device_deassert_intx(PCIDevice *dev)

{

    int i;

    for (i = 0; i < PCI_NUM_PINS; ++i) {

        qemu_set_irq(dev->irq[i], 0);

    }

}

/*

 * This function is called on #RST and FLR.

 * FLR if PCI_EXP_DEVCTL_BCR_FLR is set

 */

void pci_device_reset(PCIDevice *dev)

{

    int r;

    qdev_reset_all(&dev->qdev);

    dev->irq_state = 0;

    pci_update_irq_status(dev);

    pci_device_deassert_intx(dev);

    /* Clear all writable bits */

    pci_word_test_and_clear_mask(dev->config + PCI_COMMAND,

                                 pci_get_word(dev->wmask + PCI_COMMAND) |

                                 pci_get_word(dev->w1cmask + PCI_COMMAND));

    pci_word_test_and_clear_mask(dev->config + PCI_STATUS,

                                 pci_get_word(dev->wmask + PCI_STATUS) |

                                 pci_get_word(dev->w1cmask + PCI_STATUS));

    dev->config[PCI_CACHE_LINE_SIZE] = 0x0;

    dev->config[PCI_INTERRUPT_LINE] = 0x0;

    for (r = 0; r < PCI_NUM_REGIONS; ++r) {

        PCIIORegion *region = &dev->io_regions[r];

        if (!region->size) {

            continue;

        }

        if (!(region->type & PCI_BASE_ADDRESS_SPACE_IO) &&

            region->type & PCI_BASE_ADDRESS_MEM_TYPE_64) {

            pci_set_quad(dev->config + pci_bar(dev, r), region->type);

        } else {

            pci_set_long(dev->config + pci_bar(dev, r), region->type);

        }

    }

    pci_update_mappings(dev);

}

/*

 * Trigger pci bus reset under a given bus.

 * To be called on RST# assert.

 */

void pci_bus_reset(PCIBus *bus)

{

    int i;

    for (i = 0; i < bus->nirq; i++) {

        bus->irq_count[i] = 0;

    }

    for (i = 0; i < ARRAY_SIZE(bus->devices); ++i) {

        if (bus->devices[i]) {

            pci_device_reset(bus->devices[i]);

        }

    }

}

static int pcibus_reset(BusState *qbus)

{

    pci_bus_reset(DO_UPCAST(PCIBus, qbus, qbus));

    /* topology traverse is done by pci_bus_reset().

       Tell qbus/qdev walker not to traverse the tree */

    return 1;

}

static void pci_host_bus_register(int domain, PCIBus *bus)

{

    struct PCIHostBus *host;

    host = g_malloc0(sizeof(*host));

    host->domain = domain;

    host->bus = bus;

    QLIST_INSERT_HEAD(&host_buses, host, next);

}

PCIBus *pci_find_root_bus(int domain)

{

    struct PCIHostBus *host;

    QLIST_FOREACH(host, &host_buses, next) {

        if (host->domain == domain) {

            return host->bus;

        }

    }

    return NULL;

}

int pci_find_domain(const PCIBus *bus)

{

    PCIDevice *d;

    struct PCIHostBus *host;

    /* obtain root bus */

    while ((d = bus->parent_dev) != NULL) {

        bus = d->bus;

    }

    QLIST_FOREACH(host, &host_buses, next) {

        if (host->bus == bus) {

            return host->domain;

        }

    }

    abort();    /* should not be reached */

    return -1;

}

void pci_bus_new_inplace(PCIBus *bus, DeviceState *parent,

                         const char *name,

                         MemoryRegion *address_space_mem,

                         MemoryRegion *address_space_io,

                         uint8_t devfn_min)

{

    qbus_create_inplace(&bus->qbus, &pci_bus_info, parent, name);

    assert(PCI_FUNC(devfn_min) == 0);

    bus->devfn_min = devfn_min;

    bus->address_space_mem = address_space_mem;

    bus->address_space_io = address_space_io;

    /* host bridge */

    QLIST_INIT(&bus->child);

    pci_host_bus_register(0, bus); /* for now only pci domain 0 is supported */

    vmstate_register(NULL, -1, &vmstate_pcibus, bus);

}

PCIBus *pci_bus_new(DeviceState *parent, const char *name,

                    MemoryRegion *address_space_mem,

                    MemoryRegion *address_space_io,

                    uint8_t devfn_min)

{

    PCIBus *bus;

    bus = g_malloc0(sizeof(*bus));

    bus->qbus.qdev_allocated = 1;

    pci_bus_new_inplace(bus, parent, name, address_space_mem,

                        address_space_io, devfn_min);

    return bus;

}

void pci_bus_irqs(PCIBus *bus, pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,

                  void *irq_opaque, int nirq)

{

    bus->set_irq = set_irq;

    bus->map_irq = map_irq;

    bus->irq_opaque = irq_opaque;

    bus->nirq = nirq;

    bus->irq_count = g_malloc0(nirq * sizeof(bus->irq_count[0]));

}

void pci_bus_hotplug(PCIBus *bus, pci_hotplug_fn hotplug, DeviceState *qdev)

{

    bus->qbus.allow_hotplug = 1;

    bus->hotplug = hotplug;

    bus->hotplug_qdev = qdev;

}

PCIBus *pci_register_bus(DeviceState *parent, const char *name,

                         pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,

                         void *irq_opaque,

                         MemoryRegion *address_space_mem,

                         MemoryRegion *address_space_io,

                         uint8_t devfn_min, int nirq)

{

    PCIBus *bus;

    bus = pci_bus_new(parent, name, address_space_mem,

                      address_space_io, devfn_min);

    pci_bus_irqs(bus, set_irq, map_irq, irq_opaque, nirq);

    return bus;

}

int pci_bus_num(PCIBus *s)

{

    if (!s->parent_dev)

        return 0;       /* pci host bridge */

    return s->parent_dev->config[PCI_SECONDARY_BUS];

}

static int get_pci_config_device(QEMUFile *f, void *pv, size_t size)

{

    PCIDevice *s = container_of(pv, PCIDevice, config);

    uint8_t *config;

    int i;

    assert(size == pci_config_size(s));

    config = g_malloc(size);

    qemu_get_buffer(f, config, size);

    for (i = 0; i < size; ++i) {

        if ((config[i] ^ s->config[i]) &

            s->cmask[i] & ~s->wmask[i] & ~s->w1cmask[i]) {

            g_free(config);

            return -EINVAL;

        }

    }

    memcpy(s->config, config, size);

    pci_update_mappings(s);

    g_free(config);

    return 0;

}

/* just put buffer */

static void put_pci_config_device(QEMUFile *f, void *pv, size_t size)

{

    const uint8_t **v = pv;

    assert(size == pci_config_size(container_of(pv, PCIDevice, config)));

    qemu_put_buffer(f, *v, size);

}

static VMStateInfo vmstate_info_pci_config = {

    .name = "pci config",

    .get  = get_pci_config_device,

    .put  = put_pci_config_device,

};

static int get_pci_irq_state(QEMUFile *f, void *pv, size_t size)

{

    PCIDevice *s = container_of(pv, PCIDevice, irq_state);

    uint32_t irq_state[PCI_NUM_PINS];

    int i;

    for (i = 0; i < PCI_NUM_PINS; ++i) {

        irq_state[i] = qemu_get_be32(f);

        if (irq_state[i] != 0x1 && irq_state[i] != 0) {

            fprintf(stderr, "irq state %d: must be 0 or 1.\n",

                    irq_state[i]);

            return -EINVAL;

        }

    }

    for (i = 0; i < PCI_NUM_PINS; ++i) {

        pci_set_irq_state(s, i, irq_state[i]);

    }

    return 0;

}

static void put_pci_irq_state(QEMUFile *f, void *pv, size_t size)

{

    int i;

    PCIDevice *s = container_of(pv, PCIDevice, irq_state);

    for (i = 0; i < PCI_NUM_PINS; ++i) {

        qemu_put_be32(f, pci_irq_state(s, i));

    }

}

static VMStateInfo vmstate_info_pci_irq_state = {

    .name = "pci irq state",

    .get  = get_pci_irq_state,

    .put  = put_pci_irq_state,

};

const VMStateDescription vmstate_pci_device = {

    .name = "PCIDevice",

    .version_id = 2,

    .minimum_version_id = 1,

    .minimum_version_id_old = 1,

    .fields      = (VMStateField []) {

        VMSTATE_INT32_LE(version_id, PCIDevice),

        VMSTATE_BUFFER_UNSAFE_INFO(config, PCIDevice, 0,

                                   vmstate_info_pci_config,

                                   PCI_CONFIG_SPACE_SIZE),

        VMSTATE_BUFFER_UNSAFE_INFO(irq_state, PCIDevice, 2,

                                   vmstate_info_pci_irq_state,

                                   PCI_NUM_PINS * sizeof(int32_t)),

        VMSTATE_END_OF_LIST()

    }

};

const VMStateDescription vmstate_pcie_device = {

    .name = "PCIDevice",

    .version_id = 2,

    .minimum_version_id = 1,

    .minimum_version_id_old = 1,

    .fields      = (VMStateField []) {

        VMSTATE_INT32_LE(version_id, PCIDevice),

        VMSTATE_BUFFER_UNSAFE_INFO(config, PCIDevice, 0,

                                   vmstate_info_pci_config,

                                   PCIE_CONFIG_SPACE_SIZE),

        VMSTATE_BUFFER_UNSAFE_INFO(irq_state, PCIDevice, 2,

                                   vmstate_info_pci_irq_state,

                                   PCI_NUM_PINS * sizeof(int32_t)),

        VMSTATE_END_OF_LIST()

    }

};

static inline const VMStateDescription *pci_get_vmstate(PCIDevice *s)

{

    return pci_is_express(s) ? &vmstate_pcie_device : &vmstate_pci_device;

}

void pci_device_save(PCIDevice *s, QEMUFile *f)

{

    /* Clear interrupt status bit: it is implicit

     * in irq_state which we are saving.

     * This makes us compatible with old devices

     * which never set or clear this bit. */

    s->config[PCI_STATUS] &= ~PCI_STATUS_INTERRUPT;

    vmstate_save_state(f, pci_get_vmstate(s), s);

    /* Restore the interrupt status bit. */

    pci_update_irq_status(s);

}

int pci_device_load(PCIDevice *s, QEMUFile *f)

{

    int ret;

    ret = vmstate_load_state(f, pci_get_vmstate(s), s, s->version_id);

    /* Restore the interrupt status bit. */

    pci_update_irq_status(s);

    return ret;

}

static void pci_set_default_subsystem_id(PCIDevice *pci_dev)

{

    pci_set_word(pci_dev->config + PCI_SUBSYSTEM_VENDOR_ID,

                 pci_default_sub_vendor_id);

    pci_set_word(pci_dev->config + PCI_SUBSYSTEM_ID,

                 pci_default_sub_device_id);

}

/*

 * Parse [[<domain>:]<bus>:]<slot>, return -1 on error if funcp == NULL

 *       [[<domain>:]<bus>:]<slot>.<func>, return -1 on error

 */

static int pci_parse_devaddr(const char *addr, int *domp, int *busp,

                      unsigned int *slotp, unsigned int *funcp)

{

    const char *p;

    char *e;

    unsigned long val;

    unsigned long dom = 0, bus = 0;

    unsigned int slot = 0;

    unsigned int func = 0;

    p = addr;

    val = strtoul(p, &e, 16);

    if (e == p)

        return -1;

    if (*e == ':') {

        bus = val;

        p = e + 1;

        val = strtoul(p, &e, 16);

        if (e == p)

            return -1;

        if (*e == ':') {

            dom = bus;

            bus = val;

            p = e + 1;

            val = strtoul(p, &e, 16);

            if (e == p)

                return -1;

        }

    }

    slot = val;

    if (funcp != NULL) {

        if (*e != '.')

            return -1;

        p = e + 1;

        val = strtoul(p, &e, 16);

        if (e == p)

            return -1;

        func = val;

    }

    /* if funcp == NULL func is 0 */

    if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7)

        return -1;

    if (*e)

        return -1;

    *domp = dom;

    *busp = bus;

    *slotp = slot;

    if (funcp != NULL)

        *funcp = func;

    return 0;

}

int pci_read_devaddr(Monitor *mon, const char *addr, int *domp, int *busp,

                     unsigned *slotp)

{

    /* strip legacy tag */

    if (!strncmp(addr, "pci_addr=", 9)) {

        addr += 9;

    }

    if (pci_parse_devaddr(addr, domp, busp, slotp, NULL)) {

        monitor_printf(mon, "Invalid pci address\n");

        return -1;

    }

    return 0;

}

PCIBus *pci_get_bus_devfn(int *devfnp, const char *devaddr)

{

    int dom, bus;

    unsigned slot;

    if (!devaddr) {

        *devfnp = -1;

        return pci_find_bus_nr(pci_find_root_bus(0), 0);

    }

    if (pci_parse_devaddr(devaddr, &dom, &bus, &slot, NULL) < 0) {

        return NULL;

    }

    *devfnp = PCI_DEVFN(slot, 0);

    return pci_find_bus_nr(pci_find_root_bus(dom), bus);

}

static void pci_init_cmask(PCIDevice *dev)

{

    pci_set_word(dev->cmask + PCI_VENDOR_ID, 0xffff);

    pci_set_word(dev->cmask + PCI_DEVICE_ID, 0xffff);

    dev->cmask[PCI_STATUS] = PCI_STATUS_CAP_LIST;

    dev->cmask[PCI_REVISION_ID] = 0xff;

    dev->cmask[PCI_CLASS_PROG] = 0xff;

    pci_set_word(dev->cmask + PCI_CLASS_DEVICE, 0xffff);

    dev->cmask[PCI_HEADER_TYPE] = 0xff;

    dev->cmask[PCI_CAPABILITY_LIST] = 0xff;

}

static void pci_init_wmask(PCIDevice *dev)

{

    int config_size = pci_config_size(dev);

    dev->wmask[PCI_CACHE_LINE_SIZE] = 0xff;

    dev->wmask[PCI_INTERRUPT_LINE] = 0xff;

    pci_set_word(dev->wmask + PCI_COMMAND,

                 PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |

                 PCI_COMMAND_INTX_DISABLE);

    if (dev->cap_present & QEMU_PCI_CAP_SERR) {

        pci_word_test_and_set_mask(dev->wmask + PCI_COMMAND, PCI_COMMAND_SERR);

    }

    memset(dev->wmask + PCI_CONFIG_HEADER_SIZE, 0xff,

           config_size - PCI_CONFIG_HEADER_SIZE);

}

static void pci_init_w1cmask(PCIDevice *dev)

{

    /*

     * Note: It's okay to set w1cmask even for readonly bits as

     * long as their value is hardwired to 0.

     */

    pci_set_word(dev->w1cmask + PCI_STATUS,

                 PCI_STATUS_PARITY | PCI_STATUS_SIG_TARGET_ABORT |

                 PCI_STATUS_REC_TARGET_ABORT | PCI_STATUS_REC_MASTER_ABORT |

                 PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_DETECTED_PARITY);

}

static void pci_init_mask_bridge(PCIDevice *d)

{

    /* PCI_PRIMARY_BUS, PCI_SECONDARY_BUS, PCI_SUBORDINATE_BUS and

       PCI_SEC_LETENCY_TIMER */

    memset(d->wmask + PCI_PRIMARY_BUS, 0xff, 4);

    /* base and limit */

    d->wmask[PCI_IO_BASE] = PCI_IO_RANGE_MASK & 0xff;

    d->wmask[PCI_IO_LIMIT] = PCI_IO_RANGE_MASK & 0xff;

    pci_set_word(d->wmask + PCI_MEMORY_BASE,

                 PCI_MEMORY_RANGE_MASK & 0xffff);

    pci_set_word(d->wmask + PCI_MEMORY_LIMIT,

                 PCI_MEMORY_RANGE_MASK & 0xffff);

    pci_set_word(d->wmask + PCI_PREF_MEMORY_BASE,

                 PCI_PREF_RANGE_MASK & 0xffff);

    pci_set_word(d->wmask + PCI_PREF_MEMORY_LIMIT,

                 PCI_PREF_RANGE_MASK & 0xffff);

    /* PCI_PREF_BASE_UPPER32 and PCI_PREF_LIMIT_UPPER32 */

    memset(d->wmask + PCI_PREF_BASE_UPPER32, 0xff, 8);

    /* Supported memory and i/o types */

    d->config[PCI_IO_BASE] |= PCI_IO_RANGE_TYPE_16;

    d->config[PCI_IO_LIMIT] |= PCI_IO_RANGE_TYPE_16;

    pci_word_test_and_set_mask(d->config + PCI_PREF_MEMORY_BASE,

                               PCI_PREF_RANGE_TYPE_64);

    pci_word_test_and_set_mask(d->config + PCI_PREF_MEMORY_LIMIT,

                               PCI_PREF_RANGE_TYPE_64);

/* TODO: add this define to pci_regs.h in linux and then in qemu. */

#define  PCI_BRIDGE_CTL_VGA_16BIT        0x10        /* VGA 16-bit decode */

#define  PCI_BRIDGE_CTL_DISCARD                0x100        /* Primary discard timer */

#define  PCI_BRIDGE_CTL_SEC_DISCARD        0x200        /* Secondary discard timer */

#define  PCI_BRIDGE_CTL_DISCARD_STATUS        0x400        /* Discard timer status */

#define  PCI_BRIDGE_CTL_DISCARD_SERR        0x800        /* Discard timer SERR# enable */

    pci_set_word(d->wmask + PCI_BRIDGE_CONTROL,

                 PCI_BRIDGE_CTL_PARITY |

                 PCI_BRIDGE_CTL_SERR |

                 PCI_BRIDGE_CTL_ISA |

                 PCI_BRIDGE_CTL_VGA |

                 PCI_BRIDGE_CTL_VGA_16BIT |

                 PCI_BRIDGE_CTL_MASTER_ABORT |

                 PCI_BRIDGE_CTL_BUS_RESET |

                 PCI_BRIDGE_CTL_FAST_BACK |

                 PCI_BRIDGE_CTL_DISCARD |

                 PCI_BRIDGE_CTL_SEC_DISCARD |

                 PCI_BRIDGE_CTL_DISCARD_SERR);

    /* Below does not do anything as we never set this bit, put here for

     * completeness. */

    pci_set_word(d->w1cmask + PCI_BRIDGE_CONTROL,

                 PCI_BRIDGE_CTL_DISCARD_STATUS);

    d->cmask[PCI_IO_BASE] |= PCI_IO_RANGE_TYPE_MASK;

    d->cmask[PCI_IO_LIMIT] |= PCI_IO_RANGE_TYPE_MASK;

    pci_word_test_and_set_mask(d->cmask + PCI_PREF_MEMORY_BASE,

                               PCI_PREF_RANGE_TYPE_MASK);

    pci_word_test_and_set_mask(d->cmask + PCI_PREF_MEMORY_LIMIT,

                               PCI_PREF_RANGE_TYPE_MASK);

}

static int pci_init_multifunction(PCIBus *bus, PCIDevice *dev)

{

    uint8_t slot = PCI_SLOT(dev->devfn);

    uint8_t func;

    if (dev->cap_present & QEMU_PCI_CAP_MULTIFUNCTION) {

        dev->config[PCI_HEADER_TYPE] |= PCI_HEADER_TYPE_MULTI_FUNCTION;

    }

    /*

     * multifunction bit is interpreted in two ways as follows.

     *   - all functions must set the bit to 1.

     *     Example: Intel X53

     *   - function 0 must set the bit, but the rest function (> 0)

     *     is allowed to leave the bit to 0.

     *     Example: PIIX3(also in qemu), PIIX4(also in qemu), ICH10,

     *

     * So OS (at least Linux) checks the bit of only function 0,

     * and doesn't see the bit of function > 0.

     *

     * The below check allows both interpretation.

     */

    if (PCI_FUNC(dev->devfn)) {

        PCIDevice *f0 = bus->devices[PCI_DEVFN(slot, 0)];

        if (f0 && !(f0->cap_present & QEMU_PCI_CAP_MULTIFUNCTION)) {

            /* function 0 should set multifunction bit */

            error_report("PCI: single function device can't be populated "

                         "in function %x.%x", slot, PCI_FUNC(dev->devfn));

            return -1;

        }

        return 0;

    }

    if (dev->cap_present & QEMU_PCI_CAP_MULTIFUNCTION) {

        return 0;

    }

    /* function 0 indicates single function, so function > 0 must be NULL */

    for (func = 1; func < PCI_FUNC_MAX; ++func) {

        if (bus->devices[PCI_DEVFN(slot, func)]) {

            error_report("PCI: %x.0 indicates single function, "

                         "but %x.%x is already populated.",

                         slot, slot, func);

            return -1;

        }

    }

    return 0;

}

static void pci_config_alloc(PCIDevice *pci_dev)

{

    int config_size = pci_config_size(pci_dev);

    pci_dev->config = g_malloc0(config_size);

    pci_dev->cmask = g_malloc0(config_size);

    pci_dev->wmask = g_malloc0(config_size);

    pci_dev->w1cmask = g_malloc0(config_size);

    pci_dev->used = g_malloc0(config_size);

}

static void pci_config_free(PCIDevice *pci_dev)

{

    g_free(pci_dev->config);

    g_free(pci_dev->cmask);

    g_free(pci_dev->wmask);

    g_free(pci_dev->w1cmask);

    g_free(pci_dev->used);

}

/* -1 for devfn means auto assign */

static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,

                                         const char *name, int devfn)

{

    PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);

    PCIConfigReadFunc *config_read = pc->config_read;

    PCIConfigWriteFunc *config_write = pc->config_write;

    if (devfn < 0) {

        for(devfn = bus->devfn_min ; devfn < ARRAY_SIZE(bus->devices);

            devfn += PCI_FUNC_MAX) {

            if (!bus->devices[devfn])

                goto found;

        }

        error_report("PCI: no slot/function available for %s, all in use", name);

        return NULL;

    found: ;

    } else if (bus->devices[devfn]) {

        error_report("PCI: slot %d function %d not available for %s, in use by %s",

                     PCI_SLOT(devfn), PCI_FUNC(devfn), name, bus->devices[devfn]->name);

        return NULL;

    }

    pci_dev->bus = bus;

    pci_dev->devfn = devfn;

    pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);

    pci_dev->irq_state = 0;

    pci_config_alloc(pci_dev);

    pci_config_set_vendor_id(pci_dev->config, pc->vendor_id);

    pci_config_set_device_id(pci_dev->config, pc->device_id);

    pci_config_set_revision(pci_dev->config, pc->revision);

    pci_config_set_class(pci_dev->config, pc->class_id);

    if (!pc->is_bridge) {

        if (pc->subsystem_vendor_id || pc->subsystem_id) {

            pci_set_word(pci_dev->config + PCI_SUBSYSTEM_VENDOR_ID,

                         pc->subsystem_vendor_id);

            pci_set_word(pci_dev->config + PCI_SUBSYSTEM_ID,

                         pc->subsystem_id);

        } else {

            pci_set_default_subsystem_id(pci_dev);

        }

    } else {

        /* subsystem_vendor_id/subsystem_id are only for header type 0 */

        assert(!pc->subsystem_vendor_id);

        assert(!pc->subsystem_id);

    }

    pci_init_cmask(pci_dev);

    pci_init_wmask(pci_dev);

    pci_init_w1cmask(pci_dev);

    if (pc->is_bridge) {

        pci_init_mask_bridge(pci_dev);

    }

    if (pci_init_multifunction(bus, pci_dev)) {

        pci_config_free(pci_dev);

        return NULL;

    }

    if (!config_read)

        config_read = pci_default_read_config;

    if (!config_write)

        config_write = pci_default_write_config;

    pci_dev->config_read = config_read;

    pci_dev->config_write = config_write;

    bus->devices[devfn] = pci_dev;

    pci_dev->irq = qemu_allocate_irqs(pci_set_irq, pci_dev, PCI_NUM_PINS);

    pci_dev->version_id = 2; /* Current pci device vmstate version */

    return pci_dev;

}

static void do_pci_unregister_device(PCIDevice *pci_dev)

{

    qemu_free_irqs(pci_dev->irq);

    pci_dev->bus->devices[pci_dev->devfn] = NULL;

    pci_config_free(pci_dev);

}

static void pci_unregister_io_regions(PCIDevice *pci_dev)

{

    PCIIORegion *r;

    int i;

    for(i = 0; i < PCI_NUM_REGIONS; i++) {

        r = &pci_dev->io_regions[i];

        if (!r->size || r->addr == PCI_BAR_UNMAPPED)

            continue;

        memory_region_del_subregion(r->address_space, r->memory);

    }

}

static int pci_unregister_device(DeviceState *dev)

{

    PCIDevice *pci_dev = PCI_DEVICE(dev);

    PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);

    int ret = 0;

    if (pc->exit)

        ret = pc->exit(pci_dev);

    if (ret)

        return ret;

    pci_unregister_io_regions(pci_dev);

    pci_del_option_rom(pci_dev);

    do_pci_unregister_device(pci_dev);

    return 0;

}

void pci_register_bar(PCIDevice *pci_dev, int region_num,

                      uint8_t type, MemoryRegion *memory)

{

    PCIIORegion *r;

    uint32_t addr;

    uint64_t wmask;

    pcibus_t size = memory_region_size(memory);

    assert(region_num >= 0);

    assert(region_num < PCI_NUM_REGIONS);

    if (size & (size-1)) {

        fprintf(stderr, "ERROR: PCI region size must be pow2 "

                    "type=0x%x, size=0x%"FMT_PCIBUS"\n", type, size);

        exit(1);

    }

    r = &pci_dev->io_regions[region_num];

    r->addr = PCI_BAR_UNMAPPED;

    r->size = size;

    r->type = type;

    r->memory = NULL;

    wmask = ~(size - 1);

    addr = pci_bar(pci_dev, region_num);

    if (region_num == PCI_ROM_SLOT) {

        /* ROM enable bit is writable */

        wmask |= PCI_ROM_ADDRESS_ENABLE;

    }

    pci_set_long(pci_dev->config + addr, type);

    if (!(r->type & PCI_BASE_ADDRESS_SPACE_IO) &&

        r->type & PCI_BASE_ADDRESS_MEM_TYPE_64) {

        pci_set_quad(pci_dev->wmask + addr, wmask);

        pci_set_quad(pci_dev->cmask + addr, ~0ULL);

    } else {

        pci_set_long(pci_dev->wmask + addr, wmask & 0xffffffff);

        pci_set_long(pci_dev->cmask + addr, 0xffffffff);

    }

    pci_dev->io_regions[region_num].memory = memory;

    pci_dev->io_regions[region_num].address_space

        = type & PCI_BASE_ADDRESS_SPACE_IO

        ? pci_dev->bus->address_space_io

        : pci_dev->bus->address_space_mem;

}

pcibus_t pci_get_bar_addr(PCIDevice *pci_dev, int region_num)

{

    return pci_dev->io_regions[region_num].addr;

}

static pcibus_t pci_bar_address(PCIDevice *d,

                                int reg, uint8_t type, pcibus_t size)

{

    pcibus_t new_addr, last_addr;

    int bar = pci_bar(d, reg);

    uint16_t cmd = pci_get_word(d->config + PCI_COMMAND);

    if (type & PCI_BASE_ADDRESS_SPACE_IO) {

        if (!(cmd & PCI_COMMAND_IO)) {

            return PCI_BAR_UNMAPPED;

        }

        new_addr = pci_get_long(d->config + bar) & ~(size - 1);