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/ppc-pci.h>
24 #include <asm/byteorder.h>
25 #include <asm/uaccess.h>
26 #include <asm/machdep.h>
30 unsigned long isa_io_base
= 0;
31 unsigned long pci_dram_offset
= 0;
32 int pcibios_assign_bus_offset
= 1;
34 void pcibios_make_OF_bus_map(void);
36 static void fixup_broken_pcnet32(struct pci_dev
* dev
);
37 static void fixup_cpc710_pci64(struct pci_dev
* dev
);
39 static u8
* pci_to_OF_bus_map
;
42 /* By default, we don't re-assign bus numbers. We do this only on
45 static int pci_assign_all_buses
;
47 static int pci_bus_count
;
49 /* This will remain NULL for now, until isa-bridge.c is made common
50 * to both 32-bit and 64-bit.
52 struct pci_dev
*isa_bridge_pcidev
;
53 EXPORT_SYMBOL_GPL(isa_bridge_pcidev
);
56 fixup_hide_host_resource_fsl(struct pci_dev
*dev
)
58 int i
, class = dev
->class >> 8;
60 if ((class == PCI_CLASS_PROCESSOR_POWERPC
||
61 class == PCI_CLASS_BRIDGE_OTHER
) &&
62 (dev
->hdr_type
== PCI_HEADER_TYPE_NORMAL
) &&
63 (dev
->bus
->parent
== NULL
)) {
64 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
65 dev
->resource
[i
].start
= 0;
66 dev
->resource
[i
].end
= 0;
67 dev
->resource
[i
].flags
= 0;
71 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_MOTOROLA
, PCI_ANY_ID
, fixup_hide_host_resource_fsl
);
72 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_FREESCALE
, PCI_ANY_ID
, fixup_hide_host_resource_fsl
);
75 fixup_broken_pcnet32(struct pci_dev
* dev
)
77 if ((dev
->class>>8 == PCI_CLASS_NETWORK_ETHERNET
)) {
78 dev
->vendor
= PCI_VENDOR_ID_AMD
;
79 pci_write_config_word(dev
, PCI_VENDOR_ID
, PCI_VENDOR_ID_AMD
);
82 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TRIDENT
, PCI_ANY_ID
, fixup_broken_pcnet32
);
85 fixup_cpc710_pci64(struct pci_dev
* dev
)
87 /* Hide the PCI64 BARs from the kernel as their content doesn't
88 * fit well in the resource management
90 dev
->resource
[0].start
= dev
->resource
[0].end
= 0;
91 dev
->resource
[0].flags
= 0;
92 dev
->resource
[1].start
= dev
->resource
[1].end
= 0;
93 dev
->resource
[1].flags
= 0;
95 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CPC710_PCI64
, fixup_cpc710_pci64
);
99 * Functions below are used on OpenFirmware machines.
102 make_one_node_map(struct device_node
* node
, u8 pci_bus
)
104 const int *bus_range
;
107 if (pci_bus
>= pci_bus_count
)
109 bus_range
= of_get_property(node
, "bus-range", &len
);
110 if (bus_range
== NULL
|| len
< 2 * sizeof(int)) {
111 printk(KERN_WARNING
"Can't get bus-range for %s, "
112 "assuming it starts at 0\n", node
->full_name
);
113 pci_to_OF_bus_map
[pci_bus
] = 0;
115 pci_to_OF_bus_map
[pci_bus
] = bus_range
[0];
117 for_each_child_of_node(node
, node
) {
119 const unsigned int *class_code
, *reg
;
121 class_code
= of_get_property(node
, "class-code", NULL
);
122 if (!class_code
|| ((*class_code
>> 8) != PCI_CLASS_BRIDGE_PCI
&&
123 (*class_code
>> 8) != PCI_CLASS_BRIDGE_CARDBUS
))
125 reg
= of_get_property(node
, "reg", NULL
);
128 dev
= pci_get_bus_and_slot(pci_bus
, ((reg
[0] >> 8) & 0xff));
129 if (!dev
|| !dev
->subordinate
) {
133 make_one_node_map(node
, dev
->subordinate
->number
);
139 pcibios_make_OF_bus_map(void)
142 struct pci_controller
*hose
, *tmp
;
143 struct property
*map_prop
;
144 struct device_node
*dn
;
146 pci_to_OF_bus_map
= kmalloc(pci_bus_count
, GFP_KERNEL
);
147 if (!pci_to_OF_bus_map
) {
148 printk(KERN_ERR
"Can't allocate OF bus map !\n");
152 /* We fill the bus map with invalid values, that helps
155 for (i
=0; i
<pci_bus_count
; i
++)
156 pci_to_OF_bus_map
[i
] = 0xff;
158 /* For each hose, we begin searching bridges */
159 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
) {
160 struct device_node
* node
= hose
->dn
;
164 make_one_node_map(node
, hose
->first_busno
);
166 dn
= of_find_node_by_path("/");
167 map_prop
= of_find_property(dn
, "pci-OF-bus-map", NULL
);
169 BUG_ON(pci_bus_count
> map_prop
->length
);
170 memcpy(map_prop
->value
, pci_to_OF_bus_map
, pci_bus_count
);
174 printk("PCI->OF bus map:\n");
175 for (i
=0; i
<pci_bus_count
; i
++) {
176 if (pci_to_OF_bus_map
[i
] == 0xff)
178 printk("%d -> %d\n", i
, pci_to_OF_bus_map
[i
]);
183 typedef int (*pci_OF_scan_iterator
)(struct device_node
* node
, void* data
);
185 static struct device_node
*
186 scan_OF_pci_childs(struct device_node
*parent
, pci_OF_scan_iterator filter
, void* data
)
188 struct device_node
*node
;
189 struct device_node
* sub_node
;
191 for_each_child_of_node(parent
, node
) {
192 const unsigned int *class_code
;
194 if (filter(node
, data
)) {
199 /* For PCI<->PCI bridges or CardBus bridges, we go down
200 * Note: some OFs create a parent node "multifunc-device" as
201 * a fake root for all functions of a multi-function device,
202 * we go down them as well.
204 class_code
= of_get_property(node
, "class-code", NULL
);
205 if ((!class_code
|| ((*class_code
>> 8) != PCI_CLASS_BRIDGE_PCI
&&
206 (*class_code
>> 8) != PCI_CLASS_BRIDGE_CARDBUS
)) &&
207 strcmp(node
->name
, "multifunc-device"))
209 sub_node
= scan_OF_pci_childs(node
, filter
, data
);
218 static struct device_node
*scan_OF_for_pci_dev(struct device_node
*parent
,
221 struct device_node
*np
, *cnp
;
225 for_each_child_of_node(parent
, np
) {
226 reg
= of_get_property(np
, "reg", &psize
);
227 if (reg
&& psize
>= 4 && ((reg
[0] >> 8) & 0xff) == devfn
)
230 /* Note: some OFs create a parent node "multifunc-device" as
231 * a fake root for all functions of a multi-function device,
232 * we go down them as well. */
233 if (!strcmp(np
->name
, "multifunc-device")) {
234 cnp
= scan_OF_for_pci_dev(np
, 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
;
275 pr_debug("pci_busdev_to_OF_node(%d,0x%x)\n", bus
->number
, devfn
);
276 parent
= scan_OF_for_pci_bus(bus
);
279 pr_debug(" parent is %s\n", parent
? parent
->full_name
: "<NULL>");
280 np
= scan_OF_for_pci_dev(parent
, devfn
);
282 pr_debug(" result is %s\n", np
? np
->full_name
: "<NULL>");
284 /* XXX most callers don't release the returned node
285 * mostly because ppc64 doesn't increase the refcount,
286 * we need to fix that.
290 EXPORT_SYMBOL(pci_busdev_to_OF_node
);
293 pci_device_to_OF_node(struct pci_dev
*dev
)
295 return pci_busdev_to_OF_node(dev
->bus
, dev
->devfn
);
297 EXPORT_SYMBOL(pci_device_to_OF_node
);
300 find_OF_pci_device_filter(struct device_node
* node
, void* data
)
302 return ((void *)node
== data
);
306 * Returns the PCI device matching a given OF node
309 pci_device_from_OF_node(struct device_node
* node
, u8
* bus
, u8
* devfn
)
311 const unsigned int *reg
;
312 struct pci_controller
* hose
;
313 struct pci_dev
* dev
= NULL
;
315 /* Make sure it's really a PCI device */
316 hose
= pci_find_hose_for_OF_device(node
);
317 if (!hose
|| !hose
->dn
)
319 if (!scan_OF_pci_childs(hose
->dn
,
320 find_OF_pci_device_filter
, (void *)node
))
322 reg
= of_get_property(node
, "reg", NULL
);
325 *bus
= (reg
[0] >> 16) & 0xff;
326 *devfn
= ((reg
[0] >> 8) & 0xff);
328 /* Ok, here we need some tweak. If we have already renumbered
329 * all busses, we can't rely on the OF bus number any more.
330 * the pci_to_OF_bus_map is not enough as several PCI busses
331 * may match the same OF bus number.
333 if (!pci_to_OF_bus_map
)
336 for_each_pci_dev(dev
)
337 if (pci_to_OF_bus_map
[dev
->bus
->number
] == *bus
&&
338 dev
->devfn
== *devfn
) {
339 *bus
= dev
->bus
->number
;
346 EXPORT_SYMBOL(pci_device_from_OF_node
);
348 /* We create the "pci-OF-bus-map" property now so it appears in the
352 pci_create_OF_bus_map(void)
354 struct property
* of_prop
;
355 struct device_node
*dn
;
357 of_prop
= (struct property
*) alloc_bootmem(sizeof(struct property
) + 256);
360 dn
= of_find_node_by_path("/");
362 memset(of_prop
, -1, sizeof(struct property
) + 256);
363 of_prop
->name
= "pci-OF-bus-map";
364 of_prop
->length
= 256;
365 of_prop
->value
= &of_prop
[1];
366 prom_add_property(dn
, of_prop
);
371 #else /* CONFIG_PPC_OF */
372 void pcibios_make_OF_bus_map(void)
375 #endif /* CONFIG_PPC_OF */
377 static void __devinit
pcibios_scan_phb(struct pci_controller
*hose
)
380 struct device_node
*node
= hose
->dn
;
381 unsigned long io_offset
;
382 struct resource
*res
= &hose
->io_resource
;
384 pr_debug("PCI: Scanning PHB %s\n",
385 node
? node
->full_name
: "<NO NAME>");
387 /* Create an empty bus for the toplevel */
388 bus
= pci_create_bus(hose
->parent
, hose
->first_busno
, hose
->ops
, hose
);
390 printk(KERN_ERR
"Failed to create bus for PCI domain %04x\n",
391 hose
->global_number
);
394 bus
->secondary
= hose
->first_busno
;
397 /* Fixup IO space offset */
398 io_offset
= (unsigned long)hose
->io_base_virt
- isa_io_base
;
399 res
->start
= (res
->start
+ io_offset
) & 0xffffffffu
;
400 res
->end
= (res
->end
+ io_offset
) & 0xffffffffu
;
402 /* Wire up PHB bus resources */
403 pcibios_setup_phb_resources(hose
);
406 hose
->last_busno
= bus
->subordinate
= pci_scan_child_bus(bus
);
409 static int __init
pcibios_init(void)
411 struct pci_controller
*hose
, *tmp
;
414 printk(KERN_INFO
"PCI: Probing PCI hardware\n");
416 if (ppc_pci_flags
& PPC_PCI_REASSIGN_ALL_BUS
)
417 pci_assign_all_buses
= 1;
419 /* Scan all of the recorded PCI controllers. */
420 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
) {
421 if (pci_assign_all_buses
)
422 hose
->first_busno
= next_busno
;
423 hose
->last_busno
= 0xff;
424 pcibios_scan_phb(hose
);
425 pci_bus_add_devices(hose
->bus
);
426 if (pci_assign_all_buses
|| next_busno
<= hose
->last_busno
)
427 next_busno
= hose
->last_busno
+ pcibios_assign_bus_offset
;
429 pci_bus_count
= next_busno
;
431 /* OpenFirmware based machines need a map of OF bus
432 * numbers vs. kernel bus numbers since we may have to
435 if (pci_assign_all_buses
)
436 pcibios_make_OF_bus_map();
438 /* Call common code to handle resource allocation */
439 pcibios_resource_survey();
441 /* Call machine dependent post-init code */
442 if (ppc_md
.pcibios_after_init
)
443 ppc_md
.pcibios_after_init();
448 subsys_initcall(pcibios_init
);
450 /* the next one is stolen from the alpha port... */
452 pcibios_update_irq(struct pci_dev
*dev
, int irq
)
454 pci_write_config_byte(dev
, PCI_INTERRUPT_LINE
, irq
);
455 /* XXX FIXME - update OF device tree node interrupt property */
458 static struct pci_controller
*
459 pci_bus_to_hose(int bus
)
461 struct pci_controller
*hose
, *tmp
;
463 list_for_each_entry_safe(hose
, tmp
, &hose_list
, list_node
)
464 if (bus
>= hose
->first_busno
&& bus
<= hose
->last_busno
)
469 /* Provide information on locations of various I/O regions in physical
470 * memory. Do this on a per-card basis so that we choose the right
472 * Note that the returned IO or memory base is a physical address
475 long sys_pciconfig_iobase(long which
, unsigned long bus
, unsigned long devfn
)
477 struct pci_controller
* hose
;
478 long result
= -EOPNOTSUPP
;
480 hose
= pci_bus_to_hose(bus
);
485 case IOBASE_BRIDGE_NUMBER
:
486 return (long)hose
->first_busno
;
488 return (long)hose
->pci_mem_offset
;
490 return (long)hose
->io_base_phys
;
492 return (long)isa_io_base
;
494 return (long)isa_mem_base
;
501 * Null PCI config access functions, for the case when we can't
504 #define NULL_PCI_OP(rw, size, type) \
506 null_##rw##_config_##size(struct pci_dev *dev, int offset, type val) \
508 return PCIBIOS_DEVICE_NOT_FOUND; \
512 null_read_config(struct pci_bus
*bus
, unsigned int devfn
, int offset
,
515 return PCIBIOS_DEVICE_NOT_FOUND
;
519 null_write_config(struct pci_bus
*bus
, unsigned int devfn
, int offset
,
522 return PCIBIOS_DEVICE_NOT_FOUND
;
525 static struct pci_ops null_pci_ops
=
527 .read
= null_read_config
,
528 .write
= null_write_config
,
532 * These functions are used early on before PCI scanning is done
533 * and all of the pci_dev and pci_bus structures have been created.
535 static struct pci_bus
*
536 fake_pci_bus(struct pci_controller
*hose
, int busnr
)
538 static struct pci_bus bus
;
541 hose
= pci_bus_to_hose(busnr
);
543 printk(KERN_ERR
"Can't find hose for PCI bus %d!\n", busnr
);
547 bus
.ops
= hose
? hose
->ops
: &null_pci_ops
;
551 #define EARLY_PCI_OP(rw, size, type) \
552 int early_##rw##_config_##size(struct pci_controller *hose, int bus, \
553 int devfn, int offset, type value) \
555 return pci_bus_##rw##_config_##size(fake_pci_bus(hose, bus), \
556 devfn, offset, value); \
559 EARLY_PCI_OP(read
, byte
, u8
*)
560 EARLY_PCI_OP(read
, word
, u16
*)
561 EARLY_PCI_OP(read
, dword
, u32
*)
562 EARLY_PCI_OP(write
, byte
, u8
)
563 EARLY_PCI_OP(write
, word
, u16
)
564 EARLY_PCI_OP(write
, dword
, u32
)
566 extern int pci_bus_find_capability (struct pci_bus
*bus
, unsigned int devfn
, int cap
);
567 int early_find_capability(struct pci_controller
*hose
, int bus
, int devfn
,
570 return pci_bus_find_capability(fake_pci_bus(hose
, bus
), devfn
, cap
);