pci.c 64 KB
Newer Older
bellard's avatar
bellard committed
1
2
3
4
/*
 * QEMU PCI bus manager
 *
 * Copyright (c) 2004 Fabrice Bellard
5
 *
bellard's avatar
bellard committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 * 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.
 */
pbrook's avatar
pbrook committed
24
25
#include "hw.h"
#include "pci.h"
26
#include "pci_bridge.h"
27
#include "pci_internals.h"
aliguori's avatar
aliguori committed
28
#include "monitor.h"
pbrook's avatar
pbrook committed
29
#include "net.h"
30
#include "sysemu.h"
31
#include "loader.h"
32
#include "qemu-objects.h"
Blue Swirl's avatar
Blue Swirl committed
33
#include "range.h"
bellard's avatar
bellard committed
34
35

//#define DEBUG_PCI
36
#ifdef DEBUG_PCI
37
# define PCI_DPRINTF(format, ...)       printf(format, ## __VA_ARGS__)
38
39
40
#else
# define PCI_DPRINTF(format, ...)       do { } while (0)
#endif
bellard's avatar
bellard committed
41

42
static void pcibus_dev_print(Monitor *mon, DeviceState *dev, int indent);
43
static char *pcibus_get_dev_path(DeviceState *dev);
44
static char *pcibus_get_fw_dev_path(DeviceState *dev);
45
static int pcibus_reset(BusState *qbus);
46

47
struct BusInfo pci_bus_info = {
48
49
50
    .name       = "PCI",
    .size       = sizeof(PCIBus),
    .print_dev  = pcibus_dev_print,
51
    .get_dev_path = pcibus_get_dev_path,
52
    .get_fw_dev_path = pcibus_get_fw_dev_path,
53
    .reset      = pcibus_reset,
54
    .props      = (Property[]) {
55
        DEFINE_PROP_PCI_DEVFN("addr", PCIDevice, devfn, -1),
56
        DEFINE_PROP_STRING("romfile", PCIDevice, romfile),
57
        DEFINE_PROP_UINT32("rombar",  PCIDevice, rom_bar, 1),
58
59
        DEFINE_PROP_BIT("multifunction", PCIDevice, cap_present,
                        QEMU_PCI_CAP_MULTIFUNCTION_BITNR, false),
60
61
        DEFINE_PROP_BIT("command_serr_enable", PCIDevice, cap_present,
                        QEMU_PCI_CAP_SERR_BITNR, true),
62
        DEFINE_PROP_END_OF_LIST()
63
    }
64
};
bellard's avatar
bellard committed
65

bellard's avatar
bellard committed
66
static void pci_update_mappings(PCIDevice *d);
pbrook's avatar
pbrook committed
67
static void pci_set_irq(void *opaque, int irq_num, int level);
68
static int pci_add_option_rom(PCIDevice *pdev, bool is_default_rom);
69
static void pci_del_option_rom(PCIDevice *pdev);
bellard's avatar
bellard committed
70

71
72
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;
73
74
75
76
77
78
79

struct PCIHostBus {
    int domain;
    struct PCIBus *bus;
    QLIST_ENTRY(PCIHostBus) next;
};
static QLIST_HEAD(, PCIHostBus) host_buses;
80

Juan Quintela's avatar
Juan Quintela committed
81
82
83
84
85
86
87
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),
88
        VMSTATE_VARRAY_INT32(irq_count, PCIBus, nirq, 0, vmstate_info_int32, int32_t),
Juan Quintela's avatar
Juan Quintela committed
89
        VMSTATE_END_OF_LIST()
90
    }
Juan Quintela's avatar
Juan Quintela committed
91
};
92

93
static int pci_bar(PCIDevice *d, int reg)
94
{
95
96
97
98
99
100
101
    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;
102
103
}

104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
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);
}

129
130
131
132
133
134
135
136
137
138
139
/* 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;
    }
}

Isaku Yamahata's avatar
Isaku Yamahata committed
140
141
142
143
144
145
146
147
void pci_device_deassert_intx(PCIDevice *dev)
{
    int i;
    for (i = 0; i < PCI_NUM_PINS; ++i) {
        qemu_set_irq(dev->irq[i], 0);
    }
}

Isaku Yamahata's avatar
Isaku Yamahata committed
148
149
150
151
152
/*
 * This function is called on #RST and FLR.
 * FLR if PCI_EXP_DEVCTL_BCR_FLR is set
 */
void pci_device_reset(PCIDevice *dev)
153
{
154
    int r;
155
156
157
158
159
    /* TODO: call the below unconditionally once all pci devices
     * are qdevified */
    if (dev->qdev.info) {
        qdev_reset_all(&dev->qdev);
    }
160

161
    dev->irq_state = 0;
162
    pci_update_irq_status(dev);
Isaku Yamahata's avatar
Isaku Yamahata committed
163
    pci_device_deassert_intx(dev);
Isaku Yamahata's avatar
Isaku Yamahata committed
164
    /* Clear all writeable bits */
165
    pci_word_test_and_clear_mask(dev->config + PCI_COMMAND,
166
167
                                 pci_get_word(dev->wmask + PCI_COMMAND) |
                                 pci_get_word(dev->w1cmask + PCI_COMMAND));
168
169
170
    pci_word_test_and_clear_mask(dev->config + PCI_STATUS,
                                 pci_get_word(dev->wmask + PCI_STATUS) |
                                 pci_get_word(dev->w1cmask + PCI_STATUS));
171
172
173
    dev->config[PCI_CACHE_LINE_SIZE] = 0x0;
    dev->config[PCI_INTERRUPT_LINE] = 0x0;
    for (r = 0; r < PCI_NUM_REGIONS; ++r) {
Isaku Yamahata's avatar
Isaku Yamahata committed
174
175
        PCIIORegion *region = &dev->io_regions[r];
        if (!region->size) {
176
177
            continue;
        }
Isaku Yamahata's avatar
Isaku Yamahata committed
178
179
180
181
182
183
184

        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);
        }
185
186
    }
    pci_update_mappings(dev);
187
188
}

189
190
191
192
193
/*
 * Trigger pci bus reset under a given bus.
 * To be called on RST# assert.
 */
void pci_bus_reset(PCIBus *bus)
Gleb Natapov's avatar
Gleb Natapov committed
194
195
196
197
198
199
{
    int i;

    for (i = 0; i < bus->nirq; i++) {
        bus->irq_count[i] = 0;
    }
200
201
202
203
    for (i = 0; i < ARRAY_SIZE(bus->devices); ++i) {
        if (bus->devices[i]) {
            pci_device_reset(bus->devices[i]);
        }
Gleb Natapov's avatar
Gleb Natapov committed
204
205
206
    }
}

207
208
209
210
211
212
213
214
215
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;
}

216
217
218
219
220
221
222
223
224
static void pci_host_bus_register(int domain, PCIBus *bus)
{
    struct PCIHostBus *host;
    host = qemu_mallocz(sizeof(*host));
    host->domain = domain;
    host->bus = bus;
    QLIST_INSERT_HEAD(&host_buses, host, next);
}

225
PCIBus *pci_find_root_bus(int domain)
226
227
228
229
230
231
232
233
234
235
236
237
{
    struct PCIHostBus *host;

    QLIST_FOREACH(host, &host_buses, next) {
        if (host->domain == domain) {
            return host->bus;
        }
    }

    return NULL;
}

238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
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;
}

258
259
void pci_bus_new_inplace(PCIBus *bus, DeviceState *parent,
                         const char *name, int devfn_min)
260
{
261
    qbus_create_inplace(&bus->qbus, &pci_bus_info, parent, name);
262
    assert(PCI_FUNC(devfn_min) == 0);
pbrook's avatar
pbrook committed
263
    bus->devfn_min = devfn_min;
264
265
266
267
268

    /* host bridge */
    QLIST_INIT(&bus->child);
    pci_host_bus_register(0, bus); /* for now only pci domain 0 is supported */

269
    vmstate_register(NULL, -1, &vmstate_pcibus, bus);
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
}

PCIBus *pci_bus_new(DeviceState *parent, const char *name, int devfn_min)
{
    PCIBus *bus;

    bus = qemu_mallocz(sizeof(*bus));
    bus->qbus.qdev_allocated = 1;
    pci_bus_new_inplace(bus, parent, name, 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 = qemu_mallocz(nirq * sizeof(bus->irq_count[0]));
}

292
void pci_bus_hotplug(PCIBus *bus, pci_hotplug_fn hotplug, DeviceState *qdev)
Gerd Hoffmann's avatar
Gerd Hoffmann committed
293
294
295
{
    bus->qbus.allow_hotplug = 1;
    bus->hotplug = hotplug;
296
    bus->hotplug_qdev = qdev;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
297
298
}

Blue Swirl's avatar
Blue Swirl committed
299
300
301
302
303
void pci_bus_set_mem_base(PCIBus *bus, target_phys_addr_t base)
{
    bus->mem_base = base;
}

304
305
306
307
308
309
310
311
PCIBus *pci_register_bus(DeviceState *parent, const char *name,
                         pci_set_irq_fn set_irq, pci_map_irq_fn map_irq,
                         void *irq_opaque, int devfn_min, int nirq)
{
    PCIBus *bus;

    bus = pci_bus_new(parent, name, devfn_min);
    pci_bus_irqs(bus, set_irq, map_irq, irq_opaque, nirq);
312
313
    return bus;
}
bellard's avatar
bellard committed
314

pbrook's avatar
pbrook committed
315
316
int pci_bus_num(PCIBus *s)
{
317
318
319
    if (!s->parent_dev)
        return 0;       /* pci host bridge */
    return s->parent_dev->config[PCI_SECONDARY_BUS];
pbrook's avatar
pbrook committed
320
321
}

322
static int get_pci_config_device(QEMUFile *f, void *pv, size_t size)
323
{
324
    PCIDevice *s = container_of(pv, PCIDevice, config);
325
    uint8_t *config;
326
327
    int i;

328
329
330
331
332
    assert(size == pci_config_size(s));
    config = qemu_malloc(size);

    qemu_get_buffer(f, config, size);
    for (i = 0; i < size; ++i) {
333
334
        if ((config[i] ^ s->config[i]) &
            s->cmask[i] & ~s->wmask[i] & ~s->w1cmask[i]) {
335
            qemu_free(config);
336
            return -EINVAL;
337
338
339
        }
    }
    memcpy(s->config, config, size);
340

bellard's avatar
bellard committed
341
    pci_update_mappings(s);
342

343
    qemu_free(config);
344
345
346
    return 0;
}

347
/* just put buffer */
348
static void put_pci_config_device(QEMUFile *f, void *pv, size_t size)
349
{
350
    const uint8_t **v = pv;
351
    assert(size == pci_config_size(container_of(pv, PCIDevice, config)));
352
    qemu_put_buffer(f, *v, size);
353
354
355
356
357
358
359
360
}

static VMStateInfo vmstate_info_pci_config = {
    .name = "pci config",
    .get  = get_pci_config_device,
    .put  = put_pci_config_device,
};

361
362
static int get_pci_irq_state(QEMUFile *f, void *pv, size_t size)
{
363
    PCIDevice *s = container_of(pv, PCIDevice, irq_state);
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
    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;
385
    PCIDevice *s = container_of(pv, PCIDevice, irq_state);
386
387
388
389
390
391
392
393
394
395
396
397

    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,
};

398
399
400
401
402
403
404
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),
405
406
407
        VMSTATE_BUFFER_UNSAFE_INFO(config, PCIDevice, 0,
                                   vmstate_info_pci_config,
                                   PCI_CONFIG_SPACE_SIZE),
408
409
410
        VMSTATE_BUFFER_UNSAFE_INFO(irq_state, PCIDevice, 2,
				   vmstate_info_pci_irq_state,
				   PCI_NUM_PINS * sizeof(int32_t)),
411
412
413
414
415
416
417
418
419
420
421
422
423
424
        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),
425
426
427
        VMSTATE_BUFFER_UNSAFE_INFO(irq_state, PCIDevice, 2,
				   vmstate_info_pci_irq_state,
				   PCI_NUM_PINS * sizeof(int32_t)),
428
429
430
431
        VMSTATE_END_OF_LIST()
    }
};

432
433
434
435
436
static inline const VMStateDescription *pci_get_vmstate(PCIDevice *s)
{
    return pci_is_express(s) ? &vmstate_pcie_device : &vmstate_pci_device;
}

437
438
void pci_device_save(PCIDevice *s, QEMUFile *f)
{
439
440
441
442
443
    /* 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;
444
    vmstate_save_state(f, pci_get_vmstate(s), s);
445
446
    /* Restore the interrupt status bit. */
    pci_update_irq_status(s);
447
448
449
450
}

int pci_device_load(PCIDevice *s, QEMUFile *f)
{
451
452
453
454
455
    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;
456
457
}

458
static void pci_set_default_subsystem_id(PCIDevice *pci_dev)
459
{
460
461
462
463
    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);
464
465
}

466
/*
467
468
 * Parse [[<domain>:]<bus>:]<slot>, return -1 on error if funcp == NULL
 *       [[<domain>:]<bus>:]<slot>.<func>, return -1 on error
469
 */
470
471
int pci_parse_devaddr(const char *addr, int *domp, int *busp,
                      unsigned int *slotp, unsigned int *funcp)
472
473
474
475
476
{
    const char *p;
    char *e;
    unsigned long val;
    unsigned long dom = 0, bus = 0;
477
478
    unsigned int slot = 0;
    unsigned int func = 0;
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501

    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;

502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
    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;

518
519
520
521
    if (*e)
	return -1;

    /* Note: QEMU doesn't implement domains other than 0 */
522
    if (!pci_find_bus(pci_find_root_bus(dom), bus))
523
524
525
526
527
	return -1;

    *domp = dom;
    *busp = bus;
    *slotp = slot;
528
529
    if (funcp != NULL)
        *funcp = func;
530
531
532
    return 0;
}

533
534
int pci_read_devaddr(Monitor *mon, const char *addr, int *domp, int *busp,
                     unsigned *slotp)
535
{
536
537
538
539
    /* strip legacy tag */
    if (!strncmp(addr, "pci_addr=", 9)) {
        addr += 9;
    }
540
    if (pci_parse_devaddr(addr, domp, busp, slotp, NULL)) {
541
        monitor_printf(mon, "Invalid pci address\n");
542
        return -1;
543
544
    }
    return 0;
545
546
}

547
PCIBus *pci_get_bus_devfn(int *devfnp, const char *devaddr)
548
549
550
551
552
553
{
    int dom, bus;
    unsigned slot;

    if (!devaddr) {
        *devfnp = -1;
554
        return pci_find_bus(pci_find_root_bus(0), 0);
555
556
    }

557
    if (pci_parse_devaddr(devaddr, &dom, &bus, &slot, NULL) < 0) {
558
559
560
561
        return NULL;
    }

    *devfnp = slot << 3;
562
    return pci_find_bus(pci_find_root_bus(dom), bus);
563
564
}

565
566
567
568
569
570
571
572
573
574
575
576
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;
}

577
578
static void pci_init_wmask(PCIDevice *dev)
{
579
580
    int config_size = pci_config_size(dev);

581
582
    dev->wmask[PCI_CACHE_LINE_SIZE] = 0xff;
    dev->wmask[PCI_INTERRUPT_LINE] = 0xff;
583
    pci_set_word(dev->wmask + PCI_COMMAND,
584
585
                 PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER |
                 PCI_COMMAND_INTX_DISABLE);
586
587
588
    if (dev->cap_present & QEMU_PCI_CAP_SERR) {
        pci_word_test_and_set_mask(dev->wmask + PCI_COMMAND, PCI_COMMAND_SERR);
    }
589
590
591

    memset(dev->wmask + PCI_CONFIG_HEADER_SIZE, 0xff,
           config_size - PCI_CONFIG_HEADER_SIZE);
592
593
}

594
595
596
static void pci_init_w1cmask(PCIDevice *dev)
{
    /*
597
     * Note: It's okay to set w1cmask even for readonly bits as
598
599
600
601
602
603
604
605
     * 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);
}

606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
static void pci_init_wmask_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);

627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
/* 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_STATUS |
                 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);
650
651
}

652
653
654
655
656
657
658
659
660
661
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;
    }

    /*
Stefan Weil's avatar
Stefan Weil committed
662
     * multifunction bit is interpreted in two ways as follows.
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
     *   - 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;
}

700
701
702
703
704
705
706
static void pci_config_alloc(PCIDevice *pci_dev)
{
    int config_size = pci_config_size(pci_dev);

    pci_dev->config = qemu_mallocz(config_size);
    pci_dev->cmask = qemu_mallocz(config_size);
    pci_dev->wmask = qemu_mallocz(config_size);
707
    pci_dev->w1cmask = qemu_mallocz(config_size);
708
709
710
711
712
713
714
715
    pci_dev->used = qemu_mallocz(config_size);
}

static void pci_config_free(PCIDevice *pci_dev)
{
    qemu_free(pci_dev->config);
    qemu_free(pci_dev->cmask);
    qemu_free(pci_dev->wmask);
716
    qemu_free(pci_dev->w1cmask);
717
718
719
    qemu_free(pci_dev->used);
}

bellard's avatar
bellard committed
720
/* -1 for devfn means auto assign */
Paul Brook's avatar
Paul Brook committed
721
722
723
static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
                                         const char *name, int devfn,
                                         PCIConfigReadFunc *config_read,
724
                                         PCIConfigWriteFunc *config_write,
725
                                         bool is_bridge)
bellard's avatar
bellard committed
726
727
{
    if (devfn < 0) {
728
        for(devfn = bus->devfn_min ; devfn < ARRAY_SIZE(bus->devices);
729
            devfn += PCI_FUNC_MAX) {
730
            if (!bus->devices[devfn])
bellard's avatar
bellard committed
731
732
                goto found;
        }
733
        error_report("PCI: no slot/function available for %s, all in use", name);
734
        return NULL;
bellard's avatar
bellard committed
735
    found: ;
736
    } else if (bus->devices[devfn]) {
737
738
        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);
739
        return NULL;
bellard's avatar
bellard committed
740
    }
741
    pci_dev->bus = bus;
bellard's avatar
bellard committed
742
743
    pci_dev->devfn = devfn;
    pstrcpy(pci_dev->name, sizeof(pci_dev->name), name);
744
    pci_dev->irq_state = 0;
745
    pci_config_alloc(pci_dev);
746

747
    if (!is_bridge) {
748
749
        pci_set_default_subsystem_id(pci_dev);
    }
750
    pci_init_cmask(pci_dev);
751
    pci_init_wmask(pci_dev);
752
    pci_init_w1cmask(pci_dev);
753
    if (is_bridge) {
754
755
        pci_init_wmask_bridge(pci_dev);
    }
756
757
758
759
    if (pci_init_multifunction(bus, pci_dev)) {
        pci_config_free(pci_dev);
        return NULL;
    }
760
761
762
763
764

    if (!config_read)
        config_read = pci_default_read_config;
    if (!config_write)
        config_write = pci_default_write_config;
bellard's avatar
bellard committed
765
766
    pci_dev->config_read = config_read;
    pci_dev->config_write = config_write;
767
    bus->devices[devfn] = pci_dev;
768
    pci_dev->irq = qemu_allocate_irqs(pci_set_irq, pci_dev, PCI_NUM_PINS);
Juan Quintela's avatar
Juan Quintela committed
769
    pci_dev->version_id = 2; /* Current pci device vmstate version */
bellard's avatar
bellard committed
770
771
772
    return pci_dev;
}

773
774
775
776
777
778
779
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);
}

Paul Brook's avatar
Paul Brook committed
780
781
782
783
784
785
786
787
788
PCIDevice *pci_register_device(PCIBus *bus, const char *name,
                               int instance_size, int devfn,
                               PCIConfigReadFunc *config_read,
                               PCIConfigWriteFunc *config_write)
{
    PCIDevice *pci_dev;

    pci_dev = qemu_mallocz(instance_size);
    pci_dev = do_pci_register_device(pci_dev, bus, name, devfn,
789
790
                                     config_read, config_write,
                                     PCI_HEADER_TYPE_NORMAL);
791
792
793
    if (pci_dev == NULL) {
        hw_error("PCI: can't register device\n");
    }
Paul Brook's avatar
Paul Brook committed
794
795
    return pci_dev;
}
Blue Swirl's avatar
Blue Swirl committed
796
797
798

static target_phys_addr_t pci_to_cpu_addr(PCIBus *bus,
                                          target_phys_addr_t addr)
799
{
Blue Swirl's avatar
Blue Swirl committed
800
    return addr + bus->mem_base;
801
802
803
804
805
806
807
808
809
}

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];
810
        if (!r->size || r->addr == PCI_BAR_UNMAPPED)
811
            continue;
812
        if (r->type == PCI_BASE_ADDRESS_SPACE_IO) {
813
            isa_unassign_ioport(r->addr, r->filtered_size);
814
        } else {
Blue Swirl's avatar
Blue Swirl committed
815
816
817
818
            cpu_register_physical_memory(pci_to_cpu_addr(pci_dev->bus,
                                                         r->addr),
                                         r->filtered_size,
                                         IO_MEM_UNASSIGNED);
819
820
821
822
        }
    }
}

823
static int pci_unregister_device(DeviceState *dev)
824
{
825
    PCIDevice *pci_dev = DO_UPCAST(PCIDevice, qdev, dev);
826
    PCIDeviceInfo *info = DO_UPCAST(PCIDeviceInfo, qdev, dev->info);
827
828
    int ret = 0;

829
830
    if (info->exit)
        ret = info->exit(pci_dev);
831
832
833
834
    if (ret)
        return ret;

    pci_unregister_io_regions(pci_dev);
835
    pci_del_option_rom(pci_dev);
836
    do_pci_unregister_device(pci_dev);
837
838
839
    return 0;
}

840
void pci_register_bar(PCIDevice *pci_dev, int region_num,
841
                            pcibus_t size, uint8_t type,
bellard's avatar
bellard committed
842
843
844
                            PCIMapIORegionFunc *map_func)
{
    PCIIORegion *r;
pbrook's avatar
pbrook committed
845
    uint32_t addr;
846
    uint64_t wmask;
847

848
849
    assert(region_num >= 0);
    assert(region_num < PCI_NUM_REGIONS);
850
851
    if (size & (size-1)) {
        fprintf(stderr, "ERROR: PCI region size must be pow2 "
852
                    "type=0x%x, size=0x%"FMT_PCIBUS"\n", type, size);
853
854
855
        exit(1);
    }

bellard's avatar
bellard committed
856
    r = &pci_dev->io_regions[region_num];
857
    r->addr = PCI_BAR_UNMAPPED;
bellard's avatar
bellard committed
858
    r->size = size;
859
    r->filtered_size = size;
bellard's avatar
bellard committed
860
861
    r->type = type;
    r->map_func = map_func;
862
863

    wmask = ~(size - 1);
864
    addr = pci_bar(pci_dev, region_num);
pbrook's avatar
pbrook committed
865
    if (region_num == PCI_ROM_SLOT) {
866
        /* ROM enable bit is writeable */
867
        wmask |= PCI_ROM_ADDRESS_ENABLE;
pbrook's avatar
pbrook committed
868
    }
869
    pci_set_long(pci_dev->config + addr, type);
Isaku Yamahata's avatar
Isaku Yamahata committed
870
871
872
873
874
875
876
877
    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);
    }
bellard's avatar
bellard committed
878
879
}

880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
static void pci_bridge_filter(PCIDevice *d, pcibus_t *addr, pcibus_t *size,
                              uint8_t type)
{
    pcibus_t base = *addr;
    pcibus_t limit = *addr + *size - 1;
    PCIDevice *br;

    for (br = d->bus->parent_dev; br; br = br->bus->parent_dev) {
        uint16_t cmd = pci_get_word(d->config + PCI_COMMAND);

        if (type & PCI_BASE_ADDRESS_SPACE_IO) {
            if (!(cmd & PCI_COMMAND_IO)) {
                goto no_map;
            }
        } else {
            if (!(cmd & PCI_COMMAND_MEMORY)) {
                goto no_map;
            }
        }

        base = MAX(base, pci_bridge_get_base(br, type));
        limit = MIN(limit, pci_bridge_get_limit(br, type));
    }

    if (base > limit) {
905
        goto no_map;
906
    }
907
908
909
910
911
912
    *addr = base;
    *size = limit - base + 1;
    return;
no_map:
    *addr = PCI_BAR_UNMAPPED;
    *size = 0;
913
914
}

915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
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);
        last_addr = new_addr + size - 1;
        /* NOTE: we have only 64K ioports on PC */
        if (last_addr <= new_addr || new_addr == 0 || last_addr > UINT16_MAX) {
            return PCI_BAR_UNMAPPED;
        }
        return new_addr;
    }

    if (!(cmd & PCI_COMMAND_MEMORY)) {
        return PCI_BAR_UNMAPPED;
    }
    if (type & PCI_BASE_ADDRESS_MEM_TYPE_64) {
        new_addr = pci_get_quad(d->config + bar);
    } else {
        new_addr = pci_get_long(d->config + bar);
    }
    /* the ROM slot has a specific enable bit */
    if (reg == PCI_ROM_SLOT && !(new_addr & PCI_ROM_ADDRESS_ENABLE)) {
        return PCI_BAR_UNMAPPED;
    }
    new_addr &= ~(size - 1);
    last_addr = new_addr + size - 1;
    /* NOTE: we do not support wrapping */
    /* XXX: as we cannot support really dynamic
       mappings, we handle specific values as invalid
       mappings. */
    if (last_addr <= new_addr || new_addr == 0 ||
        last_addr == PCI_BAR_UNMAPPED) {
        return PCI_BAR_UNMAPPED;
    }

    /* Now pcibus_t is 64bit.
     * Check if 32 bit BAR wraps around explicitly.
     * Without this, PC ide doesn't work well.
     * TODO: remove this work around.
     */
    if  (!(type & PCI_BASE_ADDRESS_MEM_TYPE_64) && last_addr >= UINT32_MAX) {
        return PCI_BAR_UNMAPPED;
    }

    /*
     * OS is allowed to set BAR beyond its addressable
     * bits. For example, 32 bit OS can set 64bit bar
     * to >4G. Check it. TODO: we might need to support
     * it in the future for e.g. PAE.
     */
    if (last_addr >= TARGET_PHYS_ADDR_MAX) {
        return PCI_BAR_UNMAPPED;
    }

    return new_addr;
}

980
981
982
static void pci_update_mappings(PCIDevice *d)
{
    PCIIORegion *r;
983
    int i;
984
    pcibus_t new_addr, filtered_size;
985

986
    for(i = 0; i < PCI_NUM_REGIONS; i++) {
987
        r = &d->io_regions[i];
988
989

        /* this region isn't registered */
990
        if (!r->size)
991
992
            continue;

993
        new_addr = pci_bar_address(d, i, r->type, r->size);
994

995
996
997
998
999
1000
        /* bridge filtering */
        filtered_size = r->size;
        if (new_addr != PCI_BAR_UNMAPPED) {
            pci_bridge_filter(d, &new_addr, &filtered_size, r->type);
        }

For faster browsing, not all history is shown. View entire blame