pci.h 13.1 KB
Newer Older
P
pbrook 已提交
1 2 3
#ifndef QEMU_PCI_H
#define QEMU_PCI_H

A
aliguori 已提交
4
#include "qemu-common.h"
5
#include "qobject.h"
A
aliguori 已提交
6

P
Paul Brook 已提交
7 8
#include "qdev.h"

P
pbrook 已提交
9 10 11
/* PCI includes legacy ISA access.  */
#include "isa.h"

12 13
#include "pcie.h"

P
pbrook 已提交
14 15
/* PCI bus */

16 17 18
#define PCI_DEVFN(slot, func)   ((((slot) & 0x1f) << 3) | ((func) & 0x07))
#define PCI_SLOT(devfn)         (((devfn) >> 3) & 0x1f)
#define PCI_FUNC(devfn)         ((devfn) & 0x07)
19
#define PCI_FUNC_MAX            8
20

21 22
/* Class, Vendor and Device IDs from Linux's pci_ids.h */
#include "pci_ids.h"
23

24
/* QEMU-specific Vendor and Device ID definitions */
25

26 27
/* IBM (0x1014) */
#define PCI_DEVICE_ID_IBM_440GX          0x027f
28
#define PCI_DEVICE_ID_IBM_OPENPIC2       0xffff
29

30
/* Hitachi (0x1054) */
31
#define PCI_VENDOR_ID_HITACHI            0x1054
32
#define PCI_DEVICE_ID_HITACHI_SH7751R    0x350e
33

34
/* Apple (0x106b) */
35 36 37 38
#define PCI_DEVICE_ID_APPLE_343S1201     0x0010
#define PCI_DEVICE_ID_APPLE_UNI_N_I_PCI  0x001e
#define PCI_DEVICE_ID_APPLE_UNI_N_PCI    0x001f
#define PCI_DEVICE_ID_APPLE_UNI_N_KEYL   0x0022
39
#define PCI_DEVICE_ID_APPLE_IPID_USB     0x003f
40

41 42
/* Realtek (0x10ec) */
#define PCI_DEVICE_ID_REALTEK_8029       0x8029
43

44 45
/* Xilinx (0x10ee) */
#define PCI_DEVICE_ID_XILINX_XC2VP30     0x0300
46

47 48
/* Marvell (0x11ab) */
#define PCI_DEVICE_ID_MARVELL_GT6412X    0x4620
49

50
/* QEMU/Bochs VGA (0x1234) */
51 52 53
#define PCI_VENDOR_ID_QEMU               0x1234
#define PCI_DEVICE_ID_QEMU_VGA           0x1111

54
/* VMWare (0x15ad) */
55 56 57 58 59 60 61
#define PCI_VENDOR_ID_VMWARE             0x15ad
#define PCI_DEVICE_ID_VMWARE_SVGA2       0x0405
#define PCI_DEVICE_ID_VMWARE_SVGA        0x0710
#define PCI_DEVICE_ID_VMWARE_NET         0x0720
#define PCI_DEVICE_ID_VMWARE_SCSI        0x0730
#define PCI_DEVICE_ID_VMWARE_IDE         0x1729

A
aliguori 已提交
62
/* Intel (0x8086) */
63
#define PCI_DEVICE_ID_INTEL_82551IT      0x1209
64
#define PCI_DEVICE_ID_INTEL_82557        0x1229
65

66
/* Red Hat / Qumranet (for QEMU) -- see pci-ids.txt */
67 68 69 70 71 72 73
#define PCI_VENDOR_ID_REDHAT_QUMRANET    0x1af4
#define PCI_SUBVENDOR_ID_REDHAT_QUMRANET 0x1af4
#define PCI_SUBDEVICE_ID_QEMU            0x1100

#define PCI_DEVICE_ID_VIRTIO_NET         0x1000
#define PCI_DEVICE_ID_VIRTIO_BLOCK       0x1001
#define PCI_DEVICE_ID_VIRTIO_BALLOON     0x1002
74
#define PCI_DEVICE_ID_VIRTIO_CONSOLE     0x1003
75

76
#define FMT_PCIBUS                      PRIx64
77

P
pbrook 已提交
78 79 80 81 82
typedef void PCIConfigWriteFunc(PCIDevice *pci_dev,
                                uint32_t address, uint32_t data, int len);
typedef uint32_t PCIConfigReadFunc(PCIDevice *pci_dev,
                                   uint32_t address, int len);
typedef void PCIMapIORegionFunc(PCIDevice *pci_dev, int region_num,
83
                                pcibus_t addr, pcibus_t size, int type);
84
typedef int PCIUnregisterFunc(PCIDevice *pci_dev);
P
pbrook 已提交
85 86

typedef struct PCIIORegion {
87 88 89
    pcibus_t addr; /* current PCI mapping address. -1 means not mapped */
#define PCI_BAR_UNMAPPED (~(pcibus_t)0)
    pcibus_t size;
90
    pcibus_t filtered_size;
P
pbrook 已提交
91 92 93 94 95 96 97
    uint8_t type;
    PCIMapIORegionFunc *map_func;
} PCIIORegion;

#define PCI_ROM_SLOT 6
#define PCI_NUM_REGIONS 7

I
Isaku Yamahata 已提交
98 99 100
#include "pci_regs.h"

/* PCI HEADER_TYPE */
I
Isaku Yamahata 已提交
101
#define  PCI_HEADER_TYPE_MULTI_FUNCTION 0x80
102

103 104 105 106
/* Size of the standard PCI config header */
#define PCI_CONFIG_HEADER_SIZE 0x40
/* Size of the standard PCI config space */
#define PCI_CONFIG_SPACE_SIZE 0x100
I
Isaku Yamahata 已提交
107 108
/* Size of the standart PCIe config space: 4KB */
#define PCIE_CONFIG_SPACE_SIZE  0x1000
109

110 111
#define PCI_NUM_PINS 4 /* A-D */

112 113
/* Bits in cap_present field. */
enum {
I
Isaku Yamahata 已提交
114 115 116
    QEMU_PCI_CAP_MSI = 0x1,
    QEMU_PCI_CAP_MSIX = 0x2,
    QEMU_PCI_CAP_EXPRESS = 0x4,
117 118

    /* multifunction capable device */
I
Isaku Yamahata 已提交
119
#define QEMU_PCI_CAP_MULTIFUNCTION_BITNR        3
120
    QEMU_PCI_CAP_MULTIFUNCTION = (1 << QEMU_PCI_CAP_MULTIFUNCTION_BITNR),
121 122
};

P
pbrook 已提交
123
struct PCIDevice {
P
Paul Brook 已提交
124
    DeviceState qdev;
P
pbrook 已提交
125
    /* PCI config space */
I
Isaku Yamahata 已提交
126
    uint8_t *config;
127

128 129
    /* Used to enable config checks on load. Note that writeable bits are
     * never checked even if set in cmask. */
I
Isaku Yamahata 已提交
130
    uint8_t *cmask;
131

132
    /* Used to implement R/W bytes */
I
Isaku Yamahata 已提交
133
    uint8_t *wmask;
P
pbrook 已提交
134

135 136 137
    /* Used to implement RW1C(Write 1 to Clear) bytes */
    uint8_t *w1cmask;

138
    /* Used to allocate config space for capabilities. */
I
Isaku Yamahata 已提交
139
    uint8_t *used;
140

P
pbrook 已提交
141 142
    /* the following fields are read only */
    PCIBus *bus;
143
    uint32_t devfn;
P
pbrook 已提交
144 145 146 147 148 149 150 151 152 153 154
    char name[64];
    PCIIORegion io_regions[PCI_NUM_REGIONS];

    /* do not access the following fields */
    PCIConfigReadFunc *config_read;
    PCIConfigWriteFunc *config_write;

    /* IRQ objects for the INTA-INTD pins.  */
    qemu_irq *irq;

    /* Current IRQ levels.  Used internally by the generic PCI code.  */
155
    uint8_t irq_state;
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173

    /* Capability bits */
    uint32_t cap_present;

    /* Offset of MSI-X capability in config space */
    uint8_t msix_cap;

    /* MSI-X entries */
    int msix_entries_nr;

    /* Space to store MSIX table */
    uint8_t *msix_table_page;
    /* MMIO index used to map MSIX table and pending bit entries. */
    int msix_mmio_index;
    /* Reference-count for entries actually in use by driver. */
    unsigned *msix_entry_used;
    /* Region including the MSI-X table */
    uint32_t msix_bar_size;
J
Juan Quintela 已提交
174 175
    /* Version id needed for VMState */
    int32_t version_id;
176

I
Isaku Yamahata 已提交
177 178 179
    /* Offset of MSI capability in config space */
    uint8_t msi_cap;

180 181 182
    /* PCI Express */
    PCIExpressDevice exp;

183
    /* Location of option rom */
184
    char *romfile;
185
    ram_addr_t rom_offset;
186
    uint32_t rom_bar;
P
pbrook 已提交
187 188 189 190 191 192 193
};

PCIDevice *pci_register_device(PCIBus *bus, const char *name,
                               int instance_size, int devfn,
                               PCIConfigReadFunc *config_read,
                               PCIConfigWriteFunc *config_write);

194
void pci_register_bar(PCIDevice *pci_dev, int region_num,
195
                            pcibus_t size, uint8_t type,
P
pbrook 已提交
196 197
                            PCIMapIORegionFunc *map_func);

198 199
int pci_add_capability(PCIDevice *pdev, uint8_t cap_id,
                       uint8_t offset, uint8_t size);
200 201 202 203 204 205 206 207

void pci_del_capability(PCIDevice *pci_dev, uint8_t cap_id, uint8_t cap_size);

void pci_reserve_capability(PCIDevice *pci_dev, uint8_t offset, uint8_t size);

uint8_t pci_find_capability(PCIDevice *pci_dev, uint8_t cap_id);


P
pbrook 已提交
208 209 210 211 212 213 214
uint32_t pci_default_read_config(PCIDevice *d,
                                 uint32_t address, int len);
void pci_default_write_config(PCIDevice *d,
                              uint32_t address, uint32_t val, int len);
void pci_device_save(PCIDevice *s, QEMUFile *f);
int pci_device_load(PCIDevice *s, QEMUFile *f);

215
typedef void (*pci_set_irq_fn)(void *opaque, int irq_num, int level);
P
pbrook 已提交
216
typedef int (*pci_map_irq_fn)(PCIDevice *pci_dev, int irq_num);
217 218 219 220 221 222 223 224 225

typedef enum {
    PCI_HOTPLUG_DISABLED,
    PCI_HOTPLUG_ENABLED,
    PCI_COLDPLUG_ENABLED,
} PCIHotplugState;

typedef int (*pci_hotplug_fn)(DeviceState *qdev, PCIDevice *pci_dev,
                              PCIHotplugState state);
226 227 228 229 230
void pci_bus_new_inplace(PCIBus *bus, DeviceState *parent,
                         const char *name, int devfn_min);
PCIBus *pci_bus_new(DeviceState *parent, const char *name, int devfn_min);
void pci_bus_irqs(PCIBus *bus, pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,
                  void *irq_opaque, int nirq);
231
void pci_bus_hotplug(PCIBus *bus, pci_hotplug_fn hotplug, DeviceState *dev);
P
Paul Brook 已提交
232 233
PCIBus *pci_register_bus(DeviceState *parent, const char *name,
                         pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,
234
                         void *irq_opaque, int devfn_min, int nirq);
P
pbrook 已提交
235

B
Blue Swirl 已提交
236 237
void pci_bus_set_mem_base(PCIBus *bus, target_phys_addr_t base);

238 239
PCIDevice *pci_nic_init(NICInfo *nd, const char *default_model,
                        const char *default_devaddr);
240 241
PCIDevice *pci_nic_init_nofail(NICInfo *nd, const char *default_model,
                               const char *default_devaddr);
P
pbrook 已提交
242
int pci_bus_num(PCIBus *s);
243
void pci_for_each_device(PCIBus *bus, int bus_num, void (*fn)(PCIBus *bus, PCIDevice *d));
244
PCIBus *pci_find_root_bus(int domain);
245
int pci_find_domain(const PCIBus *bus);
246 247
PCIBus *pci_find_bus(PCIBus *bus, int bus_num);
PCIDevice *pci_find_device(PCIBus *bus, int bus_num, int slot, int function);
248
PCIBus *pci_get_bus_devfn(int *devfnp, const char *devaddr);
P
pbrook 已提交
249

250 251
int pci_parse_devaddr(const char *addr, int *domp, int *busp,
                      unsigned int *slotp, unsigned int *funcp);
252 253
int pci_read_devaddr(Monitor *mon, const char *addr, int *domp, int *busp,
                     unsigned *slotp);
254

255 256
void do_pci_info_print(Monitor *mon, const QObject *data);
void do_pci_info(Monitor *mon, QObject **ret_data);
257
void pci_bridge_update_mappings(PCIBus *b);
P
pbrook 已提交
258

259 260
bool pci_msi_enabled(PCIDevice *dev);
void pci_msi_notify(PCIDevice *dev, unsigned int vector);
P
pbrook 已提交
261

262 263 264 265 266 267 268
static inline void
pci_set_byte(uint8_t *config, uint8_t val)
{
    *config = val;
}

static inline uint8_t
269
pci_get_byte(const uint8_t *config)
270 271 272 273
{
    return *config;
}

274 275 276 277 278 279 280
static inline void
pci_set_word(uint8_t *config, uint16_t val)
{
    cpu_to_le16wu((uint16_t *)config, val);
}

static inline uint16_t
281
pci_get_word(const uint8_t *config)
282
{
283
    return le16_to_cpupu((const uint16_t *)config);
284 285 286 287 288 289 290 291 292
}

static inline void
pci_set_long(uint8_t *config, uint32_t val)
{
    cpu_to_le32wu((uint32_t *)config, val);
}

static inline uint32_t
293
pci_get_long(const uint8_t *config)
294
{
295
    return le32_to_cpupu((const uint32_t *)config);
296 297
}

298 299 300 301 302 303 304
static inline void
pci_set_quad(uint8_t *config, uint64_t val)
{
    cpu_to_le64w((uint64_t *)config, val);
}

static inline uint64_t
305
pci_get_quad(const uint8_t *config)
306
{
307
    return le64_to_cpup((const uint64_t *)config);
308 309
}

310 311 312
static inline void
pci_config_set_vendor_id(uint8_t *pci_config, uint16_t val)
{
313
    pci_set_word(&pci_config[PCI_VENDOR_ID], val);
314 315 316 317 318
}

static inline void
pci_config_set_device_id(uint8_t *pci_config, uint16_t val)
{
319
    pci_set_word(&pci_config[PCI_DEVICE_ID], val);
320 321
}

I
Izik Eidus 已提交
322 323 324 325 326 327
static inline void
pci_config_set_revision(uint8_t *pci_config, uint8_t val)
{
    pci_set_byte(&pci_config[PCI_REVISION_ID], val);
}

328 329 330
static inline void
pci_config_set_class(uint8_t *pci_config, uint16_t val)
{
331
    pci_set_word(&pci_config[PCI_CLASS_DEVICE], val);
332 333
}

I
Izik Eidus 已提交
334 335 336 337 338 339 340 341 342 343 344 345
static inline void
pci_config_set_prog_interface(uint8_t *pci_config, uint8_t val)
{
    pci_set_byte(&pci_config[PCI_CLASS_PROG], val);
}

static inline void
pci_config_set_interrupt_pin(uint8_t *pci_config, uint8_t val)
{
    pci_set_byte(&pci_config[PCI_INTERRUPT_PIN], val);
}

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/*
 * helper functions to do bit mask operation on configuration space.
 * Just to set bit, use test-and-set and discard returned value.
 * Just to clear bit, use test-and-clear and discard returned value.
 * NOTE: They aren't atomic.
 */
static inline uint8_t
pci_byte_test_and_clear_mask(uint8_t *config, uint8_t mask)
{
    uint8_t val = pci_get_byte(config);
    pci_set_byte(config, val & ~mask);
    return val & mask;
}

static inline uint8_t
pci_byte_test_and_set_mask(uint8_t *config, uint8_t mask)
{
    uint8_t val = pci_get_byte(config);
    pci_set_byte(config, val | mask);
    return val & mask;
}

static inline uint16_t
pci_word_test_and_clear_mask(uint8_t *config, uint16_t mask)
{
    uint16_t val = pci_get_word(config);
    pci_set_word(config, val & ~mask);
    return val & mask;
}

static inline uint16_t
pci_word_test_and_set_mask(uint8_t *config, uint16_t mask)
{
    uint16_t val = pci_get_word(config);
    pci_set_word(config, val | mask);
    return val & mask;
}

static inline uint32_t
pci_long_test_and_clear_mask(uint8_t *config, uint32_t mask)
{
    uint32_t val = pci_get_long(config);
    pci_set_long(config, val & ~mask);
    return val & mask;
}

static inline uint32_t
pci_long_test_and_set_mask(uint8_t *config, uint32_t mask)
{
    uint32_t val = pci_get_long(config);
    pci_set_long(config, val | mask);
    return val & mask;
}

static inline uint64_t
pci_quad_test_and_clear_mask(uint8_t *config, uint64_t mask)
{
    uint64_t val = pci_get_quad(config);
    pci_set_quad(config, val & ~mask);
    return val & mask;
}

static inline uint64_t
pci_quad_test_and_set_mask(uint8_t *config, uint64_t mask)
{
    uint64_t val = pci_get_quad(config);
    pci_set_quad(config, val | mask);
    return val & mask;
}

416
typedef int (*pci_qdev_initfn)(PCIDevice *dev);
417 418 419
typedef struct {
    DeviceInfo qdev;
    pci_qdev_initfn init;
420
    PCIUnregisterFunc *exit;
421 422
    PCIConfigReadFunc *config_read;
    PCIConfigWriteFunc *config_write;
I
Isaku Yamahata 已提交
423

424 425 426 427 428 429
    /*
     * pci-to-pci bridge or normal device.
     * This doesn't mean pci host switch.
     * When card bus bridge is supported, this would be enhanced.
     */
    int is_bridge;
430

I
Isaku Yamahata 已提交
431
    /* pcie stuff */
432
    int is_express;   /* is this device pci express? */
433 434 435

    /* rom bar */
    const char *romfile;
436 437 438 439
} PCIDeviceInfo;

void pci_qdev_register(PCIDeviceInfo *info);
void pci_qdev_register_many(PCIDeviceInfo *info);
P
Paul Brook 已提交
440

441 442 443 444 445
PCIDevice *pci_create_multifunction(PCIBus *bus, int devfn, bool multifunction,
                                    const char *name);
PCIDevice *pci_create_simple_multifunction(PCIBus *bus, int devfn,
                                           bool multifunction,
                                           const char *name);
446
PCIDevice *pci_create(PCIBus *bus, int devfn, const char *name);
P
Paul Brook 已提交
447 448
PCIDevice *pci_create_simple(PCIBus *bus, int devfn, const char *name);

449
static inline int pci_is_express(const PCIDevice *d)
I
Isaku Yamahata 已提交
450 451 452 453
{
    return d->cap_present & QEMU_PCI_CAP_EXPRESS;
}

454
static inline uint32_t pci_config_size(const PCIDevice *d)
I
Isaku Yamahata 已提交
455 456 457 458
{
    return pci_is_express(d) ? PCIE_CONFIG_SPACE_SIZE : PCI_CONFIG_SPACE_SIZE;
}

P
pbrook 已提交
459
#endif