arch/x86/pci/common.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *      Low-Level PCI Support for PC
   4  *
   5  *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
   6  */
   7
   8 #include <linux/sched.h>
   9 #include <linux/pci.h>
  10 #include <linux/pci-acpi.h>
  11 #include <linux/ioport.h>
  12 #include <linux/init.h>
  13 #include <linux/dmi.h>
  14 #include <linux/slab.h>
  15
  16 #include <asm/acpi.h>
  17 #include <asm/segment.h>
  18 #include <asm/io.h>
  19 #include <asm/smp.h>
  20 #include <asm/pci_x86.h>
  21 #include <asm/setup.h>
  22 #include <asm/irqdomain.h>
  23
  24 unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
  25                                 PCI_PROBE_MMCONF;
  26
  27 static int pci_bf_sort;
  28 int pci_routeirq;
  29 int noioapicquirk;
  30 #ifdef CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS
  31 int noioapicreroute = 0;
  32 #else
  33 int noioapicreroute = 1;
  34 #endif
  35 int pcibios_last_bus = -1;
  36 unsigned long pirq_table_addr;
  37 const struct pci_raw_ops *__read_mostly raw_pci_ops;
  38 const struct pci_raw_ops *__read_mostly raw_pci_ext_ops;
  39
  40 int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
  41                                                 int reg, int len, u32 *val)
  42 {
  43         if (domain == 0 && reg < 256 && raw_pci_ops)
  44                 return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
  45         if (raw_pci_ext_ops)
  46                 return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
  47         return -EINVAL;
  48 }
  49
  50 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
  51                                                 int reg, int len, u32 val)
  52 {
  53         if (domain == 0 && reg < 256 && raw_pci_ops)
  54                 return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
  55         if (raw_pci_ext_ops)
  56                 return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
  57         return -EINVAL;
  58 }
  59
  60 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
  61 {
  62         return raw_pci_read(pci_domain_nr(bus), bus->number,
  63                                  devfn, where, size, value);
  64 }
  65
  66 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
  67 {
  68         return raw_pci_write(pci_domain_nr(bus), bus->number,
  69                                   devfn, where, size, value);
  70 }
  71
  72 struct pci_ops pci_root_ops = {
  73         .read = pci_read,
  74         .write = pci_write,
  75 };
  76
  77 /*
  78  * This interrupt-safe spinlock protects all accesses to PCI configuration
  79  * space, except for the mmconfig (ECAM) based operations.
  80  */
  81 DEFINE_RAW_SPINLOCK(pci_config_lock);
  82
  83 static int __init can_skip_ioresource_align(const struct dmi_system_id *d)
  84 {
  85         pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
  86         printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
  87         return 0;
  88 }
  89
  90 static const struct dmi_system_id can_skip_pciprobe_dmi_table[] __initconst = {
  91 /*
  92  * Systems where PCI IO resource ISA alignment can be skipped
  93  * when the ISA enable bit in the bridge control is not set
  94  */
  95         {
  96                 .callback = can_skip_ioresource_align,
  97                 .ident = "IBM System x3800",
  98                 .matches = {
  99                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 100                         DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
 101                 },
 102         },
 103         {
 104                 .callback = can_skip_ioresource_align,
 105                 .ident = "IBM System x3850",
 106                 .matches = {
 107                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 108                         DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
 109                 },
 110         },
 111         {
 112                 .callback = can_skip_ioresource_align,
 113                 .ident = "IBM System x3950",
 114                 .matches = {
 115                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 116                         DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
 117                 },
 118         },
 119         {}
 120 };
 121
 122 void __init dmi_check_skip_isa_align(void)
 123 {
 124         dmi_check_system(can_skip_pciprobe_dmi_table);
 125 }
 126
 127 static void pcibios_fixup_device_resources(struct pci_dev *dev)
 128 {
 129         struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
 130         struct resource *bar_r;
 131         int bar;
 132
 133         if (pci_probe & PCI_NOASSIGN_BARS) {
 134                 /*
 135                 * If the BIOS did not assign the BAR, zero out the
 136                 * resource so the kernel doesn't attempt to assign
 137                 * it later on in pci_assign_unassigned_resources
 138                 */
 139                 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 140                         bar_r = &dev->resource[bar];
 141                         if (bar_r->start == 0 && bar_r->end != 0) {
 142                                 bar_r->flags = 0;
 143                                 bar_r->end = 0;
 144                         }
 145                 }
 146         }
 147
 148         if (pci_probe & PCI_NOASSIGN_ROMS) {
 149                 if (rom_r->parent)
 150                         return;
 151                 if (rom_r->start) {
 152                         /* we deal with BIOS assigned ROM later */
 153                         return;
 154                 }
 155                 rom_r->start = rom_r->end = rom_r->flags = 0;
 156         }
 157 }
 158
 159 /*
 160  *  Called after each bus is probed, but before its children
 161  *  are examined.
 162  */
 163
 164 void pcibios_fixup_bus(struct pci_bus *b)
 165 {
 166         struct pci_dev *dev;
 167
 168         pci_read_bridge_bases(b);
 169         list_for_each_entry(dev, &b->devices, bus_list)
 170                 pcibios_fixup_device_resources(dev);
 171 }
 172
 173 void pcibios_add_bus(struct pci_bus *bus)
 174 {
 175         acpi_pci_add_bus(bus);
 176 }
 177
 178 void pcibios_remove_bus(struct pci_bus *bus)
 179 {
 180         acpi_pci_remove_bus(bus);
 181 }
 182
 183 /*
 184  * Only use DMI information to set this if nothing was passed
 185  * on the kernel command line (which was parsed earlier).
 186  */
 187
 188 static int __init set_bf_sort(const struct dmi_system_id *d)
 189 {
 190         if (pci_bf_sort == pci_bf_sort_default) {
 191                 pci_bf_sort = pci_dmi_bf;
 192                 printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
 193         }
 194         return 0;
 195 }
 196
 197 static void __init read_dmi_type_b1(const struct dmi_header *dm,
 198                                     void *private_data)
 199 {
 200         u8 *data = (u8 *)dm + 4;
 201
 202         if (dm->type != 0xB1)
 203                 return;
 204         if ((((*(u32 *)data) >> 9) & 0x03) == 0x01)
 205                 set_bf_sort((const struct dmi_system_id *)private_data);
 206 }
 207
 208 static int __init find_sort_method(const struct dmi_system_id *d)
 209 {
 210         dmi_walk(read_dmi_type_b1, (void *)d);
 211         return 0;
 212 }
 213
 214 /*
 215  * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
 216  */
 217 #ifdef __i386__
 218 static int __init assign_all_busses(const struct dmi_system_id *d)
 219 {
 220         pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 221         printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
 222                         " (pci=assign-busses)\n", d->ident);
 223         return 0;
 224 }
 225 #endif
 226
 227 static int __init set_scan_all(const struct dmi_system_id *d)
 228 {
 229         printk(KERN_INFO "PCI: %s detected, enabling pci=pcie_scan_all\n",
 230                d->ident);
 231         pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
 232         return 0;
 233 }
 234
 235 static const struct dmi_system_id pciprobe_dmi_table[] __initconst = {
 236 #ifdef __i386__
 237 /*
 238  * Laptops which need pci=assign-busses to see Cardbus cards
 239  */
 240         {
 241                 .callback = assign_all_busses,
 242                 .ident = "Samsung X20 Laptop",
 243                 .matches = {
 244                         DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
 245                         DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
 246                 },
 247         },
 248 #endif          /* __i386__ */
 249         {
 250                 .callback = set_bf_sort,
 251                 .ident = "Dell PowerEdge 1950",
 252                 .matches = {
 253                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 254                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
 255                 },
 256         },
 257         {
 258                 .callback = set_bf_sort,
 259                 .ident = "Dell PowerEdge 1955",
 260                 .matches = {
 261                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 262                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
 263                 },
 264         },
 265         {
 266                 .callback = set_bf_sort,
 267                 .ident = "Dell PowerEdge 2900",
 268                 .matches = {
 269                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 270                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
 271                 },
 272         },
 273         {
 274                 .callback = set_bf_sort,
 275                 .ident = "Dell PowerEdge 2950",
 276                 .matches = {
 277                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 278                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
 279                 },
 280         },
 281         {
 282                 .callback = set_bf_sort,
 283                 .ident = "Dell PowerEdge R900",
 284                 .matches = {
 285                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 286                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
 287                 },
 288         },
 289         {
 290                 .callback = find_sort_method,
 291                 .ident = "Dell System",
 292                 .matches = {
 293                         DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc"),
 294                 },
 295         },
 296         {
 297                 .callback = set_bf_sort,
 298                 .ident = "HP ProLiant BL20p G3",
 299                 .matches = {
 300                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 301                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
 302                 },
 303         },
 304         {
 305                 .callback = set_bf_sort,
 306                 .ident = "HP ProLiant BL20p G4",
 307                 .matches = {
 308                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 309                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
 310                 },
 311         },
 312         {
 313                 .callback = set_bf_sort,
 314                 .ident = "HP ProLiant BL30p G1",
 315                 .matches = {
 316                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 317                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
 318                 },
 319         },
 320         {
 321                 .callback = set_bf_sort,
 322                 .ident = "HP ProLiant BL25p G1",
 323                 .matches = {
 324                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 325                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
 326                 },
 327         },
 328         {
 329                 .callback = set_bf_sort,
 330                 .ident = "HP ProLiant BL35p G1",
 331                 .matches = {
 332                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 333                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
 334                 },
 335         },
 336         {
 337                 .callback = set_bf_sort,
 338                 .ident = "HP ProLiant BL45p G1",
 339                 .matches = {
 340                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 341                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
 342                 },
 343         },
 344         {
 345                 .callback = set_bf_sort,
 346                 .ident = "HP ProLiant BL45p G2",
 347                 .matches = {
 348                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 349                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
 350                 },
 351         },
 352         {
 353                 .callback = set_bf_sort,
 354                 .ident = "HP ProLiant BL460c G1",
 355                 .matches = {
 356                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 357                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
 358                 },
 359         },
 360         {
 361                 .callback = set_bf_sort,
 362                 .ident = "HP ProLiant BL465c G1",
 363                 .matches = {
 364                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 365                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
 366                 },
 367         },
 368         {
 369                 .callback = set_bf_sort,
 370                 .ident = "HP ProLiant BL480c G1",
 371                 .matches = {
 372                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 373                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
 374                 },
 375         },
 376         {
 377                 .callback = set_bf_sort,
 378                 .ident = "HP ProLiant BL685c G1",
 379                 .matches = {
 380                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 381                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
 382                 },
 383         },
 384         {
 385                 .callback = set_bf_sort,
 386                 .ident = "HP ProLiant DL360",
 387                 .matches = {
 388                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 389                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
 390                 },
 391         },
 392         {
 393                 .callback = set_bf_sort,
 394                 .ident = "HP ProLiant DL380",
 395                 .matches = {
 396                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 397                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
 398                 },
 399         },
 400 #ifdef __i386__
 401         {
 402                 .callback = assign_all_busses,
 403                 .ident = "Compaq EVO N800c",
 404                 .matches = {
 405                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
 406                         DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
 407                 },
 408         },
 409 #endif
 410         {
 411                 .callback = set_bf_sort,
 412                 .ident = "HP ProLiant DL385 G2",
 413                 .matches = {
 414                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 415                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
 416                 },
 417         },
 418         {
 419                 .callback = set_bf_sort,
 420                 .ident = "HP ProLiant DL585 G2",
 421                 .matches = {
 422                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 423                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
 424                 },
 425         },
 426         {
 427                 .callback = set_scan_all,
 428                 .ident = "Stratus/NEC ftServer",
 429                 .matches = {
 430                         DMI_MATCH(DMI_SYS_VENDOR, "Stratus"),
 431                         DMI_MATCH(DMI_PRODUCT_NAME, "ftServer"),
 432                 },
 433         },
 434         {
 435                 .callback = set_scan_all,
 436                 .ident = "Stratus/NEC ftServer",
 437                 .matches = {
 438                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
 439                         DMI_MATCH(DMI_PRODUCT_NAME, "Express5800/R32"),
 440                 },
 441         },
 442         {
 443                 .callback = set_scan_all,
 444                 .ident = "Stratus/NEC ftServer",
 445                 .matches = {
 446                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
 447                         DMI_MATCH(DMI_PRODUCT_NAME, "Express5800/R31"),
 448                 },
 449         },
 450         {}
 451 };
 452
 453 void __init dmi_check_pciprobe(void)
 454 {
 455         dmi_check_system(pciprobe_dmi_table);
 456 }
 457
 458 void pcibios_scan_root(int busnum)
 459 {
 460         struct pci_bus *bus;
 461         struct pci_sysdata *sd;
 462         LIST_HEAD(resources);
 463
 464         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 465         if (!sd) {
 466                 printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busnum);
 467                 return;
 468         }
 469         sd->node = x86_pci_root_bus_node(busnum);
 470         x86_pci_root_bus_resources(busnum, &resources);
 471         printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
 472         bus = pci_scan_root_bus(NULL, busnum, &pci_root_ops, sd, &resources);
 473         if (!bus) {
 474                 pci_free_resource_list(&resources);
 475                 kfree(sd);
 476                 return;
 477         }
 478         pci_bus_add_devices(bus);
 479 }
 480
 481 void __init pcibios_set_cache_line_size(void)
 482 {
 483         struct cpuinfo_x86 *c = &boot_cpu_data;
 484
 485         /*
 486          * Set PCI cacheline size to that of the CPU if the CPU has reported it.
 487          * (For older CPUs that don't support cpuid, we se it to 32 bytes
 488          * It's also good for 386/486s (which actually have 16)
 489          * as quite a few PCI devices do not support smaller values.
 490          */
 491         if (c->x86_clflush_size > 0) {
 492                 pci_dfl_cache_line_size = c->x86_clflush_size >> 2;
 493                 printk(KERN_DEBUG "PCI: pci_cache_line_size set to %d bytes\n",
 494                         pci_dfl_cache_line_size << 2);
 495         } else {
 496                 pci_dfl_cache_line_size = 32 >> 2;
 497                 printk(KERN_DEBUG "PCI: Unknown cacheline size. Setting to 32 bytes\n");
 498         }
 499 }
 500
 501 int __init pcibios_init(void)
 502 {
 503         if (!raw_pci_ops && !raw_pci_ext_ops) {
 504                 printk(KERN_WARNING "PCI: System does not support PCI\n");
 505                 return 0;
 506         }
 507
 508         pcibios_set_cache_line_size();
 509         pcibios_resource_survey();
 510
 511         if (pci_bf_sort >= pci_force_bf)
 512                 pci_sort_breadthfirst();
 513         return 0;
 514 }
 515
 516 char *__init pcibios_setup(char *str)
 517 {
 518         if (!strcmp(str, "off")) {
 519                 pci_probe = 0;
 520                 return NULL;
 521         } else if (!strcmp(str, "bfsort")) {
 522                 pci_bf_sort = pci_force_bf;
 523                 return NULL;
 524         } else if (!strcmp(str, "nobfsort")) {
 525                 pci_bf_sort = pci_force_nobf;
 526                 return NULL;
 527         }
 528 #ifdef CONFIG_PCI_BIOS
 529         else if (!strcmp(str, "bios")) {
 530                 pci_probe = PCI_PROBE_BIOS;
 531                 return NULL;
 532         } else if (!strcmp(str, "nobios")) {
 533                 pci_probe &= ~PCI_PROBE_BIOS;
 534                 return NULL;
 535         } else if (!strcmp(str, "biosirq")) {
 536                 pci_probe |= PCI_BIOS_IRQ_SCAN;
 537                 return NULL;
 538         } else if (!strncmp(str, "pirqaddr=", 9)) {
 539                 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
 540                 return NULL;
 541         }
 542 #endif
 543 #ifdef CONFIG_PCI_DIRECT
 544         else if (!strcmp(str, "conf1")) {
 545                 pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
 546                 return NULL;
 547         }
 548         else if (!strcmp(str, "conf2")) {
 549                 pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
 550                 return NULL;
 551         }
 552 #endif
 553 #ifdef CONFIG_PCI_MMCONFIG
 554         else if (!strcmp(str, "nommconf")) {
 555                 pci_probe &= ~PCI_PROBE_MMCONF;
 556                 return NULL;
 557         }
 558         else if (!strcmp(str, "check_enable_amd_mmconf")) {
 559                 pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
 560                 return NULL;
 561         }
 562 #endif
 563         else if (!strcmp(str, "noacpi")) {
 564                 acpi_noirq_set();
 565                 return NULL;
 566         }
 567         else if (!strcmp(str, "noearly")) {
 568                 pci_probe |= PCI_PROBE_NOEARLY;
 569                 return NULL;
 570         }
 571         else if (!strcmp(str, "usepirqmask")) {
 572                 pci_probe |= PCI_USE_PIRQ_MASK;
 573                 return NULL;
 574         } else if (!strncmp(str, "irqmask=", 8)) {
 575                 pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
 576                 return NULL;
 577         } else if (!strncmp(str, "lastbus=", 8)) {
 578                 pcibios_last_bus = simple_strtol(str+8, NULL, 0);
 579                 return NULL;
 580         } else if (!strcmp(str, "rom")) {
 581                 pci_probe |= PCI_ASSIGN_ROMS;
 582                 return NULL;
 583         } else if (!strcmp(str, "norom")) {
 584                 pci_probe |= PCI_NOASSIGN_ROMS;
 585                 return NULL;
 586         } else if (!strcmp(str, "nobar")) {
 587                 pci_probe |= PCI_NOASSIGN_BARS;
 588                 return NULL;
 589         } else if (!strcmp(str, "assign-busses")) {
 590                 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 591                 return NULL;
 592         } else if (!strcmp(str, "use_crs")) {
 593                 pci_probe |= PCI_USE__CRS;
 594                 return NULL;
 595         } else if (!strcmp(str, "nocrs")) {
 596                 pci_probe |= PCI_ROOT_NO_CRS;
 597                 return NULL;
 598         } else if (!strcmp(str, "use_e820")) {
 599                 pci_probe |= PCI_USE_E820;
 600                 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 601                 return NULL;
 602         } else if (!strcmp(str, "no_e820")) {
 603                 pci_probe |= PCI_NO_E820;
 604                 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
 605                 return NULL;
 606 #ifdef CONFIG_PHYS_ADDR_T_64BIT
 607         } else if (!strcmp(str, "big_root_window")) {
 608                 pci_probe |= PCI_BIG_ROOT_WINDOW;
 609                 return NULL;
 610 #endif
 611         } else if (!strcmp(str, "routeirq")) {
 612                 pci_routeirq = 1;
 613                 return NULL;
 614         } else if (!strcmp(str, "skip_isa_align")) {
 615                 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
 616                 return NULL;
 617         } else if (!strcmp(str, "noioapicquirk")) {
 618                 noioapicquirk = 1;
 619                 return NULL;
 620         } else if (!strcmp(str, "ioapicreroute")) {
 621                 if (noioapicreroute != -1)
 622                         noioapicreroute = 0;
 623                 return NULL;
 624         } else if (!strcmp(str, "noioapicreroute")) {
 625                 if (noioapicreroute != -1)
 626                         noioapicreroute = 1;
 627                 return NULL;
 628         }
 629         return str;
 630 }
 631
 632 unsigned int pcibios_assign_all_busses(void)
 633 {
 634         return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
 635 }
 636
 637 static void set_dev_domain_options(struct pci_dev *pdev)
 638 {
 639         if (is_vmd(pdev->bus))
 640                 pdev->hotplug_user_indicators = 1;
 641 }
 642
 643 int pcibios_device_add(struct pci_dev *dev)
 644 {
 645         struct pci_setup_rom *rom;
 646         struct irq_domain *msidom;
 647         struct setup_data *data;
 648         u64 pa_data;
 649
 650         pa_data = boot_params.hdr.setup_data;
 651         while (pa_data) {
 652                 data = memremap(pa_data, sizeof(*rom), MEMREMAP_WB);
 653                 if (!data)
 654                         return -ENOMEM;
 655
 656                 if (data->type == SETUP_PCI) {
 657                         rom = (struct pci_setup_rom *)data;
 658
 659                         if ((pci_domain_nr(dev->bus) == rom->segment) &&
 660                             (dev->bus->number == rom->bus) &&
 661                             (PCI_SLOT(dev->devfn) == rom->device) &&
 662                             (PCI_FUNC(dev->devfn) == rom->function) &&
 663                             (dev->vendor == rom->vendor) &&
 664                             (dev->device == rom->devid)) {
 665                                 dev->rom = pa_data +
 666                                       offsetof(struct pci_setup_rom, romdata);
 667                                 dev->romlen = rom->pcilen;
 668                         }
 669                 }
 670                 pa_data = data->next;
 671                 memunmap(data);
 672         }
 673         set_dev_domain_options(dev);
 674
 675         /*
 676          * Setup the initial MSI domain of the device. If the underlying
 677          * bus has a PCI/MSI irqdomain associated use the bus domain,
 678          * otherwise set the default domain. This ensures that special irq
 679          * domains e.g. VMD are preserved. The default ensures initial
 680          * operation if irq remapping is not active. If irq remapping is
 681          * active it will overwrite the domain pointer when the device is
 682          * associated to a remapping domain.
 683          */
 684         msidom = dev_get_msi_domain(&dev->bus->dev);
 685         if (!msidom)
 686                 msidom = x86_pci_msi_default_domain;
 687         dev_set_msi_domain(&dev->dev, msidom);
 688         return 0;
 689 }
 690
 691 int pcibios_enable_device(struct pci_dev *dev, int mask)
 692 {
 693         int err;
 694
 695         if ((err = pci_enable_resources(dev, mask)) < 0)
 696                 return err;
 697
 698         if (!pci_dev_msi_enabled(dev))
 699                 return pcibios_enable_irq(dev);
 700         return 0;
 701 }
 702
 703 void pcibios_disable_device (struct pci_dev *dev)
 704 {
 705         if (!pci_dev_msi_enabled(dev) && pcibios_disable_irq)
 706                 pcibios_disable_irq(dev);
 707 }
 708
 709 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
 710 void pcibios_release_device(struct pci_dev *dev)
 711 {
 712         if (atomic_dec_return(&dev->enable_cnt) >= 0)
 713                 pcibios_disable_device(dev);
 714
 715 }
 716 #endif
 717
 718 int pci_ext_cfg_avail(void)
 719 {
 720         if (raw_pci_ext_ops)
 721                 return 1;
 722         else
 723                 return 0;
 724 }
 725
 726 #if IS_ENABLED(CONFIG_VMD)
 727 struct pci_dev *pci_real_dma_dev(struct pci_dev *dev)
 728 {
 729         if (is_vmd(dev->bus))
 730                 return to_pci_sysdata(dev->bus)->vmd_dev;
 731
 732         return dev;
 733 }
 734 #endif