2 * Common pmac/prep/chrp pci routines. -- Cort
5 #include <linux/kernel.h>
7 #include <linux/delay.h>
8 #include <linux/string.h>
9 #include <linux/init.h>
10 #include <linux/capability.h>
11 #include <linux/sched.h>
12 #include <linux/errno.h>
13 #include <linux/bootmem.h>
14 #include <linux/irq.h>
15 #include <linux/list.h>
18 #include <asm/processor.h>
21 #include <asm/sections.h>
22 #include <asm/pci-bridge.h>
23 #include <asm/byteorder.h>
24 #include <asm/uaccess.h>
25 #include <asm/machdep.h>
30 #define DBG(x...) printk(x)
35 unsigned long isa_io_base
= 0;
36 unsigned long pci_dram_offset
= 0;
37 int pcibios_assign_bus_offset
= 1;
39 void pcibios_make_OF_bus_map(void);
41 static void fixup_broken_pcnet32(struct pci_dev
* dev
);
42 static void fixup_cpc710_pci64(struct pci_dev
* dev
);
44 static u8
* pci_to_OF_bus_map
;
47 /* By default, we don't re-assign bus numbers. We do this only on
50 static int pci_assign_all_buses
;
54 static int pci_bus_count
;
56 /* This will remain NULL for now, until isa-bridge.c is made common
57 * to both 32-bit and 64-bit.
59 struct pci_dev
*isa_bridge_pcidev
;
60 EXPORT_SYMBOL_GPL(isa_bridge_pcidev
);
63 fixup_hide_host_resource_fsl(struct pci_dev
*dev
)
65 int i
, class = dev
->class >> 8;
67 if ((class == PCI_CLASS_PROCESSOR_POWERPC
||
68 class == PCI_CLASS_BRIDGE_OTHER
) &&
69 (dev
->hdr_type
== PCI_HEADER_TYPE_NORMAL
) &&
70 (dev
->bus
->parent
== NULL
)) {
71 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
72 dev
->resource
[i
].start
= 0;
73 dev
->resource
[i
].end
= 0;
74 dev
->resource
[i
].flags
= 0;
78 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MOTOROLA
, PCI_ANY_ID
, fixup_hide_host_resource_fsl
);
79 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_FREESCALE
, PCI_ANY_ID
, fixup_hide_host_resource_fsl
);
82 fixup_broken_pcnet32(struct pci_dev
* dev
)
84 if ((dev
->class>>8 == PCI_CLASS_NETWORK_ETHERNET
)) {
85 dev
->vendor
= PCI_VENDOR_ID_AMD
;
86 pci_write_config_word(dev
, PCI_VENDOR_ID
, PCI_VENDOR_ID_AMD
);
89 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TRIDENT
, PCI_ANY_ID
, fixup_broken_pcnet32
);
92 fixup_cpc710_pci64(struct pci_dev
* dev
)
94 /* Hide the PCI64 BARs from the kernel as their content doesn't
95 * fit well in the resource management
97 dev
->resource
[0].start
= dev
->resource
[0].end
= 0;
98 dev
->resource
[0].flags
= 0;
99 dev
->resource
[1].start
= dev
->resource
[1].end
= 0;
100 dev
->resource
[1].flags
= 0;
102 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CPC710_PCI64
, fixup_cpc710_pci64
);
106 * Functions below are used on OpenFirmware machines.
109 make_one_node_map(struct device_node
* node
, u8 pci_bus
)
111 const int *bus_range
;
114 if (pci_bus
>= pci_bus_count
)
116 bus_range
= of_get_property(node
, "bus-range", &len
);
117 if (bus_range
== NULL
|| len
< 2 * sizeof(int)) {
118 printk(KERN_WARNING
"Can't get bus-range for %s, "
119 "assuming it starts at 0\n", node
->full_name
);
120 pci_to_OF_bus_map
[pci_bus
] = 0;
122 pci_to_OF_bus_map
[pci_bus
] = bus_range
[0];
124 for_each_child_of_node(node
, node
) {
126 const unsigned int *class_code
, *reg
;
128 class_code
= of_get_property(node
, "class-code", NULL
);
129 if (!class_code
|| ((*class_code
>> 8) != PCI_CLASS_BRIDGE_PCI
&&
130 (*class_code
>> 8) != PCI_CLASS_BRIDGE_CARDBUS
))
132 reg
= of_get_property(node
, "reg", NULL
);
135 dev
= pci_get_bus_and_slot(pci_bus
, ((reg
[0] >> 8) & 0xff));
136 if (!dev
|| !dev
->subordinate
) {
140 make_one_node_map(node
, dev
->subordinate
->number
);
146 pcibios_make_OF_bus_map(void)
149 struct pci_controller
*hose
, *tmp
;
150 struct property
*map_prop
;
151 struct device_node
*dn
;
153 pci_to_OF_bus_map
= kmalloc(pci_bus_count
, GFP_KERNEL
);
154 if (!pci_to_OF_bus_map
) {
155 printk(KERN_ERR
"Can't allocate OF bus map !\n");
159 /* We fill the bus map with invalid values, that helps
162 for (i
=0; i
<pci_bus_count
; i
++)
163 pci_to_OF_bus_map
[i
] = 0xff;
165 /* For each hose, we begin searching bridges */
166 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
) {
167 struct device_node
* node
= hose
->dn
;
171 make_one_node_map(node
, hose
->first_busno
);
173 dn
= of_find_node_by_path("/");
174 map_prop
= of_find_property(dn
, "pci-OF-bus-map", NULL
);
176 BUG_ON(pci_bus_count
> map_prop
->length
);
177 memcpy(map_prop
->value
, pci_to_OF_bus_map
, pci_bus_count
);
181 printk("PCI->OF bus map:\n");
182 for (i
=0; i
<pci_bus_count
; i
++) {
183 if (pci_to_OF_bus_map
[i
] == 0xff)
185 printk("%d -> %d\n", i
, pci_to_OF_bus_map
[i
]);
190 typedef int (*pci_OF_scan_iterator
)(struct device_node
* node
, void* data
);
192 static struct device_node
*
193 scan_OF_pci_childs(struct device_node
*parent
, pci_OF_scan_iterator filter
, void* data
)
195 struct device_node
*node
;
196 struct device_node
* sub_node
;
198 for_each_child_of_node(parent
, node
) {
199 const unsigned int *class_code
;
201 if (filter(node
, data
)) {
206 /* For PCI<->PCI bridges or CardBus bridges, we go down
207 * Note: some OFs create a parent node "multifunc-device" as
208 * a fake root for all functions of a multi-function device,
209 * we go down them as well.
211 class_code
= of_get_property(node
, "class-code", NULL
);
212 if ((!class_code
|| ((*class_code
>> 8) != PCI_CLASS_BRIDGE_PCI
&&
213 (*class_code
>> 8) != PCI_CLASS_BRIDGE_CARDBUS
)) &&
214 strcmp(node
->name
, "multifunc-device"))
216 sub_node
= scan_OF_pci_childs(node
, filter
, data
);
225 static struct device_node
*scan_OF_for_pci_dev(struct device_node
*parent
,
228 struct device_node
*np
;
232 for_each_child_of_node(parent
, np
) {
233 reg
= of_get_property(np
, "reg", &psize
);
234 if (reg
== NULL
|| psize
< 4)
236 if (((reg
[0] >> 8) & 0xff) == devfn
)
243 static struct device_node
*scan_OF_for_pci_bus(struct pci_bus
*bus
)
245 struct device_node
*parent
, *np
;
247 /* Are we a root bus ? */
248 if (bus
->self
== NULL
|| bus
->parent
== NULL
) {
249 struct pci_controller
*hose
= pci_bus_to_host(bus
);
252 return of_node_get(hose
->dn
);
255 /* not a root bus, we need to get our parent */
256 parent
= scan_OF_for_pci_bus(bus
->parent
);
260 /* now iterate for children for a match */
261 np
= scan_OF_for_pci_dev(parent
, bus
->self
->devfn
);
268 * Scans the OF tree for a device node matching a PCI device
271 pci_busdev_to_OF_node(struct pci_bus
*bus
, int devfn
)
273 struct device_node
*parent
, *np
;
278 DBG("pci_busdev_to_OF_node(%d,0x%x)\n", bus
->number
, devfn
);
279 parent
= scan_OF_for_pci_bus(bus
);
282 DBG(" parent is %s\n", parent
? parent
->full_name
: "<NULL>");
283 np
= scan_OF_for_pci_dev(parent
, devfn
);
285 DBG(" result is %s\n", np
? np
->full_name
: "<NULL>");
287 /* XXX most callers don't release the returned node
288 * mostly because ppc64 doesn't increase the refcount,
289 * we need to fix that.
293 EXPORT_SYMBOL(pci_busdev_to_OF_node
);
296 pci_device_to_OF_node(struct pci_dev
*dev
)
298 return pci_busdev_to_OF_node(dev
->bus
, dev
->devfn
);
300 EXPORT_SYMBOL(pci_device_to_OF_node
);
303 find_OF_pci_device_filter(struct device_node
* node
, void* data
)
305 return ((void *)node
== data
);
309 * Returns the PCI device matching a given OF node
312 pci_device_from_OF_node(struct device_node
* node
, u8
* bus
, u8
* devfn
)
314 const unsigned int *reg
;
315 struct pci_controller
* hose
;
316 struct pci_dev
* dev
= NULL
;
320 /* Make sure it's really a PCI device */
321 hose
= pci_find_hose_for_OF_device(node
);
322 if (!hose
|| !hose
->dn
)
324 if (!scan_OF_pci_childs(hose
->dn
,
325 find_OF_pci_device_filter
, (void *)node
))
327 reg
= of_get_property(node
, "reg", NULL
);
330 *bus
= (reg
[0] >> 16) & 0xff;
331 *devfn
= ((reg
[0] >> 8) & 0xff);
333 /* Ok, here we need some tweak. If we have already renumbered
334 * all busses, we can't rely on the OF bus number any more.
335 * the pci_to_OF_bus_map is not enough as several PCI busses
336 * may match the same OF bus number.
338 if (!pci_to_OF_bus_map
)
341 for_each_pci_dev(dev
)
342 if (pci_to_OF_bus_map
[dev
->bus
->number
] == *bus
&&
343 dev
->devfn
== *devfn
) {
344 *bus
= dev
->bus
->number
;
351 EXPORT_SYMBOL(pci_device_from_OF_node
);
353 /* We create the "pci-OF-bus-map" property now so it appears in the
357 pci_create_OF_bus_map(void)
359 struct property
* of_prop
;
360 struct device_node
*dn
;
362 of_prop
= (struct property
*) alloc_bootmem(sizeof(struct property
) + 256);
365 dn
= of_find_node_by_path("/");
367 memset(of_prop
, -1, sizeof(struct property
) + 256);
368 of_prop
->name
= "pci-OF-bus-map";
369 of_prop
->length
= 256;
370 of_prop
->value
= &of_prop
[1];
371 prom_add_property(dn
, of_prop
);
376 #else /* CONFIG_PPC_OF */
377 void pcibios_make_OF_bus_map(void)
380 #endif /* CONFIG_PPC_OF */
382 static int __init
pcibios_init(void)
384 struct pci_controller
*hose
, *tmp
;
388 printk(KERN_INFO
"PCI: Probing PCI hardware\n");
390 if (ppc_pci_flags
& PPC_PCI_REASSIGN_ALL_BUS
)
391 pci_assign_all_buses
= 1;
393 /* Scan all of the recorded PCI controllers. */
394 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
) {
395 if (pci_assign_all_buses
)
396 hose
->first_busno
= next_busno
;
397 hose
->last_busno
= 0xff;
398 bus
= pci_scan_bus_parented(hose
->parent
, hose
->first_busno
,
401 pci_bus_add_devices(bus
);
402 hose
->last_busno
= bus
->subordinate
;
404 if (pci_assign_all_buses
|| next_busno
<= hose
->last_busno
)
405 next_busno
= hose
->last_busno
+ pcibios_assign_bus_offset
;
407 pci_bus_count
= next_busno
;
409 /* OpenFirmware based machines need a map of OF bus
410 * numbers vs. kernel bus numbers since we may have to
413 if (pci_assign_all_buses
&& have_of
)
414 pcibios_make_OF_bus_map();
416 /* Call common code to handle resource allocation */
417 pcibios_resource_survey();
419 /* Call machine dependent post-init code */
420 if (ppc_md
.pcibios_after_init
)
421 ppc_md
.pcibios_after_init();
426 subsys_initcall(pcibios_init
);
428 void __devinit
pcibios_do_bus_setup(struct pci_bus
*bus
)
430 struct pci_controller
*hose
= (struct pci_controller
*) bus
->sysdata
;
431 unsigned long io_offset
;
432 struct resource
*res
;
436 /* Hookup PHB resources */
437 io_offset
= (unsigned long)hose
->io_base_virt
- isa_io_base
;
438 if (bus
->parent
== NULL
) {
439 /* This is a host bridge - fill in its resources */
442 bus
->resource
[0] = res
= &hose
->io_resource
;
445 printk(KERN_ERR
"I/O resource not set for host"
446 " bridge %d\n", hose
->global_number
);
448 res
->end
= IO_SPACE_LIMIT
;
449 res
->flags
= IORESOURCE_IO
;
451 res
->start
= (res
->start
+ io_offset
) & 0xffffffffu
;
452 res
->end
= (res
->end
+ io_offset
) & 0xffffffffu
;
454 for (i
= 0; i
< 3; ++i
) {
455 res
= &hose
->mem_resources
[i
];
459 printk(KERN_ERR
"Memory resource not set for "
460 "host bridge %d\n", hose
->global_number
);
461 res
->start
= hose
->pci_mem_offset
;
463 res
->flags
= IORESOURCE_MEM
;
465 bus
->resource
[i
+1] = res
;
469 if (ppc_md
.pci_dma_bus_setup
)
470 ppc_md
.pci_dma_bus_setup(bus
);
472 list_for_each_entry(dev
, &bus
->devices
, bus_list
)
473 pcibios_setup_new_device(dev
);
476 /* the next one is stolen from the alpha port... */
478 pcibios_update_irq(struct pci_dev
*dev
, int irq
)
480 pci_write_config_byte(dev
, PCI_INTERRUPT_LINE
, irq
);
481 /* XXX FIXME - update OF device tree node interrupt property */
484 static struct pci_controller
*
485 pci_bus_to_hose(int bus
)
487 struct pci_controller
*hose
, *tmp
;
489 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
)
490 if (bus
>= hose
->first_busno
&& bus
<= hose
->last_busno
)
495 /* Provide information on locations of various I/O regions in physical
496 * memory. Do this on a per-card basis so that we choose the right
498 * Note that the returned IO or memory base is a physical address
501 long sys_pciconfig_iobase(long which
, unsigned long bus
, unsigned long devfn
)
503 struct pci_controller
* hose
;
504 long result
= -EOPNOTSUPP
;
506 hose
= pci_bus_to_hose(bus
);
511 case IOBASE_BRIDGE_NUMBER
:
512 return (long)hose
->first_busno
;
514 return (long)hose
->pci_mem_offset
;
516 return (long)hose
->io_base_phys
;
518 return (long)isa_io_base
;
520 return (long)isa_mem_base
;
526 unsigned long pci_address_to_pio(phys_addr_t address
)
528 struct pci_controller
*hose
, *tmp
;
530 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
) {
531 unsigned int size
= hose
->io_resource
.end
-
532 hose
->io_resource
.start
+ 1;
533 if (address
>= hose
->io_base_phys
&&
534 address
< (hose
->io_base_phys
+ size
)) {
536 (unsigned long)hose
->io_base_virt
- _IO_BASE
;
537 return base
+ (address
- hose
->io_base_phys
);
540 return (unsigned int)-1;
542 EXPORT_SYMBOL(pci_address_to_pio
);
545 * Null PCI config access functions, for the case when we can't
548 #define NULL_PCI_OP(rw, size, type) \
550 null_##rw##_config_##size(struct pci_dev *dev, int offset, type val) \
552 return PCIBIOS_DEVICE_NOT_FOUND; \
556 null_read_config(struct pci_bus
*bus
, unsigned int devfn
, int offset
,
559 return PCIBIOS_DEVICE_NOT_FOUND
;
563 null_write_config(struct pci_bus
*bus
, unsigned int devfn
, int offset
,
566 return PCIBIOS_DEVICE_NOT_FOUND
;
569 static struct pci_ops null_pci_ops
=
571 .read
= null_read_config
,
572 .write
= null_write_config
,
576 * These functions are used early on before PCI scanning is done
577 * and all of the pci_dev and pci_bus structures have been created.
579 static struct pci_bus
*
580 fake_pci_bus(struct pci_controller
*hose
, int busnr
)
582 static struct pci_bus bus
;
585 hose
= pci_bus_to_hose(busnr
);
587 printk(KERN_ERR
"Can't find hose for PCI bus %d!\n", busnr
);
591 bus
.ops
= hose
? hose
->ops
: &null_pci_ops
;
595 #define EARLY_PCI_OP(rw, size, type) \
596 int early_##rw##_config_##size(struct pci_controller *hose, int bus, \
597 int devfn, int offset, type value) \
599 return pci_bus_##rw##_config_##size(fake_pci_bus(hose, bus), \
600 devfn, offset, value); \
603 EARLY_PCI_OP(read
, byte
, u8
*)
604 EARLY_PCI_OP(read
, word
, u16
*)
605 EARLY_PCI_OP(read
, dword
, u32
*)
606 EARLY_PCI_OP(write
, byte
, u8
)
607 EARLY_PCI_OP(write
, word
, u16
)
608 EARLY_PCI_OP(write
, dword
, u32
)
610 extern int pci_bus_find_capability (struct pci_bus
*bus
, unsigned int devfn
, int cap
);
611 int early_find_capability(struct pci_controller
*hose
, int bus
, int devfn
,
614 return pci_bus_find_capability(fake_pci_bus(hose
, bus
), devfn
, cap
);