~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/pci/common.c

Version: ~ [ linux-4.19-rc4 ] ~ [ linux-4.18.8 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.70 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.127 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.156 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.122 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.31.14 ] ~ [ linux-2.6.30.10 ] ~ [ linux-2.6.29.6 ] ~ [ linux-2.6.28.10 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp