xref: /linux/arch/powerpc/kernel/pci_dn.c (revision 3ce095c16263630dde46d6051854073edaacf3d7)
1 /*
2  * pci_dn.c
3  *
4  * Copyright (C) 2001 Todd Inglett, IBM Corporation
5  *
6  * PCI manipulation via device_nodes.
7  *
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.
12  *
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.
17  *
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
21  */
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>
28 
29 #include <asm/io.h>
30 #include <asm/prom.h>
31 #include <asm/pci-bridge.h>
32 #include <asm/ppc-pci.h>
33 #include <asm/firmware.h>
34 
35 /*
36  * The function is used to find the firmware data of one
37  * specific PCI device, which is attached to the indicated
38  * PCI bus. For VFs, their firmware data is linked to that
39  * one of PF's bridge. For other devices, their firmware
40  * data is linked to that of their bridge.
41  */
42 static struct pci_dn *pci_bus_to_pdn(struct pci_bus *bus)
43 {
44 	struct pci_bus *pbus;
45 	struct device_node *dn;
46 	struct pci_dn *pdn;
47 
48 	/*
49 	 * We probably have virtual bus which doesn't
50 	 * have associated bridge.
51 	 */
52 	pbus = bus;
53 	while (pbus) {
54 		if (pci_is_root_bus(pbus) || pbus->self)
55 			break;
56 
57 		pbus = pbus->parent;
58 	}
59 
60 	/*
61 	 * Except virtual bus, all PCI buses should
62 	 * have device nodes.
63 	 */
64 	dn = pci_bus_to_OF_node(pbus);
65 	pdn = dn ? PCI_DN(dn) : NULL;
66 
67 	return pdn;
68 }
69 
70 struct pci_dn *pci_get_pdn_by_devfn(struct pci_bus *bus,
71 				    int devfn)
72 {
73 	struct device_node *dn = NULL;
74 	struct pci_dn *parent, *pdn;
75 	struct pci_dev *pdev = NULL;
76 
77 	/* Fast path: fetch from PCI device */
78 	list_for_each_entry(pdev, &bus->devices, bus_list) {
79 		if (pdev->devfn == devfn) {
80 			if (pdev->dev.archdata.pci_data)
81 				return pdev->dev.archdata.pci_data;
82 
83 			dn = pci_device_to_OF_node(pdev);
84 			break;
85 		}
86 	}
87 
88 	/* Fast path: fetch from device node */
89 	pdn = dn ? PCI_DN(dn) : NULL;
90 	if (pdn)
91 		return pdn;
92 
93 	/* Slow path: fetch from firmware data hierarchy */
94 	parent = pci_bus_to_pdn(bus);
95 	if (!parent)
96 		return NULL;
97 
98 	list_for_each_entry(pdn, &parent->child_list, list) {
99 		if (pdn->busno == bus->number &&
100                     pdn->devfn == devfn)
101                         return pdn;
102         }
103 
104 	return NULL;
105 }
106 
107 struct pci_dn *pci_get_pdn(struct pci_dev *pdev)
108 {
109 	struct device_node *dn;
110 	struct pci_dn *parent, *pdn;
111 
112 	/* Search device directly */
113 	if (pdev->dev.archdata.pci_data)
114 		return pdev->dev.archdata.pci_data;
115 
116 	/* Check device node */
117 	dn = pci_device_to_OF_node(pdev);
118 	pdn = dn ? PCI_DN(dn) : NULL;
119 	if (pdn)
120 		return pdn;
121 
122 	/*
123 	 * VFs don't have device nodes. We hook their
124 	 * firmware data to PF's bridge.
125 	 */
126 	parent = pci_bus_to_pdn(pdev->bus);
127 	if (!parent)
128 		return NULL;
129 
130 	list_for_each_entry(pdn, &parent->child_list, list) {
131 		if (pdn->busno == pdev->bus->number &&
132 		    pdn->devfn == pdev->devfn)
133 			return pdn;
134 	}
135 
136 	return NULL;
137 }
138 
139 #ifdef CONFIG_PCI_IOV
140 static struct pci_dn *add_one_dev_pci_data(struct pci_dn *parent,
141 					   struct pci_dev *pdev,
142 					   int busno, int devfn)
143 {
144 	struct pci_dn *pdn;
145 
146 	/* Except PHB, we always have the parent */
147 	if (!parent)
148 		return NULL;
149 
150 	pdn = kzalloc(sizeof(*pdn), GFP_KERNEL);
151 	if (!pdn) {
152 		dev_warn(&pdev->dev, "%s: Out of memory!\n", __func__);
153 		return NULL;
154 	}
155 
156 	pdn->phb = parent->phb;
157 	pdn->parent = parent;
158 	pdn->busno = busno;
159 	pdn->devfn = devfn;
160 #ifdef CONFIG_PPC_POWERNV
161 	pdn->pe_number = IODA_INVALID_PE;
162 #endif
163 	INIT_LIST_HEAD(&pdn->child_list);
164 	INIT_LIST_HEAD(&pdn->list);
165 	list_add_tail(&pdn->list, &parent->child_list);
166 
167 	/*
168 	 * If we already have PCI device instance, lets
169 	 * bind them.
170 	 */
171 	if (pdev)
172 		pdev->dev.archdata.pci_data = pdn;
173 
174 	return pdn;
175 }
176 #endif
177 
178 struct pci_dn *add_dev_pci_data(struct pci_dev *pdev)
179 {
180 #ifdef CONFIG_PCI_IOV
181 	struct pci_dn *parent, *pdn;
182 	int i;
183 
184 	/* Only support IOV for now */
185 	if (!pdev->is_physfn)
186 		return pci_get_pdn(pdev);
187 
188 	/* Check if VFs have been populated */
189 	pdn = pci_get_pdn(pdev);
190 	if (!pdn || (pdn->flags & PCI_DN_FLAG_IOV_VF))
191 		return NULL;
192 
193 	pdn->flags |= PCI_DN_FLAG_IOV_VF;
194 	parent = pci_bus_to_pdn(pdev->bus);
195 	if (!parent)
196 		return NULL;
197 
198 	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
199 		pdn = add_one_dev_pci_data(parent, NULL,
200 					   pci_iov_virtfn_bus(pdev, i),
201 					   pci_iov_virtfn_devfn(pdev, i));
202 		if (!pdn) {
203 			dev_warn(&pdev->dev, "%s: Cannot create firmware data for VF#%d\n",
204 				 __func__, i);
205 			return NULL;
206 		}
207 	}
208 #endif /* CONFIG_PCI_IOV */
209 
210 	return pci_get_pdn(pdev);
211 }
212 
213 void remove_dev_pci_data(struct pci_dev *pdev)
214 {
215 #ifdef CONFIG_PCI_IOV
216 	struct pci_dn *parent;
217 	struct pci_dn *pdn, *tmp;
218 	int i;
219 
220 	/*
221 	 * VF and VF PE are created/released dynamically, so we need to
222 	 * bind/unbind them.  Otherwise the VF and VF PE would be mismatched
223 	 * when re-enabling SR-IOV.
224 	 */
225 	if (pdev->is_virtfn) {
226 		pdn = pci_get_pdn(pdev);
227 #ifdef CONFIG_PPC_POWERNV
228 		pdn->pe_number = IODA_INVALID_PE;
229 #endif
230 		return;
231 	}
232 
233 	/* Only support IOV PF for now */
234 	if (!pdev->is_physfn)
235 		return;
236 
237 	/* Check if VFs have been populated */
238 	pdn = pci_get_pdn(pdev);
239 	if (!pdn || !(pdn->flags & PCI_DN_FLAG_IOV_VF))
240 		return;
241 
242 	pdn->flags &= ~PCI_DN_FLAG_IOV_VF;
243 	parent = pci_bus_to_pdn(pdev->bus);
244 	if (!parent)
245 		return;
246 
247 	/*
248 	 * We might introduce flag to pci_dn in future
249 	 * so that we can release VF's firmware data in
250 	 * a batch mode.
251 	 */
252 	for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) {
253 		list_for_each_entry_safe(pdn, tmp,
254 			&parent->child_list, list) {
255 			if (pdn->busno != pci_iov_virtfn_bus(pdev, i) ||
256 			    pdn->devfn != pci_iov_virtfn_devfn(pdev, i))
257 				continue;
258 
259 			if (!list_empty(&pdn->list))
260 				list_del(&pdn->list);
261 
262 			kfree(pdn);
263 		}
264 	}
265 #endif /* CONFIG_PCI_IOV */
266 }
267 
268 /*
269  * Traverse_func that inits the PCI fields of the device node.
270  * NOTE: this *must* be done before read/write config to the device.
271  */
272 void *update_dn_pci_info(struct device_node *dn, void *data)
273 {
274 	struct pci_controller *phb = data;
275 	const __be32 *type = of_get_property(dn, "ibm,pci-config-space-type", NULL);
276 	const __be32 *regs;
277 	struct device_node *parent;
278 	struct pci_dn *pdn;
279 
280 	pdn = zalloc_maybe_bootmem(sizeof(*pdn), GFP_KERNEL);
281 	if (pdn == NULL)
282 		return NULL;
283 	dn->data = pdn;
284 	pdn->node = dn;
285 	pdn->phb = phb;
286 #ifdef CONFIG_PPC_POWERNV
287 	pdn->pe_number = IODA_INVALID_PE;
288 #endif
289 	regs = of_get_property(dn, "reg", NULL);
290 	if (regs) {
291 		u32 addr = of_read_number(regs, 1);
292 
293 		/* First register entry is addr (00BBSS00)  */
294 		pdn->busno = (addr >> 16) & 0xff;
295 		pdn->devfn = (addr >> 8) & 0xff;
296 	}
297 
298 	/* vendor/device IDs and class code */
299 	regs = of_get_property(dn, "vendor-id", NULL);
300 	pdn->vendor_id = regs ? of_read_number(regs, 1) : 0;
301 	regs = of_get_property(dn, "device-id", NULL);
302 	pdn->device_id = regs ? of_read_number(regs, 1) : 0;
303 	regs = of_get_property(dn, "class-code", NULL);
304 	pdn->class_code = regs ? of_read_number(regs, 1) : 0;
305 
306 	/* Extended config space */
307 	pdn->pci_ext_config_space = (type && of_read_number(type, 1) == 1);
308 
309 	/* Attach to parent node */
310 	INIT_LIST_HEAD(&pdn->child_list);
311 	INIT_LIST_HEAD(&pdn->list);
312 	parent = of_get_parent(dn);
313 	pdn->parent = parent ? PCI_DN(parent) : NULL;
314 	if (pdn->parent)
315 		list_add_tail(&pdn->list, &pdn->parent->child_list);
316 
317 	return NULL;
318 }
319 
320 /*
321  * Traverse a device tree stopping each PCI device in the tree.
322  * This is done depth first.  As each node is processed, a "pre"
323  * function is called and the children are processed recursively.
324  *
325  * The "pre" func returns a value.  If non-zero is returned from
326  * the "pre" func, the traversal stops and this value is returned.
327  * This return value is useful when using traverse as a method of
328  * finding a device.
329  *
330  * NOTE: we do not run the func for devices that do not appear to
331  * be PCI except for the start node which we assume (this is good
332  * because the start node is often a phb which may be missing PCI
333  * properties).
334  * We use the class-code as an indicator. If we run into
335  * one of these nodes we also assume its siblings are non-pci for
336  * performance.
337  */
338 void *traverse_pci_devices(struct device_node *start, traverse_func pre,
339 		void *data)
340 {
341 	struct device_node *dn, *nextdn;
342 	void *ret;
343 
344 	/* We started with a phb, iterate all childs */
345 	for (dn = start->child; dn; dn = nextdn) {
346 		const __be32 *classp;
347 		u32 class = 0;
348 
349 		nextdn = NULL;
350 		classp = of_get_property(dn, "class-code", NULL);
351 		if (classp)
352 			class = of_read_number(classp, 1);
353 
354 		if (pre && ((ret = pre(dn, data)) != NULL))
355 			return ret;
356 
357 		/* If we are a PCI bridge, go down */
358 		if (dn->child && ((class >> 8) == PCI_CLASS_BRIDGE_PCI ||
359 				  (class >> 8) == PCI_CLASS_BRIDGE_CARDBUS))
360 			/* Depth first...do children */
361 			nextdn = dn->child;
362 		else if (dn->sibling)
363 			/* ok, try next sibling instead. */
364 			nextdn = dn->sibling;
365 		if (!nextdn) {
366 			/* Walk up to next valid sibling. */
367 			do {
368 				dn = dn->parent;
369 				if (dn == start)
370 					return NULL;
371 			} while (dn->sibling == NULL);
372 			nextdn = dn->sibling;
373 		}
374 	}
375 	return NULL;
376 }
377 
378 static struct pci_dn *pci_dn_next_one(struct pci_dn *root,
379 				      struct pci_dn *pdn)
380 {
381 	struct list_head *next = pdn->child_list.next;
382 
383 	if (next != &pdn->child_list)
384 		return list_entry(next, struct pci_dn, list);
385 
386 	while (1) {
387 		if (pdn == root)
388 			return NULL;
389 
390 		next = pdn->list.next;
391 		if (next != &pdn->parent->child_list)
392 			break;
393 
394 		pdn = pdn->parent;
395 	}
396 
397 	return list_entry(next, struct pci_dn, list);
398 }
399 
400 void *traverse_pci_dn(struct pci_dn *root,
401 		      void *(*fn)(struct pci_dn *, void *),
402 		      void *data)
403 {
404 	struct pci_dn *pdn = root;
405 	void *ret;
406 
407 	/* Only scan the child nodes */
408 	for (pdn = pci_dn_next_one(root, pdn); pdn;
409 	     pdn = pci_dn_next_one(root, pdn)) {
410 		ret = fn(pdn, data);
411 		if (ret)
412 			return ret;
413 	}
414 
415 	return NULL;
416 }
417 
418 /**
419  * pci_devs_phb_init_dynamic - setup pci devices under this PHB
420  * phb: pci-to-host bridge (top-level bridge connecting to cpu)
421  *
422  * This routine is called both during boot, (before the memory
423  * subsystem is set up, before kmalloc is valid) and during the
424  * dynamic lpar operation of adding a PHB to a running system.
425  */
426 void pci_devs_phb_init_dynamic(struct pci_controller *phb)
427 {
428 	struct device_node *dn = phb->dn;
429 	struct pci_dn *pdn;
430 
431 	/* PHB nodes themselves must not match */
432 	update_dn_pci_info(dn, phb);
433 	pdn = dn->data;
434 	if (pdn) {
435 		pdn->devfn = pdn->busno = -1;
436 		pdn->vendor_id = pdn->device_id = pdn->class_code = 0;
437 		pdn->phb = phb;
438 		phb->pci_data = pdn;
439 	}
440 
441 	/* Update dn->phb ptrs for new phb and children devices */
442 	traverse_pci_devices(dn, update_dn_pci_info, phb);
443 }
444 
445 /**
446  * pci_devs_phb_init - Initialize phbs and pci devs under them.
447  *
448  * This routine walks over all phb's (pci-host bridges) on the
449  * system, and sets up assorted pci-related structures
450  * (including pci info in the device node structs) for each
451  * pci device found underneath.  This routine runs once,
452  * early in the boot sequence.
453  */
454 void __init pci_devs_phb_init(void)
455 {
456 	struct pci_controller *phb, *tmp;
457 
458 	/* This must be done first so the device nodes have valid pci info! */
459 	list_for_each_entry_safe(phb, tmp, &hose_list, list_node)
460 		pci_devs_phb_init_dynamic(phb);
461 }
462 
463 static void pci_dev_pdn_setup(struct pci_dev *pdev)
464 {
465 	struct pci_dn *pdn;
466 
467 	if (pdev->dev.archdata.pci_data)
468 		return;
469 
470 	/* Setup the fast path */
471 	pdn = pci_get_pdn(pdev);
472 	pdev->dev.archdata.pci_data = pdn;
473 }
474 DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, pci_dev_pdn_setup);
475