4 * Copyright (C) 2001 Todd Inglett, IBM Corporation
6 * PCI manipulation via device_nodes.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/kernel.h>
23 #include <linux/pci.h>
24 #include <linux/string.h>
25 #include <linux/export.h>
26 #include <linux/init.h>
27 #include <linux/gfp.h>
31 #include <asm/pci-bridge.h>
32 #include <asm/ppc-pci.h>
33 #include <asm/firmware.h>
37 * The function is used to find the firmware data of one
38 * specific PCI device, which is attached to the indicated
39 * PCI bus. For VFs, their firmware data is linked to that
40 * one of PF's bridge. For other devices, their firmware
41 * data is linked to that of their bridge.
43 static struct pci_dn
*pci_bus_to_pdn(struct pci_bus
*bus
)
46 struct device_node
*dn
;
50 * We probably have virtual bus which doesn't
51 * have associated bridge.
55 if (pci_is_root_bus(pbus
) || pbus
->self
)
62 * Except virtual bus, all PCI buses should
65 dn
= pci_bus_to_OF_node(pbus
);
66 pdn
= dn
? PCI_DN(dn
) : NULL
;
71 struct pci_dn
*pci_get_pdn_by_devfn(struct pci_bus
*bus
,
74 struct device_node
*dn
= NULL
;
75 struct pci_dn
*parent
, *pdn
;
76 struct pci_dev
*pdev
= NULL
;
78 /* Fast path: fetch from PCI device */
79 list_for_each_entry(pdev
, &bus
->devices
, bus_list
) {
80 if (pdev
->devfn
== devfn
) {
81 if (pdev
->dev
.archdata
.pci_data
)
82 return pdev
->dev
.archdata
.pci_data
;
84 dn
= pci_device_to_OF_node(pdev
);
89 /* Fast path: fetch from device node */
90 pdn
= dn
? PCI_DN(dn
) : NULL
;
94 /* Slow path: fetch from firmware data hierarchy */
95 parent
= pci_bus_to_pdn(bus
);
99 list_for_each_entry(pdn
, &parent
->child_list
, list
) {
100 if (pdn
->busno
== bus
->number
&&
108 struct pci_dn
*pci_get_pdn(struct pci_dev
*pdev
)
110 struct device_node
*dn
;
111 struct pci_dn
*parent
, *pdn
;
113 /* Search device directly */
114 if (pdev
->dev
.archdata
.pci_data
)
115 return pdev
->dev
.archdata
.pci_data
;
117 /* Check device node */
118 dn
= pci_device_to_OF_node(pdev
);
119 pdn
= dn
? PCI_DN(dn
) : NULL
;
124 * VFs don't have device nodes. We hook their
125 * firmware data to PF's bridge.
127 parent
= pci_bus_to_pdn(pdev
->bus
);
131 list_for_each_entry(pdn
, &parent
->child_list
, list
) {
132 if (pdn
->busno
== pdev
->bus
->number
&&
133 pdn
->devfn
== pdev
->devfn
)
140 #ifdef CONFIG_PCI_IOV
141 static struct pci_dn
*add_one_dev_pci_data(struct pci_dn
*parent
,
143 int busno
, int devfn
)
147 /* Except PHB, we always have the parent */
151 pdn
= kzalloc(sizeof(*pdn
), GFP_KERNEL
);
155 pdn
->phb
= parent
->phb
;
156 pdn
->parent
= parent
;
159 #ifdef CONFIG_PPC_POWERNV
160 pdn
->vf_index
= vf_index
;
161 pdn
->pe_number
= IODA_INVALID_PE
;
163 INIT_LIST_HEAD(&pdn
->child_list
);
164 INIT_LIST_HEAD(&pdn
->list
);
165 list_add_tail(&pdn
->list
, &parent
->child_list
);
171 struct pci_dn
*add_dev_pci_data(struct pci_dev
*pdev
)
173 #ifdef CONFIG_PCI_IOV
174 struct pci_dn
*parent
, *pdn
;
177 /* Only support IOV for now */
178 if (!pdev
->is_physfn
)
179 return pci_get_pdn(pdev
);
181 /* Check if VFs have been populated */
182 pdn
= pci_get_pdn(pdev
);
183 if (!pdn
|| (pdn
->flags
& PCI_DN_FLAG_IOV_VF
))
186 pdn
->flags
|= PCI_DN_FLAG_IOV_VF
;
187 parent
= pci_bus_to_pdn(pdev
->bus
);
191 for (i
= 0; i
< pci_sriov_get_totalvfs(pdev
); i
++) {
192 struct eeh_dev
*edev __maybe_unused
;
194 pdn
= add_one_dev_pci_data(parent
, i
,
195 pci_iov_virtfn_bus(pdev
, i
),
196 pci_iov_virtfn_devfn(pdev
, i
));
198 dev_warn(&pdev
->dev
, "%s: Cannot create firmware data for VF#%d\n",
204 /* Create the EEH device for the VF */
205 edev
= eeh_dev_init(pdn
);
208 #endif /* CONFIG_EEH */
210 #endif /* CONFIG_PCI_IOV */
212 return pci_get_pdn(pdev
);
215 void remove_dev_pci_data(struct pci_dev
*pdev
)
217 #ifdef CONFIG_PCI_IOV
218 struct pci_dn
*parent
;
219 struct pci_dn
*pdn
, *tmp
;
223 * VF and VF PE are created/released dynamically, so we need to
224 * bind/unbind them. Otherwise the VF and VF PE would be mismatched
225 * when re-enabling SR-IOV.
227 if (pdev
->is_virtfn
) {
228 pdn
= pci_get_pdn(pdev
);
229 #ifdef CONFIG_PPC_POWERNV
230 pdn
->pe_number
= IODA_INVALID_PE
;
235 /* Only support IOV PF for now */
236 if (!pdev
->is_physfn
)
239 /* Check if VFs have been populated */
240 pdn
= pci_get_pdn(pdev
);
241 if (!pdn
|| !(pdn
->flags
& PCI_DN_FLAG_IOV_VF
))
244 pdn
->flags
&= ~PCI_DN_FLAG_IOV_VF
;
245 parent
= pci_bus_to_pdn(pdev
->bus
);
250 * We might introduce flag to pci_dn in future
251 * so that we can release VF's firmware data in
254 for (i
= 0; i
< pci_sriov_get_totalvfs(pdev
); i
++) {
255 struct eeh_dev
*edev __maybe_unused
;
257 list_for_each_entry_safe(pdn
, tmp
,
258 &parent
->child_list
, list
) {
259 if (pdn
->busno
!= pci_iov_virtfn_bus(pdev
, i
) ||
260 pdn
->devfn
!= pci_iov_virtfn_devfn(pdev
, i
))
264 /* Release EEH device for the VF */
265 edev
= pdn_to_eeh_dev(pdn
);
270 #endif /* CONFIG_EEH */
272 if (!list_empty(&pdn
->list
))
273 list_del(&pdn
->list
);
278 #endif /* CONFIG_PCI_IOV */
281 struct pci_dn
*pci_add_device_node_info(struct pci_controller
*hose
,
282 struct device_node
*dn
)
284 const __be32
*type
= of_get_property(dn
, "ibm,pci-config-space-type", NULL
);
286 struct device_node
*parent
;
289 struct eeh_dev
*edev
;
292 pdn
= kzalloc(sizeof(*pdn
), GFP_KERNEL
);
297 #ifdef CONFIG_PPC_POWERNV
298 pdn
->pe_number
= IODA_INVALID_PE
;
300 regs
= of_get_property(dn
, "reg", NULL
);
302 u32 addr
= of_read_number(regs
, 1);
304 /* First register entry is addr (00BBSS00) */
305 pdn
->busno
= (addr
>> 16) & 0xff;
306 pdn
->devfn
= (addr
>> 8) & 0xff;
309 /* vendor/device IDs and class code */
310 regs
= of_get_property(dn
, "vendor-id", NULL
);
311 pdn
->vendor_id
= regs
? of_read_number(regs
, 1) : 0;
312 regs
= of_get_property(dn
, "device-id", NULL
);
313 pdn
->device_id
= regs
? of_read_number(regs
, 1) : 0;
314 regs
= of_get_property(dn
, "class-code", NULL
);
315 pdn
->class_code
= regs
? of_read_number(regs
, 1) : 0;
317 /* Extended config space */
318 pdn
->pci_ext_config_space
= (type
&& of_read_number(type
, 1) == 1);
320 /* Create EEH device */
322 edev
= eeh_dev_init(pdn
);
329 /* Attach to parent node */
330 INIT_LIST_HEAD(&pdn
->child_list
);
331 INIT_LIST_HEAD(&pdn
->list
);
332 parent
= of_get_parent(dn
);
333 pdn
->parent
= parent
? PCI_DN(parent
) : NULL
;
335 list_add_tail(&pdn
->list
, &pdn
->parent
->child_list
);
339 EXPORT_SYMBOL_GPL(pci_add_device_node_info
);
341 void pci_remove_device_node_info(struct device_node
*dn
)
343 struct pci_dn
*pdn
= dn
? PCI_DN(dn
) : NULL
;
344 struct device_node
*parent
;
346 struct eeh_dev
*edev
= pdn_to_eeh_dev(pdn
);
355 WARN_ON(!list_empty(&pdn
->child_list
));
356 list_del(&pdn
->list
);
358 parent
= of_get_parent(dn
);
365 EXPORT_SYMBOL_GPL(pci_remove_device_node_info
);
368 * Traverse a device tree stopping each PCI device in the tree.
369 * This is done depth first. As each node is processed, a "pre"
370 * function is called and the children are processed recursively.
372 * The "pre" func returns a value. If non-zero is returned from
373 * the "pre" func, the traversal stops and this value is returned.
374 * This return value is useful when using traverse as a method of
377 * NOTE: we do not run the func for devices that do not appear to
378 * be PCI except for the start node which we assume (this is good
379 * because the start node is often a phb which may be missing PCI
381 * We use the class-code as an indicator. If we run into
382 * one of these nodes we also assume its siblings are non-pci for
385 void *pci_traverse_device_nodes(struct device_node
*start
,
386 void *(*fn
)(struct device_node
*, void *),
389 struct device_node
*dn
, *nextdn
;
392 /* We started with a phb, iterate all childs */
393 for (dn
= start
->child
; dn
; dn
= nextdn
) {
394 const __be32
*classp
;
398 classp
= of_get_property(dn
, "class-code", NULL
);
400 class = of_read_number(classp
, 1);
408 /* If we are a PCI bridge, go down */
409 if (dn
->child
&& ((class >> 8) == PCI_CLASS_BRIDGE_PCI
||
410 (class >> 8) == PCI_CLASS_BRIDGE_CARDBUS
))
411 /* Depth first...do children */
413 else if (dn
->sibling
)
414 /* ok, try next sibling instead. */
415 nextdn
= dn
->sibling
;
417 /* Walk up to next valid sibling. */
422 } while (dn
->sibling
== NULL
);
423 nextdn
= dn
->sibling
;
428 EXPORT_SYMBOL_GPL(pci_traverse_device_nodes
);
430 static struct pci_dn
*pci_dn_next_one(struct pci_dn
*root
,
433 struct list_head
*next
= pdn
->child_list
.next
;
435 if (next
!= &pdn
->child_list
)
436 return list_entry(next
, struct pci_dn
, list
);
442 next
= pdn
->list
.next
;
443 if (next
!= &pdn
->parent
->child_list
)
449 return list_entry(next
, struct pci_dn
, list
);
452 void *traverse_pci_dn(struct pci_dn
*root
,
453 void *(*fn
)(struct pci_dn
*, void *),
456 struct pci_dn
*pdn
= root
;
459 /* Only scan the child nodes */
460 for (pdn
= pci_dn_next_one(root
, pdn
); pdn
;
461 pdn
= pci_dn_next_one(root
, pdn
)) {
470 static void *add_pdn(struct device_node
*dn
, void *data
)
472 struct pci_controller
*hose
= data
;
475 pdn
= pci_add_device_node_info(hose
, dn
);
477 return ERR_PTR(-ENOMEM
);
483 * pci_devs_phb_init_dynamic - setup pci devices under this PHB
484 * phb: pci-to-host bridge (top-level bridge connecting to cpu)
486 * This routine is called both during boot, (before the memory
487 * subsystem is set up, before kmalloc is valid) and during the
488 * dynamic lpar operation of adding a PHB to a running system.
490 void pci_devs_phb_init_dynamic(struct pci_controller
*phb
)
492 struct device_node
*dn
= phb
->dn
;
495 /* PHB nodes themselves must not match */
496 pdn
= pci_add_device_node_info(phb
, dn
);
498 pdn
->devfn
= pdn
->busno
= -1;
499 pdn
->vendor_id
= pdn
->device_id
= pdn
->class_code
= 0;
504 /* Update dn->phb ptrs for new phb and children devices */
505 pci_traverse_device_nodes(dn
, add_pdn
, phb
);
509 * pci_devs_phb_init - Initialize phbs and pci devs under them.
511 * This routine walks over all phb's (pci-host bridges) on the
512 * system, and sets up assorted pci-related structures
513 * (including pci info in the device node structs) for each
514 * pci device found underneath. This routine runs once,
515 * early in the boot sequence.
517 static int __init
pci_devs_phb_init(void)
519 struct pci_controller
*phb
, *tmp
;
521 /* This must be done first so the device nodes have valid pci info! */
522 list_for_each_entry_safe(phb
, tmp
, &hose_list
, list_node
)
523 pci_devs_phb_init_dynamic(phb
);
528 core_initcall(pci_devs_phb_init
);
530 static void pci_dev_pdn_setup(struct pci_dev
*pdev
)
534 if (pdev
->dev
.archdata
.pci_data
)
537 /* Setup the fast path */
538 pdn
= pci_get_pdn(pdev
);
539 pdev
->dev
.archdata
.pci_data
= pdn
;
541 DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID
, PCI_ANY_ID
, pci_dev_pdn_setup
);