xref: /illumos-gate/usr/src/lib/fm/topo/modules/common/pcibus/pcibus.c (revision 1be2e5dfebda7cac010af97aae7a3a1b45649aed)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/fm/protocol.h>
30 #include <assert.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <strings.h>
35 #include <alloca.h>
36 #include <sys/param.h>
37 #include <sys/pci.h>
38 #include <sys/pcie.h>
39 #include <libdevinfo.h>
40 #include <libnvpair.h>
41 #include <fm/topo_mod.h>
42 #include <fm/topo_hc.h>
43 
44 #include <hostbridge.h>
45 #include <pcibus.h>
46 #include <did.h>
47 #include <did_props.h>
48 #include <util.h>
49 
50 extern txprop_t Bus_common_props[];
51 extern txprop_t Dev_common_props[];
52 extern txprop_t Fn_common_props[];
53 extern int Bus_propcnt;
54 extern int Dev_propcnt;
55 extern int Fn_propcnt;
56 
57 extern int platform_pci_label(topo_mod_t *mod, tnode_t *, nvlist_t *,
58     nvlist_t **);
59 extern int platform_pci_fru(topo_mod_t *mod, tnode_t *, nvlist_t *,
60     nvlist_t **);
61 static void pci_release(topo_mod_t *, tnode_t *);
62 static int pci_enum(topo_mod_t *, tnode_t *, const char *, topo_instance_t,
63     topo_instance_t, void *, void *);
64 static int pci_label(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
65     nvlist_t **);
66 static int pci_fru(topo_mod_t *, tnode_t *, topo_version_t, nvlist_t *,
67     nvlist_t **);
68 
69 static const topo_modops_t Pci_ops =
70 	{ pci_enum, pci_release };
71 static const topo_modinfo_t Pci_info =
72 	{ PCI_BUS, FM_FMRI_SCHEME_HC, PCI_ENUMR_VERS, &Pci_ops };
73 
74 static const topo_method_t Pci_methods[] = {
75 	{ TOPO_METH_LABEL, TOPO_METH_LABEL_DESC,
76 	    TOPO_METH_LABEL_VERSION, TOPO_STABILITY_INTERNAL, pci_label },
77 	{ TOPO_METH_FRU_COMPUTE, TOPO_METH_FRU_COMPUTE_DESC,
78 	    TOPO_METH_FRU_COMPUTE_VERSION, TOPO_STABILITY_INTERNAL, pci_fru },
79 	{ NULL }
80 };
81 
82 int
83 _topo_init(topo_mod_t *modhdl, topo_version_t version)
84 {
85 	/*
86 	 * Turn on module debugging output
87 	 */
88 	if (getenv("TOPOPCIDBG") != NULL)
89 		topo_mod_setdebug(modhdl);
90 	topo_mod_dprintf(modhdl, "initializing pcibus builtin\n");
91 
92 	if (version != PCI_ENUMR_VERS)
93 		return (topo_mod_seterrno(modhdl, EMOD_VER_NEW));
94 
95 	topo_mod_register(modhdl, &Pci_info, TOPO_VERSION);
96 	topo_mod_dprintf(modhdl, "PCI Enumr initd\n");
97 
98 	return (0);
99 }
100 
101 void
102 _topo_fini(topo_mod_t *modhdl)
103 {
104 	topo_mod_unregister(modhdl);
105 }
106 
107 static int
108 pci_label(topo_mod_t *mp, tnode_t *node, topo_version_t version,
109     nvlist_t *in, nvlist_t **out)
110 {
111 	if (version > TOPO_METH_LABEL_VERSION)
112 		return (topo_mod_seterrno(mp, EMOD_VER_NEW));
113 	return (platform_pci_label(mp, node, in, out));
114 }
115 static int
116 pci_fru(topo_mod_t *mp, tnode_t *node, topo_version_t version,
117     nvlist_t *in, nvlist_t **out)
118 {
119 	if (version > TOPO_METH_FRU_COMPUTE_VERSION)
120 		return (topo_mod_seterrno(mp, EMOD_VER_NEW));
121 	return (platform_pci_fru(mp, node, in, out));
122 }
123 static tnode_t *
124 pci_tnode_create(topo_mod_t *mod, tnode_t *parent,
125     const char *name, topo_instance_t i, void *priv)
126 {
127 	tnode_t *ntn;
128 
129 	if ((ntn = tnode_create(mod, parent, name, i, priv)) == NULL)
130 		return (NULL);
131 	if (topo_method_register(mod, ntn, Pci_methods) < 0) {
132 		topo_mod_dprintf(mod, "topo_method_register failed: %s\n",
133 		    topo_strerror(topo_mod_errno(mod)));
134 		topo_node_unbind(ntn);
135 		return (NULL);
136 	}
137 	return (ntn);
138 }
139 
140 /*ARGSUSED*/
141 static int
142 hostbridge_asdevice(topo_mod_t *mod, tnode_t *bus)
143 {
144 	di_node_t di;
145 	tnode_t *dev32;
146 
147 	di = topo_node_getspecific(bus);
148 	assert(di != DI_NODE_NIL);
149 
150 	if ((dev32 = pcidev_declare(mod, bus, di, 32)) == NULL)
151 		return (-1);
152 	if (pcifn_declare(mod, dev32, di, 0) == NULL) {
153 		topo_node_unbind(dev32);
154 		return (-1);
155 	}
156 	return (0);
157 }
158 
159 tnode_t *
160 pciexfn_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
161     topo_instance_t i)
162 {
163 	did_t *pd;
164 	tnode_t *ntn;
165 
166 	if ((pd = did_find(mod, dn)) == NULL)
167 		return (NULL);
168 	if ((ntn = pci_tnode_create(mod, parent, PCIEX_FUNCTION, i, dn))
169 	    == NULL)
170 		return (NULL);
171 	if (did_props_set(ntn, pd, Fn_common_props, Fn_propcnt) < 0) {
172 		topo_node_unbind(ntn);
173 		return (NULL);
174 	}
175 	/*
176 	 * We may find pci-express buses or plain-pci buses beneath a function
177 	 */
178 	if (child_range_add(mod, ntn, PCIEX_BUS, 0, MAX_HB_BUSES) < 0) {
179 		topo_node_unbind(ntn);
180 		return (NULL);
181 	}
182 	if (child_range_add(mod, ntn, PCI_BUS, 0, MAX_HB_BUSES) < 0) {
183 		topo_node_range_destroy(ntn, PCIEX_BUS);
184 		topo_node_unbind(ntn);
185 		return (NULL);
186 	}
187 	return (ntn);
188 }
189 
190 tnode_t *
191 pciexdev_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
192     topo_instance_t i)
193 {
194 	did_t *pd;
195 	tnode_t *ntn;
196 
197 	if ((pd = did_find(mod, dn)) == NULL)
198 		return (NULL);
199 	did_settnode(pd, parent);
200 
201 	if ((ntn = pci_tnode_create(mod, parent, PCIEX_DEVICE, i, dn)) == NULL)
202 		return (NULL);
203 	if (did_props_set(ntn, pd, Dev_common_props, Dev_propcnt) < 0) {
204 		topo_node_unbind(ntn);
205 		return (NULL);
206 	}
207 
208 	/*
209 	 * We can expect to find pci-express functions beneath the device
210 	 */
211 	if (child_range_add(mod,
212 	    ntn, PCIEX_FUNCTION, 0, MAX_PCIDEV_FNS) < 0) {
213 		topo_node_unbind(ntn);
214 		return (NULL);
215 	}
216 	return (ntn);
217 }
218 
219 tnode_t *
220 pciexbus_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
221     topo_instance_t i)
222 {
223 	did_t *pd;
224 	tnode_t *ntn;
225 
226 	if ((pd = did_find(mod, dn)) == NULL)
227 		return (NULL);
228 	did_settnode(pd, parent);
229 	if ((ntn = pci_tnode_create(mod, parent, PCIEX_BUS, i, dn)) == NULL)
230 		return (NULL);
231 	if (did_props_set(ntn, pd, Bus_common_props, Bus_propcnt) < 0) {
232 		topo_node_unbind(ntn);
233 		return (NULL);
234 	}
235 	/*
236 	 * We can expect to find pci-express devices beneath the bus
237 	 */
238 	if (child_range_add(mod,
239 	    ntn, PCIEX_DEVICE, 0, MAX_PCIBUS_DEVS) < 0) {
240 		topo_node_unbind(ntn);
241 		return (NULL);
242 	}
243 	return (ntn);
244 }
245 
246 tnode_t *
247 pcifn_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
248     topo_instance_t i)
249 {
250 	did_t *pd;
251 	tnode_t *ntn;
252 
253 	if ((pd = did_find(mod, dn)) == NULL)
254 		return (NULL);
255 	if ((ntn = pci_tnode_create(mod, parent, PCI_FUNCTION, i, dn)) == NULL)
256 		return (NULL);
257 	if (did_props_set(ntn, pd, Fn_common_props, Fn_propcnt) < 0) {
258 		topo_node_unbind(ntn);
259 		return (NULL);
260 	}
261 	/*
262 	 * We may find pci buses beneath a function
263 	 */
264 	if (child_range_add(mod, ntn, PCI_BUS, 0, MAX_HB_BUSES) < 0) {
265 		topo_node_unbind(ntn);
266 		return (NULL);
267 	}
268 	return (ntn);
269 }
270 
271 tnode_t *
272 pcidev_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
273     topo_instance_t i)
274 {
275 	did_t *pd;
276 	tnode_t *ntn;
277 
278 	if ((pd = did_find(mod, dn)) == NULL)
279 		return (NULL);
280 	/* remember parent tnode */
281 	did_settnode(pd, parent);
282 
283 	if ((ntn = pci_tnode_create(mod, parent, PCI_DEVICE, i, dn)) == NULL)
284 		return (NULL);
285 	if (did_props_set(ntn, pd, Dev_common_props, Dev_propcnt) < 0) {
286 		topo_node_unbind(ntn);
287 		return (NULL);
288 	}
289 
290 	/*
291 	 * We can expect to find pci functions beneath the device
292 	 */
293 	if (child_range_add(mod, ntn, PCI_FUNCTION, 0, MAX_PCIDEV_FNS) < 0) {
294 		topo_node_unbind(ntn);
295 		return (NULL);
296 	}
297 	return (ntn);
298 }
299 
300 tnode_t *
301 pcibus_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
302     topo_instance_t i)
303 {
304 	did_t *pd;
305 	tnode_t *ntn;
306 	int hbchild = 0;
307 
308 	if ((pd = did_find(mod, dn)) == NULL)
309 		return (NULL);
310 	did_settnode(pd, parent);
311 	if ((ntn = pci_tnode_create(mod, parent, PCI_BUS, i, dn)) == NULL)
312 		return (NULL);
313 	/*
314 	 * If our devinfo node is lacking certain information of its
315 	 * own, and our parent topology node is a hostbridge, we may
316 	 * need/want to inherit information available in the
317 	 * hostbridge node's private data.
318 	 */
319 	if (strcmp(topo_node_name(parent), HOSTBRIDGE) == 0)
320 		hbchild = 1;
321 	if (did_props_set(ntn, pd, Bus_common_props, Bus_propcnt) < 0) {
322 		topo_node_unbind(ntn);
323 		return (NULL);
324 	}
325 	/*
326 	 * We can expect to find pci devices beneath the bus
327 	 */
328 	if (child_range_add(mod, ntn, PCI_DEVICE, 0, MAX_PCIBUS_DEVS) < 0) {
329 		topo_node_unbind(ntn);
330 		return (NULL);
331 	}
332 	/*
333 	 * On each bus child of the hostbridge, we represent the
334 	 * hostbridge as a device outside the range of legal device
335 	 * numbers.
336 	 */
337 	if (hbchild == 1) {
338 		if (hostbridge_asdevice(mod, ntn) < 0) {
339 			topo_node_range_destroy(ntn, PCI_DEVICE);
340 			topo_node_unbind(ntn);
341 			return (NULL);
342 		}
343 	}
344 	return (ntn);
345 }
346 
347 static int
348 pci_bridge_declare(topo_mod_t *mod, tnode_t *fn, di_node_t din, int board,
349     int bridge, int rc, int depth)
350 {
351 	int err, excap, extyp;
352 
353 	excap = pciex_cap_get(mod, din);
354 	extyp = excap & PCIE_PCIECAP_DEV_TYPE_MASK;
355 	if (excap <= 0 ||
356 	    extyp != PCIE_PCIECAP_DEV_TYPE_PCIE2PCI)
357 		err = pci_children_instantiate(mod, fn, din, board, bridge,
358 		    rc, TRUST_BDF, depth + 1);
359 	else
360 		err = pci_children_instantiate(mod, fn, din, board, bridge,
361 		    rc - TO_PCI, TRUST_BDF, depth + 1);
362 	return (err);
363 }
364 
365 static void
366 declare_dev_and_fn(topo_mod_t *mod, tnode_t *bus, tnode_t **dev, di_node_t din,
367     int board, int bridge, int rc, int devno, int fnno, int depth)
368 {
369 	int dcnt = 0;
370 	tnode_t *fn;
371 	uint_t class, subclass;
372 	uint_t vid, did;
373 
374 	if (*dev == NULL) {
375 		if (rc >= 0)
376 			*dev = pciexdev_declare(mod, bus, din, devno);
377 		else
378 			*dev = pcidev_declare(mod, bus, din, devno);
379 		if (*dev == NULL)
380 			return;
381 		++dcnt;
382 	}
383 	if (rc >= 0)
384 		fn = pciexfn_declare(mod, *dev, din, fnno);
385 	else
386 		fn = pcifn_declare(mod, *dev, din, fnno);
387 
388 	if (fn == NULL) {
389 		if (dcnt) {
390 			topo_node_unbind(*dev);
391 			*dev = NULL;
392 		}
393 		return;
394 	}
395 
396 	if (pci_classcode_get(mod, din, &class, &subclass) < 0) {
397 		topo_node_unbind(fn);
398 		if (dcnt)
399 			topo_node_unbind(*dev);
400 		return;
401 	}
402 
403 	/*
404 	 * This function may be a bridge.  If not, check for a possible
405 	 * topology map file and kick off its enumeration of lower-level
406 	 * devices.
407 	 */
408 	if (class == PCI_CLASS_BRIDGE && subclass == PCI_BRIDGE_PCI) {
409 		(void) pci_bridge_declare(mod, fn, din, board, bridge, rc,
410 		    depth);
411 	}
412 	/*
413 	 * Use xfp-hc-topology.xml to expand topology to include the XFP optical
414 	 * module, which is a FRU on the Neptune based 10giga fiber NICs.
415 	 */
416 	else if (class == PCI_CLASS_NET &&
417 	    di_uintprop_get(mod, din, DI_VENDIDPROP, &vid) >= 0 &&
418 	    di_uintprop_get(mod, din, DI_DEVIDPROP, &did) >= 0) {
419 		if (vid == SUN_VENDOR_ID && did == NEPTUNE_DEVICE_ID) {
420 			(void) topo_mod_enummap(mod, fn,
421 			    "xfp", FM_FMRI_SCHEME_HC);
422 		}
423 	}
424 }
425 
426 int
427 pci_children_instantiate(topo_mod_t *mod, tnode_t *parent, di_node_t pn,
428     int board, int bridge, int rc, int bover, int depth)
429 {
430 	did_t *pps[MAX_PCIBUS_DEVS][MAX_PCIDEV_FNS];
431 	did_t *bp = NULL;
432 	did_t *np;
433 	di_node_t sib;
434 	di_node_t din;
435 	tnode_t *bn = NULL;
436 	tnode_t *dn = NULL;
437 	int pb = -1;
438 	int b, d, f;
439 
440 	for (d = 0; d < MAX_PCIBUS_DEVS; d++)
441 		for (f = 0; f < MAX_PCIDEV_FNS; f++)
442 			pps[d][f] = NULL;
443 
444 	/* start at the parent's first sibling */
445 	sib = di_child_node(pn);
446 	while (sib != DI_NODE_NIL) {
447 		np = did_create(mod, sib, board, bridge, rc, bover);
448 		if (np == NULL)
449 			return (-1);
450 		did_BDF(np, &b, &d, &f);
451 		pps[d][f] = np;
452 		if (bp == NULL)
453 			bp = np;
454 		if (pb < 0)
455 			pb = ((bover == TRUST_BDF) ? b : bover);
456 		sib = di_sibling_node(sib);
457 	}
458 	if (pb < 0 && bover < 0)
459 		return (0);
460 	if (rc >= 0)
461 		bn = pciexbus_declare(mod, parent, pn, ((pb < 0) ? bover : pb));
462 	else
463 		bn = pcibus_declare(mod, parent, pn, ((pb < 0) ? bover : pb));
464 	if (bn == NULL)
465 		return (-1);
466 	if (pb < 0)
467 		return (0);
468 
469 	for (d = 0; d < MAX_PCIBUS_DEVS; d++) {
470 		for (f = 0; f < MAX_PCIDEV_FNS; f++) {
471 			if (pps[d][f] == NULL)
472 				continue;
473 			din = did_dinode(pps[d][f]);
474 
475 			/*
476 			 * Try to enumerate as many devices and functions as
477 			 * possible.  If we fail to declare a device, break
478 			 * out of the function loop.
479 			 */
480 			declare_dev_and_fn(mod, bn,
481 			    &dn, din, board, bridge, rc, d, f, depth);
482 			did_rele(pps[d][f]);
483 
484 			if (dn == NULL)
485 				break;
486 		}
487 		dn = NULL;
488 	}
489 	return (0);
490 }
491 
492 static int
493 pciexbus_enum(topo_mod_t *mp, tnode_t *ptn, char *pnm, topo_instance_t min,
494     topo_instance_t max)
495 {
496 	di_node_t pdn;
497 	int rc;
498 	int retval;
499 
500 	/*
501 	 * PCI-Express; root complex shares the hostbridge's instance
502 	 * number.  Parent node's private data is a simple di_node_t
503 	 * and we have to construct our own did hash and did_t.
504 	 */
505 	rc = topo_node_instance(ptn);
506 
507 	if ((pdn = topo_node_getspecific(ptn)) == DI_NODE_NIL) {
508 		topo_mod_dprintf(mp,
509 		    "Parent %s node missing private data.\n"
510 		    "Unable to proceed with %s enumeration.\n", pnm, PCIEX_BUS);
511 		return (0);
512 	}
513 	if (did_hash_init(mp) != 0)
514 		return (-1);
515 	if ((did_create(mp, pdn, 0, 0, rc, TRUST_BDF)) == NULL)
516 		return (-1);	/* errno already set */
517 
518 	retval = pci_children_instantiate(mp, ptn, pdn, 0, 0, rc,
519 	    (min == max) ? min : TRUST_BDF, 0);
520 	did_hash_fini(mp);
521 
522 	return (retval);
523 }
524 
525 static int
526 pcibus_enum(topo_mod_t *mp, tnode_t *ptn, char *pnm, topo_instance_t min,
527     topo_instance_t max, void *data)
528 {
529 	did_t *didp, *hbdid = (did_t *)data;
530 	int retval;
531 
532 	/*
533 	 * XXTOPO: we should not be sharing private node data with another
534 	 * module. PCI Bus; Parent node's private data is a did_t.  We'll
535 	 * use the did hash established by the parent.
536 	 */
537 	did_setspecific(mp, data);
538 
539 	/*
540 	 * If we're looking for a specific bus-instance, find the right
541 	 * did_t in the chain, otherwise, there should be only one did_t.
542 	 */
543 	if (min == max) {
544 		int b;
545 		didp = hbdid;
546 		while (didp != NULL) {
547 			did_BDF(didp, &b, NULL, NULL);
548 			if (b == min)
549 				break;
550 			didp = did_link_get(didp);
551 		}
552 		if (didp == NULL) {
553 			topo_mod_dprintf(mp,
554 			    "Parent %s node missing private data related\n"
555 			    "to %s instance %d.\n", pnm, PCI_BUS, min);
556 			topo_mod_setspecific(mp, NULL);
557 			return (0);
558 		}
559 	} else {
560 		assert(did_link_get(hbdid) == NULL);
561 		didp = hbdid;
562 	}
563 	retval = pci_children_instantiate(mp, ptn, did_dinode(didp),
564 	    did_board(didp), did_bridge(didp), did_rc(didp),
565 	    (min == max) ? min : TRUST_BDF, 0);
566 
567 	topo_mod_setspecific(mp, NULL);
568 
569 	return (retval);
570 }
571 
572 /*ARGSUSED*/
573 static int
574 pci_enum(topo_mod_t *mod, tnode_t *ptn, const char *name,
575     topo_instance_t min, topo_instance_t max, void *notused, void *data)
576 {
577 	int retval;
578 	char *pname;
579 
580 	topo_mod_dprintf(mod, "Enumerating pci!\n");
581 
582 	if (strcmp(name, PCI_BUS) != 0 && strcmp(name, PCIEX_BUS) != 0) {
583 		topo_mod_dprintf(mod,
584 		    "Currently only know how to enumerate %s or %s.\n",
585 		    PCI_BUS, PCIEX_BUS);
586 		return (0);
587 	}
588 	pname = topo_node_name(ptn);
589 	if (strcmp(pname, HOSTBRIDGE) != 0 && strcmp(pname, PCIEX_ROOT) != 0) {
590 		topo_mod_dprintf(mod,
591 		    "Currently can only enumerate a %s or %s directly\n",
592 		    PCI_BUS, PCIEX_BUS);
593 		topo_mod_dprintf(mod,
594 		    "descended from a %s or %s node.\n",
595 		    HOSTBRIDGE, PCIEX_ROOT);
596 		return (0);
597 	}
598 
599 	if (strcmp(name, PCI_BUS) == 0) {
600 		retval = pcibus_enum(mod, ptn, pname, min, max, data);
601 	} else if (strcmp(name, PCIEX_BUS) == 0) {
602 		retval = pciexbus_enum(mod, ptn, pname, min, max);
603 	} else {
604 		topo_mod_dprintf(mod,
605 		    "Currently only know how to enumerate %s or %s not %s.\n",
606 		    PCI_BUS, PCIEX_BUS, name);
607 		return (0);
608 	}
609 
610 	return (retval);
611 }
612 
613 /*ARGSUSED*/
614 static void
615 pci_release(topo_mod_t *mp, tnode_t *node)
616 {
617 	topo_method_unregister_all(mp, node);
618 
619 	/*
620 	 * node private data (did_t) for this node is destroyed in
621 	 * did_hash_destroy()
622 	 */
623 
624 	topo_node_unbind(node);
625 }
626