qemu/roms/seabios/src/fw/pciinit.c

   1 // Initialize PCI devices (on emulators)
   2 //
   3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2006 Fabrice Bellard
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "byteorder.h" // le64_to_cpu
   9 #include "config.h" // CONFIG_*
  10 #include "dev-q35.h" // Q35_HOST_BRIDGE_PCIEXBAR_ADDR
  11 #include "dev-piix.h" // PIIX_*
  12 #include "e820map.h" // e820_add
  13 #include "hw/ata.h" // PORT_ATA1_CMD_BASE
  14 #include "hw/pci.h" // pci_config_readl
  15 #include "hw/pci_ids.h" // PCI_VENDOR_ID_INTEL
  16 #include "hw/pci_regs.h" // PCI_COMMAND
  17 #include "list.h" // struct hlist_node
  18 #include "malloc.h" // free
  19 #include "output.h" // dprintf
  20 #include "paravirt.h" // RamSize
  21 #include "romfile.h" // romfile_loadint
  22 #include "string.h" // memset
  23 #include "util.h" // pci_setup
  24 #include "x86.h" // outb
  25
  26 #define PCI_DEVICE_MEM_MIN    (1<<12)  // 4k == page size
  27 #define PCI_BRIDGE_MEM_MIN    (1<<21)  // 2M == hugepage size
  28 #define PCI_BRIDGE_IO_MIN      0x1000  // mandated by pci bridge spec
  29
  30 static const char *region_type_name[] = {
  31     [ PCI_REGION_TYPE_IO ]      = "io",
  32     [ PCI_REGION_TYPE_MEM ]     = "mem",
  33     [ PCI_REGION_TYPE_PREFMEM ] = "prefmem",
  34 };
  35
  36 u64 pcimem_start   = BUILD_PCIMEM_START;
  37 u64 pcimem_end     = BUILD_PCIMEM_END;
  38 u64 pcimem64_start = BUILD_PCIMEM64_START;
  39 u64 pcimem64_end   = BUILD_PCIMEM64_END;
  40 u64 pci_io_low_end = 0xa000;
  41
  42 struct pci_region_entry {
  43     struct pci_device *dev;
  44     int bar;
  45     u64 size;
  46     u64 align;
  47     int is64;
  48     enum pci_region_type type;
  49     struct hlist_node node;
  50 };
  51
  52 struct pci_region {
  53     /* pci region assignments */
  54     u64 base;
  55     struct hlist_head list;
  56 };
  57
  58 struct pci_bus {
  59     struct pci_region r[PCI_REGION_TYPE_COUNT];
  60     struct pci_device *bus_dev;
  61 };
  62
  63 static u32 pci_bar(struct pci_device *pci, int region_num)
  64 {
  65     if (region_num != PCI_ROM_SLOT) {
  66         return PCI_BASE_ADDRESS_0 + region_num * 4;
  67     }
  68
  69 #define PCI_HEADER_TYPE_MULTI_FUNCTION 0x80
  70     u8 type = pci->header_type & ~PCI_HEADER_TYPE_MULTI_FUNCTION;
  71     return type == PCI_HEADER_TYPE_BRIDGE ? PCI_ROM_ADDRESS1 : PCI_ROM_ADDRESS;
  72 }
  73
  74 static void
  75 pci_set_io_region_addr(struct pci_device *pci, int bar, u64 addr, int is64)
  76 {
  77     u32 ofs = pci_bar(pci, bar);
  78     pci_config_writel(pci->bdf, ofs, addr);
  79     if (is64)
  80         pci_config_writel(pci->bdf, ofs + 4, addr >> 32);
  81 }
  82
  83
  84 /****************************************************************
  85  * Misc. device init
  86  ****************************************************************/
  87
  88 /* host irqs corresponding to PCI irqs A-D */
  89 const u8 pci_irqs[4] = {
  90     10, 10, 11, 11
  91 };
  92
  93 static int dummy_pci_slot_get_irq(struct pci_device *pci, int pin)
  94 {
  95     dprintf(1, "pci_slot_get_irq called with unknown routing\n");
  96
  97     return 0xff; /* PCI defined "unknown" or "no connection" for x86 */
  98 }
  99
 100 static int (*pci_slot_get_irq)(struct pci_device *pci, int pin) =
 101     dummy_pci_slot_get_irq;
 102
 103 // Return the global irq number corresponding to a host bus device irq pin.
 104 static int piix_pci_slot_get_irq(struct pci_device *pci, int pin)
 105 {
 106     int slot_addend = 0;
 107
 108     while (pci->parent != NULL) {
 109         slot_addend += pci_bdf_to_dev(pci->bdf);
 110         pci = pci->parent;
 111     }
 112     slot_addend += pci_bdf_to_dev(pci->bdf) - 1;
 113     return pci_irqs[(pin - 1 + slot_addend) & 3];
 114 }
 115
 116 static int mch_pci_slot_get_irq(struct pci_device *pci, int pin)
 117 {
 118     int pin_addend = 0;
 119     while (pci->parent != NULL) {
 120         pin_addend += pci_bdf_to_dev(pci->bdf);
 121         pci = pci->parent;
 122     }
 123     u8 slot = pci_bdf_to_dev(pci->bdf);
 124     if (slot <= 24)
 125         /* Slots 0-24 rotate slot:pin mapping similar to piix above, but
 126            with a different starting index - see q35-acpi-dsdt.dsl */
 127         return pci_irqs[(pin - 1 + pin_addend + slot) & 3];
 128     /* Slots 25-31 all use LNKA mapping (or LNKE, but A:D = E:H) */
 129     return pci_irqs[(pin - 1 + pin_addend) & 3];
 130 }
 131
 132 /* PIIX3/PIIX4 PCI to ISA bridge */
 133 static void piix_isa_bridge_setup(struct pci_device *pci, void *arg)
 134 {
 135     int i, irq;
 136     u8 elcr[2];
 137
 138     elcr[0] = 0x00;
 139     elcr[1] = 0x00;
 140     for (i = 0; i < 4; i++) {
 141         irq = pci_irqs[i];
 142         /* set to trigger level */
 143         elcr[irq >> 3] |= (1 << (irq & 7));
 144         /* activate irq remapping in PIIX */
 145         pci_config_writeb(pci->bdf, 0x60 + i, irq);
 146     }
 147     outb(elcr[0], PIIX_PORT_ELCR1);
 148     outb(elcr[1], PIIX_PORT_ELCR2);
 149     dprintf(1, "PIIX3/PIIX4 init: elcr=%02x %02x\n", elcr[0], elcr[1]);
 150 }
 151
 152 /* ICH9 LPC PCI to ISA bridge */
 153 /* PCI_VENDOR_ID_INTEL && PCI_DEVICE_ID_INTEL_ICH9_LPC */
 154 static void mch_isa_bridge_setup(struct pci_device *dev, void *arg)
 155 {
 156     u16 bdf = dev->bdf;
 157     int i, irq;
 158     u8 elcr[2];
 159
 160     elcr[0] = 0x00;
 161     elcr[1] = 0x00;
 162
 163     for (i = 0; i < 4; i++) {
 164         irq = pci_irqs[i];
 165         /* set to trigger level */
 166         elcr[irq >> 3] |= (1 << (irq & 7));
 167
 168         /* activate irq remapping in LPC */
 169
 170         /* PIRQ[A-D] routing */
 171         pci_config_writeb(bdf, ICH9_LPC_PIRQA_ROUT + i, irq);
 172         /* PIRQ[E-H] routing */
 173         pci_config_writeb(bdf, ICH9_LPC_PIRQE_ROUT + i, irq);
 174     }
 175     outb(elcr[0], ICH9_LPC_PORT_ELCR1);
 176     outb(elcr[1], ICH9_LPC_PORT_ELCR2);
 177     dprintf(1, "Q35 LPC init: elcr=%02x %02x\n", elcr[0], elcr[1]);
 178
 179     /* pm io base */
 180     pci_config_writel(bdf, ICH9_LPC_PMBASE,
 181                       acpi_pm_base | ICH9_LPC_PMBASE_RTE);
 182
 183     /* acpi enable, SCI: IRQ9 000b = irq9*/
 184     pci_config_writeb(bdf, ICH9_LPC_ACPI_CTRL, ICH9_LPC_ACPI_CTRL_ACPI_EN);
 185
 186     /* set root complex register block BAR */
 187     pci_config_writel(bdf, ICH9_LPC_RCBA,
 188                       ICH9_LPC_RCBA_ADDR | ICH9_LPC_RCBA_EN);
 189     e820_add(ICH9_LPC_RCBA_ADDR, 16*1024, E820_RESERVED);
 190
 191     acpi_pm1a_cnt = acpi_pm_base + 0x04;
 192     pmtimer_setup(acpi_pm_base + 0x08);
 193 }
 194
 195 static void storage_ide_setup(struct pci_device *pci, void *arg)
 196 {
 197     /* IDE: we map it as in ISA mode */
 198     pci_set_io_region_addr(pci, 0, PORT_ATA1_CMD_BASE, 0);
 199     pci_set_io_region_addr(pci, 1, PORT_ATA1_CTRL_BASE, 0);
 200     pci_set_io_region_addr(pci, 2, PORT_ATA2_CMD_BASE, 0);
 201     pci_set_io_region_addr(pci, 3, PORT_ATA2_CTRL_BASE, 0);
 202 }
 203
 204 /* PIIX3/PIIX4 IDE */
 205 static void piix_ide_setup(struct pci_device *pci, void *arg)
 206 {
 207     u16 bdf = pci->bdf;
 208     pci_config_writew(bdf, 0x40, 0x8000); // enable IDE0
 209     pci_config_writew(bdf, 0x42, 0x8000); // enable IDE1
 210 }
 211
 212 static void pic_ibm_setup(struct pci_device *pci, void *arg)
 213 {
 214     /* PIC, IBM, MPIC & MPIC2 */
 215     pci_set_io_region_addr(pci, 0, 0x80800000 + 0x00040000, 0);
 216 }
 217
 218 static void apple_macio_setup(struct pci_device *pci, void *arg)
 219 {
 220     /* macio bridge */
 221     pci_set_io_region_addr(pci, 0, 0x80800000, 0);
 222 }
 223
 224 static void piix4_pm_config_setup(u16 bdf)
 225 {
 226     // acpi sci is hardwired to 9
 227     pci_config_writeb(bdf, PCI_INTERRUPT_LINE, 9);
 228
 229     pci_config_writel(bdf, PIIX_PMBASE, acpi_pm_base | 1);
 230     pci_config_writeb(bdf, PIIX_PMREGMISC, 0x01); /* enable PM io space */
 231     pci_config_writel(bdf, PIIX_SMBHSTBASE, (acpi_pm_base + 0x100) | 1);
 232     pci_config_writeb(bdf, PIIX_SMBHSTCFG, 0x09); /* enable SMBus io space */
 233 }
 234
 235 static int PiixPmBDF = -1;
 236
 237 /* PIIX4 Power Management device (for ACPI) */
 238 static void piix4_pm_setup(struct pci_device *pci, void *arg)
 239 {
 240     PiixPmBDF = pci->bdf;
 241     piix4_pm_config_setup(pci->bdf);
 242
 243     acpi_pm1a_cnt = acpi_pm_base + 0x04;
 244     pmtimer_setup(acpi_pm_base + 0x08);
 245 }
 246
 247 /* ICH9 SMBUS */
 248 /* PCI_VENDOR_ID_INTEL && PCI_DEVICE_ID_INTEL_ICH9_SMBUS */
 249 static void ich9_smbus_setup(struct pci_device *dev, void *arg)
 250 {
 251     u16 bdf = dev->bdf;
 252     /* map smbus into io space */
 253     pci_config_writel(bdf, ICH9_SMB_SMB_BASE,
 254                       (acpi_pm_base + 0x100) | PCI_BASE_ADDRESS_SPACE_IO);
 255
 256     /* enable SMBus */
 257     pci_config_writeb(bdf, ICH9_SMB_HOSTC, ICH9_SMB_HOSTC_HST_EN);
 258 }
 259
 260 static const struct pci_device_id pci_device_tbl[] = {
 261     /* PIIX3/PIIX4 PCI to ISA bridge */
 262     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371SB_0,
 263                piix_isa_bridge_setup),
 264     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_0,
 265                piix_isa_bridge_setup),
 266     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_LPC,
 267                mch_isa_bridge_setup),
 268
 269     /* STORAGE IDE */
 270     PCI_DEVICE_CLASS(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371SB_1,
 271                      PCI_CLASS_STORAGE_IDE, piix_ide_setup),
 272     PCI_DEVICE_CLASS(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB,
 273                      PCI_CLASS_STORAGE_IDE, piix_ide_setup),
 274     PCI_DEVICE_CLASS(PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE,
 275                      storage_ide_setup),
 276
 277     /* PIC, IBM, MIPC & MPIC2 */
 278     PCI_DEVICE_CLASS(PCI_VENDOR_ID_IBM, 0x0046, PCI_CLASS_SYSTEM_PIC,
 279                      pic_ibm_setup),
 280     PCI_DEVICE_CLASS(PCI_VENDOR_ID_IBM, 0xFFFF, PCI_CLASS_SYSTEM_PIC,
 281                      pic_ibm_setup),
 282
 283     /* PIIX4 Power Management device (for ACPI) */
 284     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3,
 285                piix4_pm_setup),
 286     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH9_SMBUS,
 287                ich9_smbus_setup),
 288
 289     /* 0xff00 */
 290     PCI_DEVICE_CLASS(PCI_VENDOR_ID_APPLE, 0x0017, 0xff00, apple_macio_setup),
 291     PCI_DEVICE_CLASS(PCI_VENDOR_ID_APPLE, 0x0022, 0xff00, apple_macio_setup),
 292
 293     PCI_DEVICE_END,
 294 };
 295
 296 void pci_resume(void)
 297 {
 298     if (!CONFIG_QEMU) {
 299         return;
 300     }
 301
 302     if (PiixPmBDF >= 0) {
 303         piix4_pm_config_setup(PiixPmBDF);
 304     }
 305 }
 306
 307 static void pci_bios_init_device(struct pci_device *pci)
 308 {
 309     u16 bdf = pci->bdf;
 310     dprintf(1, "PCI: init bdf=%02x:%02x.%x id=%04x:%04x\n"
 311             , pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf), pci_bdf_to_fn(bdf)
 312             , pci->vendor, pci->device);
 313
 314     /* map the interrupt */
 315     int pin = pci_config_readb(bdf, PCI_INTERRUPT_PIN);
 316     if (pin != 0)
 317         pci_config_writeb(bdf, PCI_INTERRUPT_LINE, pci_slot_get_irq(pci, pin));
 318
 319     pci_init_device(pci_device_tbl, pci, NULL);
 320
 321     /* enable memory mappings */
 322     pci_config_maskw(bdf, PCI_COMMAND, 0,
 323                      PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_SERR);
 324     /* enable SERR# for forwarding */
 325     if (pci->header_type & PCI_HEADER_TYPE_BRIDGE)
 326         pci_config_maskw(bdf, PCI_BRIDGE_CONTROL, 0,
 327                          PCI_BRIDGE_CTL_SERR);
 328 }
 329
 330 static void pci_bios_init_devices(void)
 331 {
 332     struct pci_device *pci;
 333     foreachpci(pci) {
 334         pci_bios_init_device(pci);
 335     }
 336 }
 337
 338 static void pci_enable_default_vga(void)
 339 {
 340     struct pci_device *pci;
 341
 342     foreachpci(pci) {
 343         if (is_pci_vga(pci)) {
 344             dprintf(1, "PCI: Using %02x:%02x.%x for primary VGA\n",
 345                     pci_bdf_to_bus(pci->bdf), pci_bdf_to_dev(pci->bdf),
 346                     pci_bdf_to_fn(pci->bdf));
 347             return;
 348         }
 349     }
 350
 351     pci = pci_find_class(PCI_CLASS_DISPLAY_VGA);
 352     if (!pci) {
 353         dprintf(1, "PCI: No VGA devices found\n");
 354         return;
 355     }
 356
 357     dprintf(1, "PCI: Enabling %02x:%02x.%x for primary VGA\n",
 358             pci_bdf_to_bus(pci->bdf), pci_bdf_to_dev(pci->bdf),
 359             pci_bdf_to_fn(pci->bdf));
 360
 361     pci_config_maskw(pci->bdf, PCI_COMMAND, 0,
 362                      PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 363
 364     while (pci->parent) {
 365         pci = pci->parent;
 366
 367         dprintf(1, "PCI: Setting VGA enable on bridge %02x:%02x.%x\n",
 368                 pci_bdf_to_bus(pci->bdf), pci_bdf_to_dev(pci->bdf),
 369                 pci_bdf_to_fn(pci->bdf));
 370
 371         pci_config_maskw(pci->bdf, PCI_BRIDGE_CONTROL, 0, PCI_BRIDGE_CTL_VGA);
 372         pci_config_maskw(pci->bdf, PCI_COMMAND, 0,
 373                          PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
 374     }
 375 }
 376
 377 /****************************************************************
 378  * Platform device initialization
 379  ****************************************************************/
 380
 381 static void i440fx_mem_addr_setup(struct pci_device *dev, void *arg)
 382 {
 383     if (RamSize <= 0x80000000)
 384         pcimem_start = 0x80000000;
 385     else if (RamSize <= 0xc0000000)
 386         pcimem_start = 0xc0000000;
 387
 388     pci_slot_get_irq = piix_pci_slot_get_irq;
 389 }
 390
 391 static void mch_mem_addr_setup(struct pci_device *dev, void *arg)
 392 {
 393     u64 addr = Q35_HOST_BRIDGE_PCIEXBAR_ADDR;
 394     u32 size = Q35_HOST_BRIDGE_PCIEXBAR_SIZE;
 395
 396     /* setup mmconfig */
 397     u16 bdf = dev->bdf;
 398     u32 upper = addr >> 32;
 399     u32 lower = (addr & 0xffffffff) | Q35_HOST_BRIDGE_PCIEXBAREN;
 400     pci_config_writel(bdf, Q35_HOST_BRIDGE_PCIEXBAR, 0);
 401     pci_config_writel(bdf, Q35_HOST_BRIDGE_PCIEXBAR + 4, upper);
 402     pci_config_writel(bdf, Q35_HOST_BRIDGE_PCIEXBAR, lower);
 403     e820_add(addr, size, E820_RESERVED);
 404
 405     /* setup pci i/o window (above mmconfig) */
 406     pcimem_start = addr + size;
 407
 408     pci_slot_get_irq = mch_pci_slot_get_irq;
 409
 410     /* setup io address space */
 411     if (acpi_pm_base < 0x1000)
 412         pci_io_low_end = 0x10000;
 413     else
 414         pci_io_low_end = acpi_pm_base;
 415 }
 416
 417 static const struct pci_device_id pci_platform_tbl[] = {
 418     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82441,
 419                i440fx_mem_addr_setup),
 420     PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_Q35_MCH,
 421                mch_mem_addr_setup),
 422     PCI_DEVICE_END
 423 };
 424
 425 static void pci_bios_init_platform(void)
 426 {
 427     struct pci_device *pci;
 428     foreachpci(pci) {
 429         pci_init_device(pci_platform_tbl, pci, NULL);
 430     }
 431 }
 432
 433
 434 /****************************************************************
 435  * Bus initialization
 436  ****************************************************************/
 437
 438 static void
 439 pci_bios_init_bus_rec(int bus, u8 *pci_bus)
 440 {
 441     int bdf;
 442     u16 class;
 443
 444     dprintf(1, "PCI: %s bus = 0x%x\n", __func__, bus);
 445
 446     /* prevent accidental access to unintended devices */
 447     foreachbdf(bdf, bus) {
 448         class = pci_config_readw(bdf, PCI_CLASS_DEVICE);
 449         if (class == PCI_CLASS_BRIDGE_PCI) {
 450             pci_config_writeb(bdf, PCI_SECONDARY_BUS, 255);
 451             pci_config_writeb(bdf, PCI_SUBORDINATE_BUS, 0);
 452         }
 453     }
 454
 455     foreachbdf(bdf, bus) {
 456         class = pci_config_readw(bdf, PCI_CLASS_DEVICE);
 457         if (class != PCI_CLASS_BRIDGE_PCI) {
 458             continue;
 459         }
 460         dprintf(1, "PCI: %s bdf = 0x%x\n", __func__, bdf);
 461
 462         u8 pribus = pci_config_readb(bdf, PCI_PRIMARY_BUS);
 463         if (pribus != bus) {
 464             dprintf(1, "PCI: primary bus = 0x%x -> 0x%x\n", pribus, bus);
 465             pci_config_writeb(bdf, PCI_PRIMARY_BUS, bus);
 466         } else {
 467             dprintf(1, "PCI: primary bus = 0x%x\n", pribus);
 468         }
 469
 470         u8 secbus = pci_config_readb(bdf, PCI_SECONDARY_BUS);
 471         (*pci_bus)++;
 472         if (*pci_bus != secbus) {
 473             dprintf(1, "PCI: secondary bus = 0x%x -> 0x%x\n",
 474                     secbus, *pci_bus);
 475             secbus = *pci_bus;
 476             pci_config_writeb(bdf, PCI_SECONDARY_BUS, secbus);
 477         } else {
 478             dprintf(1, "PCI: secondary bus = 0x%x\n", secbus);
 479         }
 480
 481         /* set to max for access to all subordinate buses.
 482            later set it to accurate value */
 483         u8 subbus = pci_config_readb(bdf, PCI_SUBORDINATE_BUS);
 484         pci_config_writeb(bdf, PCI_SUBORDINATE_BUS, 255);
 485
 486         pci_bios_init_bus_rec(secbus, pci_bus);
 487
 488         if (subbus != *pci_bus) {
 489             dprintf(1, "PCI: subordinate bus = 0x%x -> 0x%x\n",
 490                     subbus, *pci_bus);
 491             subbus = *pci_bus;
 492         } else {
 493             dprintf(1, "PCI: subordinate bus = 0x%x\n", subbus);
 494         }
 495         pci_config_writeb(bdf, PCI_SUBORDINATE_BUS, subbus);
 496     }
 497 }
 498
 499 static void
 500 pci_bios_init_bus(void)
 501 {
 502     u8 extraroots = romfile_loadint("etc/extra-pci-roots", 0);
 503     u8 pci_bus = 0;
 504
 505     pci_bios_init_bus_rec(0 /* host bus */, &pci_bus);
 506
 507     if (extraroots) {
 508         while (pci_bus < 0xff) {
 509             pci_bus++;
 510             pci_bios_init_bus_rec(pci_bus, &pci_bus);
 511         }
 512     }
 513 }
 514
 515
 516 /****************************************************************
 517  * Bus sizing
 518  ****************************************************************/
 519
 520 static void
 521 pci_bios_get_bar(struct pci_device *pci, int bar,
 522                  int *ptype, u64 *psize, int *pis64)
 523 {
 524     u32 ofs = pci_bar(pci, bar);
 525     u16 bdf = pci->bdf;
 526     u32 old = pci_config_readl(bdf, ofs);
 527     int is64 = 0, type = PCI_REGION_TYPE_MEM;
 528     u64 mask;
 529
 530     if (bar == PCI_ROM_SLOT) {
 531         mask = PCI_ROM_ADDRESS_MASK;
 532         pci_config_writel(bdf, ofs, mask);
 533     } else {
 534         if (old & PCI_BASE_ADDRESS_SPACE_IO) {
 535             mask = PCI_BASE_ADDRESS_IO_MASK;
 536             type = PCI_REGION_TYPE_IO;
 537         } else {
 538             mask = PCI_BASE_ADDRESS_MEM_MASK;
 539             if (old & PCI_BASE_ADDRESS_MEM_PREFETCH)
 540                 type = PCI_REGION_TYPE_PREFMEM;
 541             is64 = ((old & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
 542                     == PCI_BASE_ADDRESS_MEM_TYPE_64);
 543         }
 544         pci_config_writel(bdf, ofs, ~0);
 545     }
 546     u64 val = pci_config_readl(bdf, ofs);
 547     pci_config_writel(bdf, ofs, old);
 548     if (is64) {
 549         u32 hold = pci_config_readl(bdf, ofs + 4);
 550         pci_config_writel(bdf, ofs + 4, ~0);
 551         u32 high = pci_config_readl(bdf, ofs + 4);
 552         pci_config_writel(bdf, ofs + 4, hold);
 553         val |= ((u64)high << 32);
 554         mask |= ((u64)0xffffffff << 32);
 555         *psize = (~(val & mask)) + 1;
 556     } else {
 557         *psize = ((~(val & mask)) + 1) & 0xffffffff;
 558     }
 559     *ptype = type;
 560     *pis64 = is64;
 561 }
 562
 563 static int pci_bios_bridge_region_is64(struct pci_region *r,
 564                                  struct pci_device *pci, int type)
 565 {
 566     if (type != PCI_REGION_TYPE_PREFMEM)
 567         return 0;
 568     u32 pmem = pci_config_readl(pci->bdf, PCI_PREF_MEMORY_BASE);
 569     if (!pmem) {
 570         pci_config_writel(pci->bdf, PCI_PREF_MEMORY_BASE, 0xfff0fff0);
 571         pmem = pci_config_readl(pci->bdf, PCI_PREF_MEMORY_BASE);
 572         pci_config_writel(pci->bdf, PCI_PREF_MEMORY_BASE, 0x0);
 573     }
 574     if ((pmem & PCI_PREF_RANGE_TYPE_MASK) != PCI_PREF_RANGE_TYPE_64)
 575        return 0;
 576     struct pci_region_entry *entry;
 577     hlist_for_each_entry(entry, &r->list, node) {
 578         if (!entry->is64)
 579             return 0;
 580     }
 581     return 1;
 582 }
 583
 584 static u64 pci_region_align(struct pci_region *r)
 585 {
 586     struct pci_region_entry *entry;
 587     hlist_for_each_entry(entry, &r->list, node) {
 588         // The first entry in the sorted list has the largest alignment
 589         return entry->align;
 590     }
 591     return 1;
 592 }
 593
 594 static u64 pci_region_sum(struct pci_region *r)
 595 {
 596     u64 sum = 0;
 597     struct pci_region_entry *entry;
 598     hlist_for_each_entry(entry, &r->list, node) {
 599         sum += entry->size;
 600     }
 601     return sum;
 602 }
 603
 604 static void pci_region_migrate_64bit_entries(struct pci_region *from,
 605                                              struct pci_region *to)
 606 {
 607     struct hlist_node *n, **last = &to->list.first;
 608     struct pci_region_entry *entry;
 609     hlist_for_each_entry_safe(entry, n, &from->list, node) {
 610         if (!entry->is64)
 611             continue;
 612         if (entry->dev->class == PCI_CLASS_SERIAL_USB)
 613             continue;
 614         // Move from source list to destination list.
 615         hlist_del(&entry->node);
 616         hlist_add(&entry->node, last);
 617         last = &entry->node.next;
 618     }
 619 }
 620
 621 static struct pci_region_entry *
 622 pci_region_create_entry(struct pci_bus *bus, struct pci_device *dev,
 623                         int bar, u64 size, u64 align, int type, int is64)
 624 {
 625     struct pci_region_entry *entry = malloc_tmp(sizeof(*entry));
 626     if (!entry) {
 627         warn_noalloc();
 628         return NULL;
 629     }
 630     memset(entry, 0, sizeof(*entry));
 631     entry->dev = dev;
 632     entry->bar = bar;
 633     entry->size = size;
 634     entry->align = align;
 635     entry->is64 = is64;
 636     entry->type = type;
 637     // Insert into list in sorted order.
 638     struct hlist_node **pprev;
 639     struct pci_region_entry *pos;
 640     hlist_for_each_entry_pprev(pos, pprev, &bus->r[type].list, node) {
 641         if (pos->align < align || (pos->align == align && pos->size < size))
 642             break;
 643     }
 644     hlist_add(&entry->node, pprev);
 645     return entry;
 646 }
 647
 648 static int pci_bus_hotplug_support(struct pci_bus *bus, u8 pcie_cap)
 649 {
 650     u8 shpc_cap;
 651
 652     if (pcie_cap) {
 653         u16 pcie_flags = pci_config_readw(bus->bus_dev->bdf,
 654                                           pcie_cap + PCI_EXP_FLAGS);
 655         u8 port_type = ((pcie_flags & PCI_EXP_FLAGS_TYPE) >>
 656                        (__builtin_ffs(PCI_EXP_FLAGS_TYPE) - 1));
 657         u8 downstream_port = (port_type == PCI_EXP_TYPE_DOWNSTREAM) ||
 658                              (port_type == PCI_EXP_TYPE_ROOT_PORT);
 659         /*
 660          * PCI Express SPEC, 7.8.2:
 661          *   Slot Implemented – When Set, this bit indicates that the Link
 662          *   HwInit associated with this Port is connected to a slot (as
 663          *   compared to being connected to a system-integrated device or
 664          *   being disabled).
 665          *   This bit is valid for Downstream Ports. This bit is undefined
 666          *   for Upstream Ports.
 667          */
 668         u16 slot_implemented = pcie_flags & PCI_EXP_FLAGS_SLOT;
 669
 670         return downstream_port && slot_implemented;
 671     }
 672
 673     shpc_cap = pci_find_capability(bus->bus_dev, PCI_CAP_ID_SHPC, 0);
 674     return !!shpc_cap;
 675 }
 676
 677 static int pci_bios_check_devices(struct pci_bus *busses)
 678 {
 679     dprintf(1, "PCI: check devices\n");
 680
 681     // Calculate resources needed for regular (non-bus) devices.
 682     struct pci_device *pci;
 683     foreachpci(pci) {
 684         if (pci->class == PCI_CLASS_BRIDGE_PCI)
 685             busses[pci->secondary_bus].bus_dev = pci;
 686
 687         struct pci_bus *bus = &busses[pci_bdf_to_bus(pci->bdf)];
 688         if (!bus->bus_dev)
 689             /*
 690              * Resources for all root busses go in busses[0]
 691              */
 692             bus = &busses[0];
 693         int i;
 694         for (i = 0; i < PCI_NUM_REGIONS; i++) {
 695             if ((pci->class == PCI_CLASS_BRIDGE_PCI) &&
 696                 (i >= PCI_BRIDGE_NUM_REGIONS && i < PCI_ROM_SLOT))
 697                 continue;
 698             int type, is64;
 699             u64 size;
 700             pci_bios_get_bar(pci, i, &type, &size, &is64);
 701             if (size == 0)
 702                 continue;
 703
 704             if (type != PCI_REGION_TYPE_IO && size < PCI_DEVICE_MEM_MIN)
 705                 size = PCI_DEVICE_MEM_MIN;
 706             struct pci_region_entry *entry = pci_region_create_entry(
 707                 bus, pci, i, size, size, type, is64);
 708             if (!entry)
 709                 return -1;
 710
 711             if (is64)
 712                 i++;
 713         }
 714     }
 715
 716     // Propagate required bus resources to parent busses.
 717     int secondary_bus;
 718     for (secondary_bus=MaxPCIBus; secondary_bus>0; secondary_bus--) {
 719         struct pci_bus *s = &busses[secondary_bus];
 720         if (!s->bus_dev)
 721             continue;
 722         struct pci_bus *parent = &busses[pci_bdf_to_bus(s->bus_dev->bdf)];
 723         if (!parent->bus_dev)
 724             /*
 725              * Resources for all root busses go in busses[0]
 726              */
 727             parent = &busses[0];
 728         int type;
 729         u8 pcie_cap = pci_find_capability(s->bus_dev, PCI_CAP_ID_EXP, 0);
 730         int hotplug_support = pci_bus_hotplug_support(s, pcie_cap);
 731         for (type = 0; type < PCI_REGION_TYPE_COUNT; type++) {
 732             u64 align = (type == PCI_REGION_TYPE_IO) ?
 733                 PCI_BRIDGE_IO_MIN : PCI_BRIDGE_MEM_MIN;
 734             if (!pci_bridge_has_region(s->bus_dev, type))
 735                 continue;
 736             if (pci_region_align(&s->r[type]) > align)
 737                  align = pci_region_align(&s->r[type]);
 738             u64 sum = pci_region_sum(&s->r[type]);
 739             int resource_optional = pcie_cap && (type == PCI_REGION_TYPE_IO);
 740             if (!sum && hotplug_support && !resource_optional)
 741                 sum = align; /* reserve min size for hot-plug */
 742             u64 size = ALIGN(sum, align);
 743             int is64 = pci_bios_bridge_region_is64(&s->r[type],
 744                                             s->bus_dev, type);
 745             // entry->bar is -1 if the entry represents a bridge region
 746             struct pci_region_entry *entry = pci_region_create_entry(
 747                 parent, s->bus_dev, -1, size, align, type, is64);
 748             if (!entry)
 749                 return -1;
 750             dprintf(1, "PCI: secondary bus %d size %08llx type %s\n",
 751                       entry->dev->secondary_bus, size,
 752                       region_type_name[entry->type]);
 753         }
 754     }
 755     return 0;
 756 }
 757
 758
 759 /****************************************************************
 760  * BAR assignment
 761  ****************************************************************/
 762
 763 // Setup region bases (given the regions' size and alignment)
 764 static int pci_bios_init_root_regions_io(struct pci_bus *bus)
 765 {
 766     /*
 767      * QEMU I/O address space usage:
 768      *   0000 - 0fff    legacy isa, pci config, pci root bus, ...
 769      *   1000 - 9fff    free
 770      *   a000 - afff    hotplug (cpu, pci via acpi, i440fx/piix only)
 771      *   b000 - bfff    power management (PORT_ACPI_PM_BASE)
 772      *                  [ qemu 1.4+ implements pci config registers
 773      *                    properly so guests can place the registers
 774      *                    where they want, on older versions its fixed ]
 775      *   c000 - ffff    free, traditionally used for pci io
 776      */
 777     struct pci_region *r_io = &bus->r[PCI_REGION_TYPE_IO];
 778     u64 sum = pci_region_sum(r_io);
 779     if (sum < 0x4000) {
 780         /* traditional region is big enougth, use it */
 781         r_io->base = 0xc000;
 782     } else if (sum < pci_io_low_end - 0x1000) {
 783         /* use the larger region at 0x1000 */
 784         r_io->base = 0x1000;
 785     } else {
 786         /* not enouth io address space -> error out */
 787         return -1;
 788     }
 789     dprintf(1, "PCI: IO: %4llx - %4llx\n", r_io->base, r_io->base + sum - 1);
 790     return 0;
 791 }
 792
 793 static int pci_bios_init_root_regions_mem(struct pci_bus *bus)
 794 {
 795     struct pci_region *r_end = &bus->r[PCI_REGION_TYPE_PREFMEM];
 796     struct pci_region *r_start = &bus->r[PCI_REGION_TYPE_MEM];
 797
 798     if (pci_region_align(r_start) < pci_region_align(r_end)) {
 799         // Swap regions to improve alignment.
 800         r_end = r_start;
 801         r_start = &bus->r[PCI_REGION_TYPE_PREFMEM];
 802     }
 803     u64 sum = pci_region_sum(r_end);
 804     u64 align = pci_region_align(r_end);
 805     r_end->base = ALIGN_DOWN((pcimem_end - sum), align);
 806     sum = pci_region_sum(r_start);
 807     align = pci_region_align(r_start);
 808     r_start->base = ALIGN_DOWN((r_end->base - sum), align);
 809
 810     if ((r_start->base < pcimem_start) ||
 811          (r_start->base > pcimem_end))
 812         // Memory range requested is larger than available.
 813         return -1;
 814     return 0;
 815 }
 816
 817 #define PCI_IO_SHIFT            8
 818 #define PCI_MEMORY_SHIFT        16
 819 #define PCI_PREF_MEMORY_SHIFT   16
 820
 821 static void
 822 pci_region_map_one_entry(struct pci_region_entry *entry, u64 addr)
 823 {
 824     u16 bdf = entry->dev->bdf;
 825     if (entry->bar >= 0) {
 826         dprintf(1, "PCI: map device bdf=%02x:%02x.%x"
 827                 "  bar %d, addr %08llx, size %08llx [%s]\n",
 828                 pci_bdf_to_bus(bdf), pci_bdf_to_dev(bdf), pci_bdf_to_fn(bdf),
 829                 entry->bar, addr, entry->size, region_type_name[entry->type]);
 830
 831         pci_set_io_region_addr(entry->dev, entry->bar, addr, entry->is64);
 832         return;
 833     }
 834
 835     u64 limit = addr + entry->size - 1;
 836     if (entry->type == PCI_REGION_TYPE_IO) {
 837         pci_config_writeb(bdf, PCI_IO_BASE, addr >> PCI_IO_SHIFT);
 838         pci_config_writew(bdf, PCI_IO_BASE_UPPER16, 0);
 839         pci_config_writeb(bdf, PCI_IO_LIMIT, limit >> PCI_IO_SHIFT);
 840         pci_config_writew(bdf, PCI_IO_LIMIT_UPPER16, 0);
 841     }
 842     if (entry->type == PCI_REGION_TYPE_MEM) {
 843         pci_config_writew(bdf, PCI_MEMORY_BASE, addr >> PCI_MEMORY_SHIFT);
 844         pci_config_writew(bdf, PCI_MEMORY_LIMIT, limit >> PCI_MEMORY_SHIFT);
 845     }
 846     if (entry->type == PCI_REGION_TYPE_PREFMEM) {
 847         pci_config_writew(bdf, PCI_PREF_MEMORY_BASE, addr >> PCI_PREF_MEMORY_SHIFT);
 848         pci_config_writew(bdf, PCI_PREF_MEMORY_LIMIT, limit >> PCI_PREF_MEMORY_SHIFT);
 849         pci_config_writel(bdf, PCI_PREF_BASE_UPPER32, addr >> 32);
 850         pci_config_writel(bdf, PCI_PREF_LIMIT_UPPER32, limit >> 32);
 851     }
 852 }
 853
 854 static void pci_region_map_entries(struct pci_bus *busses, struct pci_region *r)
 855 {
 856     struct hlist_node *n;
 857     struct pci_region_entry *entry;
 858     hlist_for_each_entry_safe(entry, n, &r->list, node) {
 859         u64 addr = r->base;
 860         r->base += entry->size;
 861         if (entry->bar == -1)
 862             // Update bus base address if entry is a bridge region
 863             busses[entry->dev->secondary_bus].r[entry->type].base = addr;
 864         pci_region_map_one_entry(entry, addr);
 865         hlist_del(&entry->node);
 866         free(entry);
 867     }
 868 }
 869
 870 static void pci_bios_map_devices(struct pci_bus *busses)
 871 {
 872     if (pci_bios_init_root_regions_io(busses))
 873         panic("PCI: out of I/O address space\n");
 874
 875     dprintf(1, "PCI: 32: %016llx - %016llx\n", pcimem_start, pcimem_end);
 876     if (pci_bios_init_root_regions_mem(busses)) {
 877         struct pci_region r64_mem, r64_pref;
 878         r64_mem.list.first = NULL;
 879         r64_pref.list.first = NULL;
 880         pci_region_migrate_64bit_entries(&busses[0].r[PCI_REGION_TYPE_MEM],
 881                                          &r64_mem);
 882         pci_region_migrate_64bit_entries(&busses[0].r[PCI_REGION_TYPE_PREFMEM],
 883                                          &r64_pref);
 884
 885         if (pci_bios_init_root_regions_mem(busses))
 886             panic("PCI: out of 32bit address space\n");
 887
 888         u64 sum_mem = pci_region_sum(&r64_mem);
 889         u64 sum_pref = pci_region_sum(&r64_pref);
 890         u64 align_mem = pci_region_align(&r64_mem);
 891         u64 align_pref = pci_region_align(&r64_pref);
 892
 893         r64_mem.base = le64_to_cpu(romfile_loadint("etc/reserved-memory-end", 0));
 894         if (r64_mem.base < 0x100000000LL + RamSizeOver4G)
 895             r64_mem.base = 0x100000000LL + RamSizeOver4G;
 896         r64_mem.base = ALIGN(r64_mem.base, align_mem);
 897         r64_mem.base = ALIGN(r64_mem.base, (1LL<<30));    // 1G hugepage
 898         r64_pref.base = r64_mem.base + sum_mem;
 899         r64_pref.base = ALIGN(r64_pref.base, align_pref);
 900         r64_pref.base = ALIGN(r64_pref.base, (1LL<<30));  // 1G hugepage
 901         pcimem64_start = r64_mem.base;
 902         pcimem64_end = r64_pref.base + sum_pref;
 903         pcimem64_end = ALIGN(pcimem64_end, (1LL<<30));    // 1G hugepage
 904         dprintf(1, "PCI: 64: %016llx - %016llx\n", pcimem64_start, pcimem64_end);
 905
 906         pci_region_map_entries(busses, &r64_mem);
 907         pci_region_map_entries(busses, &r64_pref);
 908     } else {
 909         // no bars mapped high -> drop 64bit window (see dsdt)
 910         pcimem64_start = 0;
 911     }
 912     // Map regions on each device.
 913     int bus;
 914     for (bus = 0; bus<=MaxPCIBus; bus++) {
 915         int type;
 916         for (type = 0; type < PCI_REGION_TYPE_COUNT; type++)
 917             pci_region_map_entries(busses, &busses[bus].r[type]);
 918     }
 919 }
 920
 921
 922 /****************************************************************
 923  * Main setup code
 924  ****************************************************************/
 925
 926 void
 927 pci_setup(void)
 928 {
 929     if (!CONFIG_QEMU)
 930         return;
 931
 932     dprintf(3, "pci setup\n");
 933
 934     dprintf(1, "=== PCI bus & bridge init ===\n");
 935     if (pci_probe_host() != 0) {
 936         return;
 937     }
 938     pci_bios_init_bus();
 939
 940     dprintf(1, "=== PCI device probing ===\n");
 941     pci_probe_devices();
 942
 943     pcimem_start = RamSize;
 944     pci_bios_init_platform();
 945
 946     dprintf(1, "=== PCI new allocation pass #1 ===\n");
 947     struct pci_bus *busses = malloc_tmp(sizeof(*busses) * (MaxPCIBus + 1));
 948     if (!busses) {
 949         warn_noalloc();
 950         return;
 951     }
 952     memset(busses, 0, sizeof(*busses) * (MaxPCIBus + 1));
 953     if (pci_bios_check_devices(busses))
 954         return;
 955
 956     dprintf(1, "=== PCI new allocation pass #2 ===\n");
 957     pci_bios_map_devices(busses);
 958
 959     pci_bios_init_devices();
 960
 961     free(busses);
 962
 963     pci_enable_default_vga();
 964 }