SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/x86/pci/common.c

   1 /*
   2  *      Low-Level PCI Support for PC
   3  *
   4  *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <linux/sched.h>
   8 #include <linux/pci.h>
   9 #include <linux/ioport.h>
  10 #include <linux/init.h>
  11 #include <linux/dmi.h>
  12 #include <linux/slab.h>
  13
  14 #include <asm/acpi.h>
  15 #include <asm/segment.h>
  16 #include <asm/io.h>
  17 #include <asm/smp.h>
  18 #include <asm/pci_x86.h>
  19
  20 unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
  21                                 PCI_PROBE_MMCONF;
  22
  23 unsigned int pci_early_dump_regs;
  24 static int pci_bf_sort;
  25 int pci_routeirq;
  26 int noioapicquirk;
  27 #ifdef CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS
  28 int noioapicreroute = 0;
  29 #else
  30 int noioapicreroute = 1;
  31 #endif
  32 int pcibios_last_bus = -1;
  33 unsigned long pirq_table_addr;
  34 struct pci_bus *pci_root_bus;
  35 struct pci_raw_ops *raw_pci_ops;
  36 struct pci_raw_ops *raw_pci_ext_ops;
  37
  38 int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
  39                                                 int reg, int len, u32 *val)
  40 {
  41         if (domain == 0 && reg < 256 && raw_pci_ops)
  42                 return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
  43         if (raw_pci_ext_ops)
  44                 return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
  45         return -EINVAL;
  46 }
  47
  48 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
  49                                                 int reg, int len, u32 val)
  50 {
  51         if (domain == 0 && reg < 256 && raw_pci_ops)
  52                 return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
  53         if (raw_pci_ext_ops)
  54                 return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
  55         return -EINVAL;
  56 }
  57
  58 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
  59 {
  60         return raw_pci_read(pci_domain_nr(bus), bus->number,
  61                                  devfn, where, size, value);
  62 }
  63
  64 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
  65 {
  66         return raw_pci_write(pci_domain_nr(bus), bus->number,
  67                                   devfn, where, size, value);
  68 }
  69
  70 struct pci_ops pci_root_ops = {
  71         .read = pci_read,
  72         .write = pci_write,
  73 };
  74
  75 /*
  76  * This interrupt-safe spinlock protects all accesses to PCI
  77  * configuration space.
  78  */
  79 DEFINE_SPINLOCK(pci_config_lock);
  80
  81 static int __devinit can_skip_ioresource_align(const struct dmi_system_id *d)
  82 {
  83         pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
  84         printk(KERN_INFO "PCI: %s detected, can skip ISA alignment\n", d->ident);
  85         return 0;
  86 }
  87
  88 static const struct dmi_system_id can_skip_pciprobe_dmi_table[] __devinitconst = {
  89 /*
  90  * Systems where PCI IO resource ISA alignment can be skipped
  91  * when the ISA enable bit in the bridge control is not set
  92  */
  93         {
  94                 .callback = can_skip_ioresource_align,
  95                 .ident = "IBM System x3800",
  96                 .matches = {
  97                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
  98                         DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
  99                 },
 100         },
 101         {
 102                 .callback = can_skip_ioresource_align,
 103                 .ident = "IBM System x3850",
 104                 .matches = {
 105                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 106                         DMI_MATCH(DMI_PRODUCT_NAME, "x3850"),
 107                 },
 108         },
 109         {
 110                 .callback = can_skip_ioresource_align,
 111                 .ident = "IBM System x3950",
 112                 .matches = {
 113                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
 114                         DMI_MATCH(DMI_PRODUCT_NAME, "x3950"),
 115                 },
 116         },
 117         {}
 118 };
 119
 120 void __init dmi_check_skip_isa_align(void)
 121 {
 122         dmi_check_system(can_skip_pciprobe_dmi_table);
 123 }
 124
 125 static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
 126 {
 127         struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
 128
 129         if (pci_probe & PCI_NOASSIGN_ROMS) {
 130                 if (rom_r->parent)
 131                         return;
 132                 if (rom_r->start) {
 133                         /* we deal with BIOS assigned ROM later */
 134                         return;
 135                 }
 136                 rom_r->start = rom_r->end = rom_r->flags = 0;
 137         }
 138 }
 139
 140 /*
 141  *  Called after each bus is probed, but before its children
 142  *  are examined.
 143  */
 144
 145 void __devinit pcibios_fixup_bus(struct pci_bus *b)
 146 {
 147         struct pci_dev *dev;
 148
 149         /* root bus? */
 150         if (!b->parent)
 151                 x86_pci_root_bus_res_quirks(b);
 152         pci_read_bridge_bases(b);
 153         list_for_each_entry(dev, &b->devices, bus_list)
 154                 pcibios_fixup_device_resources(dev);
 155 }
 156
 157 /*
 158  * Only use DMI information to set this if nothing was passed
 159  * on the kernel command line (which was parsed earlier).
 160  */
 161
 162 static int __devinit set_bf_sort(const struct dmi_system_id *d)
 163 {
 164         if (pci_bf_sort == pci_bf_sort_default) {
 165                 pci_bf_sort = pci_dmi_bf;
 166                 printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
 167         }
 168         return 0;
 169 }
 170
 171 /*
 172  * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
 173  */
 174 #ifdef __i386__
 175 static int __devinit assign_all_busses(const struct dmi_system_id *d)
 176 {
 177         pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 178         printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
 179                         " (pci=assign-busses)\n", d->ident);
 180         return 0;
 181 }
 182 #endif
 183
 184 static const struct dmi_system_id __devinitconst pciprobe_dmi_table[] = {
 185 #ifdef __i386__
 186 /*
 187  * Laptops which need pci=assign-busses to see Cardbus cards
 188  */
 189         {
 190                 .callback = assign_all_busses,
 191                 .ident = "Samsung X20 Laptop",
 192                 .matches = {
 193                         DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
 194                         DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
 195                 },
 196         },
 197 #endif          /* __i386__ */
 198         {
 199                 .callback = set_bf_sort,
 200                 .ident = "Dell PowerEdge 1950",
 201                 .matches = {
 202                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 203                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
 204                 },
 205         },
 206         {
 207                 .callback = set_bf_sort,
 208                 .ident = "Dell PowerEdge 1955",
 209                 .matches = {
 210                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 211                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
 212                 },
 213         },
 214         {
 215                 .callback = set_bf_sort,
 216                 .ident = "Dell PowerEdge 2900",
 217                 .matches = {
 218                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 219                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
 220                 },
 221         },
 222         {
 223                 .callback = set_bf_sort,
 224                 .ident = "Dell PowerEdge 2950",
 225                 .matches = {
 226                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 227                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
 228                 },
 229         },
 230         {
 231                 .callback = set_bf_sort,
 232                 .ident = "Dell PowerEdge R900",
 233                 .matches = {
 234                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 235                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
 236                 },
 237         },
 238         {
 239                 .callback = set_bf_sort,
 240                 .ident = "HP ProLiant BL20p G3",
 241                 .matches = {
 242                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 243                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
 244                 },
 245         },
 246         {
 247                 .callback = set_bf_sort,
 248                 .ident = "HP ProLiant BL20p G4",
 249                 .matches = {
 250                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 251                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
 252                 },
 253         },
 254         {
 255                 .callback = set_bf_sort,
 256                 .ident = "HP ProLiant BL30p G1",
 257                 .matches = {
 258                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 259                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
 260                 },
 261         },
 262         {
 263                 .callback = set_bf_sort,
 264                 .ident = "HP ProLiant BL25p G1",
 265                 .matches = {
 266                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 267                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
 268                 },
 269         },
 270         {
 271                 .callback = set_bf_sort,
 272                 .ident = "HP ProLiant BL35p G1",
 273                 .matches = {
 274                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 275                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
 276                 },
 277         },
 278         {
 279                 .callback = set_bf_sort,
 280                 .ident = "HP ProLiant BL45p G1",
 281                 .matches = {
 282                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 283                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
 284                 },
 285         },
 286         {
 287                 .callback = set_bf_sort,
 288                 .ident = "HP ProLiant BL45p G2",
 289                 .matches = {
 290                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 291                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
 292                 },
 293         },
 294         {
 295                 .callback = set_bf_sort,
 296                 .ident = "HP ProLiant BL460c G1",
 297                 .matches = {
 298                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 299                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
 300                 },
 301         },
 302         {
 303                 .callback = set_bf_sort,
 304                 .ident = "HP ProLiant BL465c G1",
 305                 .matches = {
 306                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 307                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
 308                 },
 309         },
 310         {
 311                 .callback = set_bf_sort,
 312                 .ident = "HP ProLiant BL480c G1",
 313                 .matches = {
 314                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 315                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
 316                 },
 317         },
 318         {
 319                 .callback = set_bf_sort,
 320                 .ident = "HP ProLiant BL685c G1",
 321                 .matches = {
 322                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 323                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
 324                 },
 325         },
 326         {
 327                 .callback = set_bf_sort,
 328                 .ident = "HP ProLiant DL360",
 329                 .matches = {
 330                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 331                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL360"),
 332                 },
 333         },
 334         {
 335                 .callback = set_bf_sort,
 336                 .ident = "HP ProLiant DL380",
 337                 .matches = {
 338                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 339                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL380"),
 340                 },
 341         },
 342 #ifdef __i386__
 343         {
 344                 .callback = assign_all_busses,
 345                 .ident = "Compaq EVO N800c",
 346                 .matches = {
 347                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
 348                         DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
 349                 },
 350         },
 351 #endif
 352         {
 353                 .callback = set_bf_sort,
 354                 .ident = "HP ProLiant DL385 G2",
 355                 .matches = {
 356                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 357                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
 358                 },
 359         },
 360         {
 361                 .callback = set_bf_sort,
 362                 .ident = "HP ProLiant DL585 G2",
 363                 .matches = {
 364                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 365                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
 366                 },
 367         },
 368         {}
 369 };
 370
 371 void __init dmi_check_pciprobe(void)
 372 {
 373         dmi_check_system(pciprobe_dmi_table);
 374 }
 375
 376 struct pci_bus * __devinit pcibios_scan_root(int busnum)
 377 {
 378         struct pci_bus *bus = NULL;
 379         struct pci_sysdata *sd;
 380
 381         while ((bus = pci_find_next_bus(bus)) != NULL) {
 382                 if (bus->number == busnum) {
 383                         /* Already scanned */
 384                         return bus;
 385                 }
 386         }
 387
 388         /* Allocate per-root-bus (not per bus) arch-specific data.
 389          * TODO: leak; this memory is never freed.
 390          * It's arguable whether it's worth the trouble to care.
 391          */
 392         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 393         if (!sd) {
 394                 printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
 395                 return NULL;
 396         }
 397
 398         sd->node = get_mp_bus_to_node(busnum);
 399
 400         printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
 401         bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
 402         if (!bus)
 403                 kfree(sd);
 404
 405         return bus;
 406 }
 407
 408 int __init pcibios_init(void)
 409 {
 410         struct cpuinfo_x86 *c = &boot_cpu_data;
 411
 412         if (!raw_pci_ops) {
 413                 printk(KERN_WARNING "PCI: System does not support PCI\n");
 414                 return 0;
 415         }
 416
 417         /*
 418          * Set PCI cacheline size to that of the CPU if the CPU has reported it.
 419          * (For older CPUs that don't support cpuid, we se it to 32 bytes
 420          * It's also good for 386/486s (which actually have 16)
 421          * as quite a few PCI devices do not support smaller values.
 422          */
 423         if (c->x86_clflush_size > 0) {
 424                 pci_dfl_cache_line_size = c->x86_clflush_size >> 2;
 425                 printk(KERN_DEBUG "PCI: pci_cache_line_size set to %d bytes\n",
 426                         pci_dfl_cache_line_size << 2);
 427         } else {
 428                 pci_dfl_cache_line_size = 32 >> 2;
 429                 printk(KERN_DEBUG "PCI: Unknown cacheline size. Setting to 32 bytes\n");
 430         }
 431
 432         pcibios_resource_survey();
 433
 434         if (pci_bf_sort >= pci_force_bf)
 435                 pci_sort_breadthfirst();
 436         return 0;
 437 }
 438
 439 char * __devinit  pcibios_setup(char *str)
 440 {
 441         if (!strcmp(str, "off")) {
 442                 pci_probe = 0;
 443                 return NULL;
 444         } else if (!strcmp(str, "bfsort")) {
 445                 pci_bf_sort = pci_force_bf;
 446                 return NULL;
 447         } else if (!strcmp(str, "nobfsort")) {
 448                 pci_bf_sort = pci_force_nobf;
 449                 return NULL;
 450         }
 451 #ifdef CONFIG_PCI_BIOS
 452         else if (!strcmp(str, "bios")) {
 453                 pci_probe = PCI_PROBE_BIOS;
 454                 return NULL;
 455         } else if (!strcmp(str, "nobios")) {
 456                 pci_probe &= ~PCI_PROBE_BIOS;
 457                 return NULL;
 458         } else if (!strcmp(str, "biosirq")) {
 459                 pci_probe |= PCI_BIOS_IRQ_SCAN;
 460                 return NULL;
 461         } else if (!strncmp(str, "pirqaddr=", 9)) {
 462                 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
 463                 return NULL;
 464         }
 465 #endif
 466 #ifdef CONFIG_PCI_DIRECT
 467         else if (!strcmp(str, "conf1")) {
 468                 pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
 469                 return NULL;
 470         }
 471         else if (!strcmp(str, "conf2")) {
 472                 pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
 473                 return NULL;
 474         }
 475 #endif
 476 #ifdef CONFIG_PCI_MMCONFIG
 477         else if (!strcmp(str, "nommconf")) {
 478                 pci_probe &= ~PCI_PROBE_MMCONF;
 479                 return NULL;
 480         }
 481         else if (!strcmp(str, "check_enable_amd_mmconf")) {
 482                 pci_probe |= PCI_CHECK_ENABLE_AMD_MMCONF;
 483                 return NULL;
 484         }
 485 #endif
 486         else if (!strcmp(str, "noacpi")) {
 487                 acpi_noirq_set();
 488                 return NULL;
 489         }
 490         else if (!strcmp(str, "noearly")) {
 491                 pci_probe |= PCI_PROBE_NOEARLY;
 492                 return NULL;
 493         }
 494 #ifndef CONFIG_X86_VISWS
 495         else if (!strcmp(str, "usepirqmask")) {
 496                 pci_probe |= PCI_USE_PIRQ_MASK;
 497                 return NULL;
 498         } else if (!strncmp(str, "irqmask=", 8)) {
 499                 pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
 500                 return NULL;
 501         } else if (!strncmp(str, "lastbus=", 8)) {
 502                 pcibios_last_bus = simple_strtol(str+8, NULL, 0);
 503                 return NULL;
 504         }
 505 #endif
 506         else if (!strcmp(str, "rom")) {
 507                 pci_probe |= PCI_ASSIGN_ROMS;
 508                 return NULL;
 509         } else if (!strcmp(str, "norom")) {
 510                 pci_probe |= PCI_NOASSIGN_ROMS;
 511                 return NULL;
 512         } else if (!strcmp(str, "assign-busses")) {
 513                 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 514                 return NULL;
 515         } else if (!strcmp(str, "use_crs")) {
 516                 pci_probe |= PCI_USE__CRS;
 517                 return NULL;
 518         } else if (!strcmp(str, "nocrs")) {
 519                 pci_probe |= PCI_ROOT_NO_CRS;
 520                 return NULL;
 521         } else if (!strcmp(str, "earlydump")) {
 522                 pci_early_dump_regs = 1;
 523                 return NULL;
 524         } else if (!strcmp(str, "routeirq")) {
 525                 pci_routeirq = 1;
 526                 return NULL;
 527         } else if (!strcmp(str, "skip_isa_align")) {
 528                 pci_probe |= PCI_CAN_SKIP_ISA_ALIGN;
 529                 return NULL;
 530         } else if (!strcmp(str, "noioapicquirk")) {
 531                 noioapicquirk = 1;
 532                 return NULL;
 533         } else if (!strcmp(str, "ioapicreroute")) {
 534                 if (noioapicreroute != -1)
 535                         noioapicreroute = 0;
 536                 return NULL;
 537         } else if (!strcmp(str, "noioapicreroute")) {
 538                 if (noioapicreroute != -1)
 539                         noioapicreroute = 1;
 540                 return NULL;
 541         }
 542         return str;
 543 }
 544
 545 unsigned int pcibios_assign_all_busses(void)
 546 {
 547         return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
 548 }
 549
 550 int pcibios_enable_device(struct pci_dev *dev, int mask)
 551 {
 552         int err;
 553
 554         if ((err = pci_enable_resources(dev, mask)) < 0)
 555                 return err;
 556
 557         if (!pci_dev_msi_enabled(dev))
 558                 return pcibios_enable_irq(dev);
 559         return 0;
 560 }
 561
 562 void pcibios_disable_device (struct pci_dev *dev)
 563 {
 564         if (!pci_dev_msi_enabled(dev) && pcibios_disable_irq)
 565                 pcibios_disable_irq(dev);
 566 }
 567
 568 int pci_ext_cfg_avail(struct pci_dev *dev)
 569 {
 570         if (raw_pci_ext_ops)
 571                 return 1;
 572         else
 573                 return 0;
 574 }
 575
 576 struct pci_bus * __devinit pci_scan_bus_on_node(int busno, struct pci_ops *ops, int node)
 577 {
 578         struct pci_bus *bus = NULL;
 579         struct pci_sysdata *sd;
 580
 581         /*
 582          * Allocate per-root-bus (not per bus) arch-specific data.
 583          * TODO: leak; this memory is never freed.
 584          * It's arguable whether it's worth the trouble to care.
 585          */
 586         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 587         if (!sd) {
 588                 printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busno);
 589                 return NULL;
 590         }
 591         sd->node = node;
 592         bus = pci_scan_bus(busno, ops, sd);
 593         if (!bus)
 594                 kfree(sd);
 595
 596         return bus;
 597 }
 598
 599 struct pci_bus * __devinit pci_scan_bus_with_sysdata(int busno)
 600 {
 601         return pci_scan_bus_on_node(busno, &pci_root_ops, -1);
 602 }
 603
 604 /*
 605  * NUMA info for PCI busses
 606  *
 607  * Early arch code is responsible for filling in reasonable values here.
 608  * A node id of "-1" means "use current node".  In other words, if a bus
 609  * has a -1 node id, it's not tightly coupled to any particular chunk
 610  * of memory (as is the case on some Nehalem systems).
 611  */
 612 #ifdef CONFIG_NUMA
 613
 614 #define BUS_NR 256
 615
 616 #ifdef CONFIG_X86_64
 617
 618 static int mp_bus_to_node[BUS_NR] = {
 619         [0 ... BUS_NR - 1] = -1
 620 };
 621
 622 void set_mp_bus_to_node(int busnum, int node)
 623 {
 624         if (busnum >= 0 &&  busnum < BUS_NR)
 625                 mp_bus_to_node[busnum] = node;
 626 }
 627
 628 int get_mp_bus_to_node(int busnum)
 629 {
 630         int node = -1;
 631
 632         if (busnum < 0 || busnum > (BUS_NR - 1))
 633                 return node;
 634
 635         node = mp_bus_to_node[busnum];
 636
 637         /*
 638          * let numa_node_id to decide it later in dma_alloc_pages
 639          * if there is no ram on that node
 640          */
 641         if (node != -1 && !node_online(node))
 642                 node = -1;
 643
 644         return node;
 645 }
 646
 647 #else /* CONFIG_X86_32 */
 648
 649 static int mp_bus_to_node[BUS_NR] = {
 650         [0 ... BUS_NR - 1] = -1
 651 };
 652
 653 void set_mp_bus_to_node(int busnum, int node)
 654 {
 655         if (busnum >= 0 &&  busnum < BUS_NR)
 656         mp_bus_to_node[busnum] = (unsigned char) node;
 657 }
 658
 659 int get_mp_bus_to_node(int busnum)
 660 {
 661         int node;
 662
 663         if (busnum < 0 || busnum > (BUS_NR - 1))
 664                 return 0;
 665         node = mp_bus_to_node[busnum];
 666         return node;
 667 }
 668
 669 #endif /* CONFIG_X86_32 */
 670
 671 #endif /* CONFIG_NUMA */