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 	if ((ntn = pci_tnode_create(mod, parent, PCIEX_BUS, i, dn)) == NULL)
229 		return (NULL);
230 	if (did_props_set(ntn, pd, Bus_common_props, Bus_propcnt) < 0) {
231 		topo_node_unbind(ntn);
232 		return (NULL);
233 	}
234 	/*
235 	 * We can expect to find pci-express devices beneath the bus
236 	 */
237 	if (child_range_add(mod,
238 	    ntn, PCIEX_DEVICE, 0, MAX_PCIBUS_DEVS) < 0) {
239 		topo_node_unbind(ntn);
240 		return (NULL);
241 	}
242 	return (ntn);
243 }
244 
245 tnode_t *
246 pcifn_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
247     topo_instance_t i)
248 {
249 	did_t *pd;
250 	tnode_t *ntn;
251 
252 	if ((pd = did_find(mod, dn)) == NULL)
253 		return (NULL);
254 	if ((ntn = pci_tnode_create(mod, parent, PCI_FUNCTION, i, dn)) == NULL)
255 		return (NULL);
256 	if (did_props_set(ntn, pd, Fn_common_props, Fn_propcnt) < 0) {
257 		topo_node_unbind(ntn);
258 		return (NULL);
259 	}
260 	/*
261 	 * We may find pci buses beneath a function
262 	 */
263 	if (child_range_add(mod, ntn, PCI_BUS, 0, MAX_HB_BUSES) < 0) {
264 		topo_node_unbind(ntn);
265 		return (NULL);
266 	}
267 	return (ntn);
268 }
269 
270 tnode_t *
271 pcidev_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
272     topo_instance_t i)
273 {
274 	did_t *pd;
275 	did_t *ppd;
276 	di_node_t pdn;
277 	tnode_t *ntn;
278 
279 	if ((pdn = topo_node_getspecific(parent)) == DI_NODE_NIL)
280 		return (NULL);
281 	if ((ppd = did_find(mod, pdn)) == NULL)
282 		return (NULL);
283 	if ((pd = did_find(mod, dn)) == NULL)
284 		return (NULL);
285 	/* remember parent tnode */
286 	did_settnode(pd, parent);
287 
288 	if ((ntn = pci_tnode_create(mod, parent, PCI_DEVICE, i, dn)) == NULL)
289 		return (NULL);
290 	/*
291 	 * If our devinfo node is lacking certain information of its
292 	 * own, we may need/want to inherit the information available
293 	 * from our parent node's private data.
294 	 */
295 
296 	did_inherit(ppd, pd);
297 	if (did_props_set(ntn, pd, Dev_common_props, Dev_propcnt) < 0) {
298 		topo_node_unbind(ntn);
299 		return (NULL);
300 	}
301 
302 	/*
303 	 * We can expect to find pci functions beneath the device
304 	 */
305 	if (child_range_add(mod, ntn, PCI_FUNCTION, 0, MAX_PCIDEV_FNS) < 0) {
306 		topo_node_unbind(ntn);
307 		return (NULL);
308 	}
309 	return (ntn);
310 }
311 
312 tnode_t *
313 pcibus_declare(topo_mod_t *mod, tnode_t *parent, di_node_t dn,
314     topo_instance_t i)
315 {
316 	did_t *pd;
317 	tnode_t *ntn;
318 	int hbchild = 0;
319 
320 	if ((pd = did_find(mod, dn)) == NULL)
321 		return (NULL);
322 	if ((ntn = pci_tnode_create(mod, parent, PCI_BUS, i, dn)) == NULL)
323 		return (NULL);
324 	/*
325 	 * If our devinfo node is lacking certain information of its
326 	 * own, and our parent topology node is a hostbridge, we may
327 	 * need/want to inherit information available in the
328 	 * hostbridge node's private data.
329 	 */
330 	if (strcmp(topo_node_name(parent), HOSTBRIDGE) == 0)
331 		hbchild = 1;
332 	if (did_props_set(ntn, pd, Bus_common_props, Bus_propcnt) < 0) {
333 		topo_node_unbind(ntn);
334 		return (NULL);
335 	}
336 	/*
337 	 * We can expect to find pci devices beneath the bus
338 	 */
339 	if (child_range_add(mod, ntn, PCI_DEVICE, 0, MAX_PCIBUS_DEVS) < 0) {
340 		topo_node_unbind(ntn);
341 		return (NULL);
342 	}
343 	/*
344 	 * On each bus child of the hostbridge, we represent the
345 	 * hostbridge as a device outside the range of legal device
346 	 * numbers.
347 	 */
348 	if (hbchild == 1) {
349 		if (hostbridge_asdevice(mod, ntn) < 0) {
350 			topo_node_range_destroy(ntn, PCI_DEVICE);
351 			topo_node_unbind(ntn);
352 			return (NULL);
353 		}
354 	}
355 	return (ntn);
356 }
357 
358 static int
359 pci_bridge_declare(topo_mod_t *mod, tnode_t *fn, di_node_t din, int board,
360     int bridge, int rc, int depth)
361 {
362 	int err, excap, extyp;
363 
364 	excap = pciex_cap_get(mod, din);
365 	extyp = excap & PCIE_PCIECAP_DEV_TYPE_MASK;
366 	if (excap <= 0 ||
367 	    extyp != PCIE_PCIECAP_DEV_TYPE_PCIE2PCI)
368 		err = pci_children_instantiate(mod, fn, din, board, bridge,
369 		    rc, TRUST_BDF, depth + 1);
370 	else
371 		err = pci_children_instantiate(mod, fn, din, board, bridge,
372 		    rc - TO_PCI, TRUST_BDF, depth + 1);
373 	return (err);
374 }
375 
376 static void
377 declare_dev_and_fn(topo_mod_t *mod, tnode_t *bus, tnode_t **dev, di_node_t din,
378     int board, int bridge, int rc, int devno, int fnno, int depth)
379 {
380 	int dcnt = 0;
381 	tnode_t *fn;
382 	uint_t class, subclass;
383 
384 	if (*dev == NULL) {
385 		if (rc >= 0)
386 			*dev = pciexdev_declare(mod, bus, din, devno);
387 		else
388 			*dev = pcidev_declare(mod, bus, din, devno);
389 		if (*dev == NULL)
390 			return;
391 		++dcnt;
392 	}
393 	if (rc >= 0)
394 		fn = pciexfn_declare(mod, *dev, din, fnno);
395 	else
396 		fn = pcifn_declare(mod, *dev, din, fnno);
397 
398 	if (fn == NULL) {
399 		if (dcnt) {
400 			topo_node_unbind(*dev);
401 			*dev = NULL;
402 		}
403 		return;
404 	}
405 
406 	if (pci_classcode_get(mod, din, &class, &subclass) < 0) {
407 		topo_node_unbind(fn);
408 		if (dcnt)
409 			topo_node_unbind(*dev);
410 		return;
411 	}
412 
413 	/*
414 	 * This function may be a bridge.  If not, check for a possible
415 	 * topology map file and kick off its enumeration of lower-level
416 	 * devices.
417 	 */
418 	if (class == PCI_CLASS_BRIDGE && subclass == PCI_BRIDGE_PCI)
419 		(void) pci_bridge_declare(mod, fn, din, board, bridge, rc,
420 		    depth);
421 }
422 
423 int
424 pci_children_instantiate(topo_mod_t *mod, tnode_t *parent, di_node_t pn,
425     int board, int bridge, int rc, int bover, int depth)
426 {
427 	did_t *pps[MAX_PCIBUS_DEVS][MAX_PCIDEV_FNS];
428 	did_t *bp = NULL;
429 	did_t *np;
430 	di_node_t sib;
431 	di_node_t din;
432 	tnode_t *bn = NULL;
433 	tnode_t *dn = NULL;
434 	int pb = -1;
435 	int b, d, f;
436 
437 	for (d = 0; d < MAX_PCIBUS_DEVS; d++)
438 		for (f = 0; f < MAX_PCIDEV_FNS; f++)
439 			pps[d][f] = NULL;
440 
441 	/* start at the parent's first sibling */
442 	sib = di_child_node(pn);
443 	while (sib != DI_NODE_NIL) {
444 		np = did_create(mod, sib, board, bridge, rc, bover);
445 		if (np == NULL)
446 			return (-1);
447 		did_BDF(np, &b, &d, &f);
448 		pps[d][f] = np;
449 		if (bp == NULL)
450 			bp = np;
451 		if (pb < 0)
452 			pb = ((bover == TRUST_BDF) ? b : bover);
453 		sib = di_sibling_node(sib);
454 	}
455 	if (pb < 0 && bover < 0)
456 		return (0);
457 	if (rc >= 0)
458 		bn = pciexbus_declare(mod, parent, pn, ((pb < 0) ? bover : pb));
459 	else
460 		bn = pcibus_declare(mod, parent, pn, ((pb < 0) ? bover : pb));
461 	if (bn == NULL)
462 		return (-1);
463 	if (pb < 0)
464 		return (0);
465 
466 	for (d = 0; d < MAX_PCIBUS_DEVS; d++) {
467 		for (f = 0; f < MAX_PCIDEV_FNS; f++) {
468 			if (pps[d][f] == NULL)
469 				continue;
470 			din = did_dinode(pps[d][f]);
471 
472 			/*
473 			 * Try to enumerate as many devices and functions as
474 			 * possible.  If we fail to declare a device, break
475 			 * out of the function loop.
476 			 */
477 			declare_dev_and_fn(mod, bn,
478 			    &dn, din, board, bridge, rc, d, f, depth);
479 			did_rele(pps[d][f]);
480 
481 			if (dn == NULL)
482 				break;
483 		}
484 		dn = NULL;
485 	}
486 	return (0);
487 }
488 
489 static int
490 pciexbus_enum(topo_mod_t *mp, tnode_t *ptn, char *pnm, topo_instance_t min,
491     topo_instance_t max)
492 {
493 	di_node_t pdn;
494 	int rc;
495 	int retval;
496 
497 	/*
498 	 * PCI-Express; root complex shares the hostbridge's instance
499 	 * number.  Parent node's private data is a simple di_node_t
500 	 * and we have to construct our own did hash and did_t.
501 	 */
502 	rc = topo_node_instance(ptn);
503 
504 	if ((pdn = topo_node_getspecific(ptn)) == DI_NODE_NIL) {
505 		topo_mod_dprintf(mp,
506 		    "Parent %s node missing private data.\n"
507 		    "Unable to proceed with %s enumeration.\n", pnm, PCIEX_BUS);
508 		return (0);
509 	}
510 	did_hash_init(mp);
511 	if ((did_create(mp, pdn, 0, 0, rc, TRUST_BDF)) == NULL)
512 		return (-1);	/* errno already set */
513 
514 	retval = pci_children_instantiate(mp, ptn, pdn, 0, 0, rc,
515 	    (min == max) ? min : TRUST_BDF, 0);
516 	did_hash_fini(mp);
517 
518 	return (retval);
519 }
520 
521 static int
522 pcibus_enum(topo_mod_t *mp, tnode_t *ptn, char *pnm, topo_instance_t min,
523     topo_instance_t max, void *data)
524 {
525 	did_t *didp, *hbdid = (did_t *)data;
526 	int retval;
527 
528 	/*
529 	 * XXTOPO: we should not be sharing private node data with another
530 	 * module. PCI Bus; Parent node's private data is a did_t.  We'll
531 	 * use the did hash established by the parent.
532 	 */
533 	did_setspecific(mp, data);
534 
535 	/*
536 	 * If we're looking for a specific bus-instance, find the right
537 	 * did_t in the chain, otherwise, there should be only one did_t.
538 	 */
539 	if (min == max) {
540 		int b;
541 		didp = hbdid;
542 		while (didp != NULL) {
543 			did_BDF(didp, &b, NULL, NULL);
544 			if (b == min)
545 				break;
546 			didp = did_link_get(didp);
547 		}
548 		if (didp == NULL) {
549 			topo_mod_dprintf(mp,
550 			    "Parent %s node missing private data related\n"
551 			    "to %s instance %d.\n", pnm, PCI_BUS, min);
552 			topo_mod_setspecific(mp, NULL);
553 			return (0);
554 		}
555 	} else {
556 		assert(did_link_get(hbdid) == NULL);
557 		didp = hbdid;
558 	}
559 	retval = pci_children_instantiate(mp, ptn, did_dinode(didp),
560 	    did_board(didp), did_bridge(didp), did_rc(didp),
561 	    (min == max) ? min : TRUST_BDF, 0);
562 
563 	topo_mod_setspecific(mp, NULL);
564 
565 	return (retval);
566 }
567 
568 /*ARGSUSED*/
569 static int
570 pci_enum(topo_mod_t *mod, tnode_t *ptn, const char *name,
571     topo_instance_t min, topo_instance_t max, void *notused, void *data)
572 {
573 	int retval;
574 	char *pname;
575 
576 	topo_mod_dprintf(mod, "Enumerating pci!\n");
577 
578 	if (strcmp(name, PCI_BUS) != 0 && strcmp(name, PCIEX_BUS) != 0) {
579 		topo_mod_dprintf(mod,
580 		    "Currently only know how to enumerate %s or %s.\n",
581 		    PCI_BUS, PCIEX_BUS);
582 		return (0);
583 	}
584 	pname = topo_node_name(ptn);
585 	if (strcmp(pname, HOSTBRIDGE) != 0 && strcmp(pname, PCIEX_ROOT) != 0) {
586 		topo_mod_dprintf(mod,
587 		    "Currently can only enumerate a %s or %s directly\n",
588 		    PCI_BUS, PCIEX_BUS);
589 		topo_mod_dprintf(mod,
590 		    "descended from a %s or %s node.\n",
591 		    HOSTBRIDGE, PCIEX_ROOT);
592 		return (0);
593 	}
594 
595 	if (strcmp(name, PCI_BUS) == 0) {
596 		retval = pcibus_enum(mod, ptn, pname, min, max, data);
597 	} else if (strcmp(name, PCIEX_BUS) == 0) {
598 		retval = pciexbus_enum(mod, ptn, pname, min, max);
599 	} else {
600 		topo_mod_dprintf(mod,
601 		    "Currently only know how to enumerate %s or %s not %s.\n",
602 		    PCI_BUS, PCIEX_BUS, name);
603 		return (0);
604 	}
605 
606 	return (retval);
607 }
608 
609 /*ARGSUSED*/
610 static void
611 pci_release(topo_mod_t *mp, tnode_t *node)
612 {
613 	topo_method_unregister_all(mp, node);
614 
615 	/*
616 	 * node private data (did_t) for this node is destroyed in
617 	 * did_hash_destroy()
618 	 */
619 
620 	topo_node_unbind(node);
621 }
622