17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
561db5dcaSrd  * Common Development and Distribution License (the "License").
661db5dcaSrd  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
2248556476SJustin Frank  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*
277c478bd9Sstevel@tonic-gate  * PICL plug-in that creates device tree nodes for all platforms
287c478bd9Sstevel@tonic-gate  */
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #include <stdio.h>
317c478bd9Sstevel@tonic-gate #include <string.h>
327c478bd9Sstevel@tonic-gate #include <ctype.h>
337c478bd9Sstevel@tonic-gate #include <limits.h>
347c478bd9Sstevel@tonic-gate #include <stdlib.h>
357c478bd9Sstevel@tonic-gate #include <assert.h>
367c478bd9Sstevel@tonic-gate #include <alloca.h>
377c478bd9Sstevel@tonic-gate #include <unistd.h>
387c478bd9Sstevel@tonic-gate #include <stropts.h>
397c478bd9Sstevel@tonic-gate #include <syslog.h>
407c478bd9Sstevel@tonic-gate #include <libdevinfo.h>
417c478bd9Sstevel@tonic-gate #include <sys/dkio.h>
427c478bd9Sstevel@tonic-gate #include <sys/vtoc.h>
437c478bd9Sstevel@tonic-gate #include <sys/time.h>
447c478bd9Sstevel@tonic-gate #include <fcntl.h>
457c478bd9Sstevel@tonic-gate #include <picl.h>
467c478bd9Sstevel@tonic-gate #include <picltree.h>
477c478bd9Sstevel@tonic-gate #include <sys/types.h>
487c478bd9Sstevel@tonic-gate #include <sys/processor.h>
497c478bd9Sstevel@tonic-gate #include <kstat.h>
507c478bd9Sstevel@tonic-gate #include <sys/sysinfo.h>
517c478bd9Sstevel@tonic-gate #include <dirent.h>
527c478bd9Sstevel@tonic-gate #include <libintl.h>
537c478bd9Sstevel@tonic-gate #include <pthread.h>
547c478bd9Sstevel@tonic-gate #include <libnvpair.h>
557c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
567c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h>
577c478bd9Sstevel@tonic-gate #include <sys/obpdefs.h>
587c478bd9Sstevel@tonic-gate #include <sys/openpromio.h>
597c478bd9Sstevel@tonic-gate #include "picldevtree.h"
607c478bd9Sstevel@tonic-gate 
617c478bd9Sstevel@tonic-gate /*
627c478bd9Sstevel@tonic-gate  * Plugin registration entry points
637c478bd9Sstevel@tonic-gate  */
647c478bd9Sstevel@tonic-gate static void	picldevtree_register(void);
657c478bd9Sstevel@tonic-gate static void	picldevtree_init(void);
667c478bd9Sstevel@tonic-gate static void	picldevtree_fini(void);
677c478bd9Sstevel@tonic-gate 
687c478bd9Sstevel@tonic-gate static void	picldevtree_evhandler(const char *ename, const void *earg,
697c478bd9Sstevel@tonic-gate 		    size_t size, void *cookie);
707c478bd9Sstevel@tonic-gate 
717c478bd9Sstevel@tonic-gate #pragma	init(picldevtree_register)
727c478bd9Sstevel@tonic-gate 
737c478bd9Sstevel@tonic-gate /*
747c478bd9Sstevel@tonic-gate  * Log message texts
757c478bd9Sstevel@tonic-gate  */
767c478bd9Sstevel@tonic-gate #define	DEVINFO_PLUGIN_INIT_FAILED	gettext("SUNW_picldevtree failed!\n")
777c478bd9Sstevel@tonic-gate #define	PICL_EVENT_DROPPED	\
787c478bd9Sstevel@tonic-gate 	gettext("SUNW_picldevtree '%s' event dropped.\n")
797c478bd9Sstevel@tonic-gate 
807c478bd9Sstevel@tonic-gate /*
817c478bd9Sstevel@tonic-gate  * Macro to get PCI device id (from IEEE 1275 spec)
827c478bd9Sstevel@tonic-gate  */
837c478bd9Sstevel@tonic-gate #define	PCI_DEVICE_ID(x)			(((x) >> 11) & 0x1f)
847c478bd9Sstevel@tonic-gate /*
857c478bd9Sstevel@tonic-gate  * Local variables
867c478bd9Sstevel@tonic-gate  */
877c478bd9Sstevel@tonic-gate static picld_plugin_reg_t  my_reg_info = {
887c478bd9Sstevel@tonic-gate 	PICLD_PLUGIN_VERSION_1,
897c478bd9Sstevel@tonic-gate 	PICLD_PLUGIN_CRITICAL,
907c478bd9Sstevel@tonic-gate 	"SUNW_picldevtree",
917c478bd9Sstevel@tonic-gate 	picldevtree_init,
927c478bd9Sstevel@tonic-gate 	picldevtree_fini
937c478bd9Sstevel@tonic-gate };
947c478bd9Sstevel@tonic-gate 
957c478bd9Sstevel@tonic-gate /*
967c478bd9Sstevel@tonic-gate  * Debug enabling environment variable
977c478bd9Sstevel@tonic-gate  */
987c478bd9Sstevel@tonic-gate #define	SUNW_PICLDEVTREE_PLUGIN_DEBUG	"SUNW_PICLDEVTREE_PLUGIN_DEBUG"
997c478bd9Sstevel@tonic-gate static	int		picldevtree_debug = 0;
1007c478bd9Sstevel@tonic-gate 
1017c478bd9Sstevel@tonic-gate static	conf_entries_t 	*conf_name_class_map = NULL;
1027c478bd9Sstevel@tonic-gate static	builtin_map_t	sun4u_map[] = {
1037c478bd9Sstevel@tonic-gate 	/* MAX_NAMEVAL_SIZE */
1047c478bd9Sstevel@tonic-gate 	{ "SUNW,bpp", PICL_CLASS_PARALLEL},
1057c478bd9Sstevel@tonic-gate 	{ "parallel", PICL_CLASS_PARALLEL},
1067c478bd9Sstevel@tonic-gate 	{ "floppy", PICL_CLASS_FLOPPY},
1077c478bd9Sstevel@tonic-gate 	{ "memory", PICL_CLASS_MEMORY},
1087c478bd9Sstevel@tonic-gate 	{ "ebus", PICL_CLASS_EBUS},
1097c478bd9Sstevel@tonic-gate 	{ "i2c", PICL_CLASS_I2C},
1107c478bd9Sstevel@tonic-gate 	{ "usb", PICL_CLASS_USB},
1117c478bd9Sstevel@tonic-gate 	{ "isa", PICL_CLASS_ISA},
1127c478bd9Sstevel@tonic-gate 	{ "dma", PICL_CLASS_DMA},
1137c478bd9Sstevel@tonic-gate 	{ "keyboard", PICL_CLASS_KEYBOARD},
1147c478bd9Sstevel@tonic-gate 	{ "mouse", PICL_CLASS_MOUSE},
1157c478bd9Sstevel@tonic-gate 	{ "fan-control", PICL_CLASS_FAN_CONTROL},
1167c478bd9Sstevel@tonic-gate 	{ "sc", PICL_CLASS_SYSTEM_CONTROLLER},
1177c478bd9Sstevel@tonic-gate 	{ "dimm", PICL_CLASS_SEEPROM},
1187c478bd9Sstevel@tonic-gate 	{ "dimm-fru", PICL_CLASS_SEEPROM},
1197c478bd9Sstevel@tonic-gate 	{ "cpu", PICL_CLASS_SEEPROM},
1207c478bd9Sstevel@tonic-gate 	{ "cpu-fru", PICL_CLASS_SEEPROM},
1217c478bd9Sstevel@tonic-gate 	{ "flashprom", PICL_CLASS_FLASHPROM},
1227c478bd9Sstevel@tonic-gate 	{ "temperature", PICL_CLASS_TEMPERATURE_DEVICE},
1237c478bd9Sstevel@tonic-gate 	{ "motherboard", PICL_CLASS_SEEPROM},
1247c478bd9Sstevel@tonic-gate 	{ "motherboard-fru", PICL_CLASS_SEEPROM},
1257c478bd9Sstevel@tonic-gate 	{ "motherboard-fru-prom", PICL_CLASS_SEEPROM},
1267c478bd9Sstevel@tonic-gate 	{ "pmu", PICL_CLASS_PMU},
1277c478bd9Sstevel@tonic-gate 	{ "sound", PICL_CLASS_SOUND},
1287c478bd9Sstevel@tonic-gate 	{ "firewire", PICL_CLASS_FIREWIRE},
1297c478bd9Sstevel@tonic-gate 	{ "i2c-at34c02", PICL_CLASS_SEEPROM},
1307c478bd9Sstevel@tonic-gate 	{ "hardware-monitor", PICL_CLASS_HARDWARE_MONITOR},
1317c478bd9Sstevel@tonic-gate 	{ "", ""}
1327c478bd9Sstevel@tonic-gate };
1337c478bd9Sstevel@tonic-gate static	builtin_map_t	i86pc_map[] = {
1347c478bd9Sstevel@tonic-gate 	/* MAX_NAMEVAL_SIZE */
1357c478bd9Sstevel@tonic-gate 	{ "cpus", PICL_CLASS_I86CPUS},
1367c478bd9Sstevel@tonic-gate 	{ "cpu", PICL_CLASS_CPU},
1377c478bd9Sstevel@tonic-gate 	{ "memory", PICL_CLASS_MEMORY},
1387c478bd9Sstevel@tonic-gate 	{ "asy", PICL_CLASS_SERIAL},
1397c478bd9Sstevel@tonic-gate 	{ "", ""}
1407c478bd9Sstevel@tonic-gate };
1417c478bd9Sstevel@tonic-gate static	pname_type_map_t	pname_type_map[] = {
1427c478bd9Sstevel@tonic-gate 	{ "reg", PICL_PTYPE_BYTEARRAY},
1437c478bd9Sstevel@tonic-gate 	{ "device_type", PICL_PTYPE_CHARSTRING},
1447c478bd9Sstevel@tonic-gate 	{ "ranges", PICL_PTYPE_BYTEARRAY},
1457c478bd9Sstevel@tonic-gate 	{ "status", PICL_PTYPE_CHARSTRING},
1467c478bd9Sstevel@tonic-gate 	{ "compatible", PICL_PTYPE_CHARSTRING},
1477c478bd9Sstevel@tonic-gate 	{ "interrupts", PICL_PTYPE_BYTEARRAY},
1487c478bd9Sstevel@tonic-gate 	{ "model", PICL_PTYPE_CHARSTRING},
1497c478bd9Sstevel@tonic-gate 	{ "address", PICL_PTYPE_BYTEARRAY},
1507c478bd9Sstevel@tonic-gate 	{ "vendor-id", PICL_PTYPE_UNSIGNED_INT},
1517c478bd9Sstevel@tonic-gate 	{ "device-id", PICL_PTYPE_UNSIGNED_INT},
1527c478bd9Sstevel@tonic-gate 	{ "revision-id", PICL_PTYPE_UNSIGNED_INT},
1537c478bd9Sstevel@tonic-gate 	{ "class-code", PICL_PTYPE_UNSIGNED_INT},
1547c478bd9Sstevel@tonic-gate 	{ "min-grant", PICL_PTYPE_UNSIGNED_INT},
1557c478bd9Sstevel@tonic-gate 	{ "max-latency", PICL_PTYPE_UNSIGNED_INT},
1567c478bd9Sstevel@tonic-gate 	{ "devsel-speed", PICL_PTYPE_UNSIGNED_INT},
1577c478bd9Sstevel@tonic-gate 	{ "subsystem-id", PICL_PTYPE_UNSIGNED_INT},
1587c478bd9Sstevel@tonic-gate 	{ "subsystem-vendor-id", PICL_PTYPE_UNSIGNED_INT},
1597c478bd9Sstevel@tonic-gate 	{ "assigned-addresses", PICL_PTYPE_BYTEARRAY},
1607c478bd9Sstevel@tonic-gate 	{ "configuration#", PICL_PTYPE_UNSIGNED_INT},
1617c478bd9Sstevel@tonic-gate 	{ "assigned-address", PICL_PTYPE_UNSIGNED_INT},
1627c478bd9Sstevel@tonic-gate 	{ "#address-cells", PICL_PTYPE_UNSIGNED_INT},
1637c478bd9Sstevel@tonic-gate 	{ "#size-cells", PICL_PTYPE_UNSIGNED_INT},
1647c478bd9Sstevel@tonic-gate 	{ "clock-frequency", PICL_PTYPE_UNSIGNED_INT},
1657c478bd9Sstevel@tonic-gate 	{ "scsi-initiator-id", PICL_PTYPE_UNSIGNED_INT},
1667c478bd9Sstevel@tonic-gate 	{ "differential", PICL_PTYPE_UNSIGNED_INT},
1677c478bd9Sstevel@tonic-gate 	{ "idprom", PICL_PTYPE_BYTEARRAY},
1687c478bd9Sstevel@tonic-gate 	{ "bus-range", PICL_PTYPE_BYTEARRAY},
1697c478bd9Sstevel@tonic-gate 	{ "alternate-reg", PICL_PTYPE_BYTEARRAY},
1707c478bd9Sstevel@tonic-gate 	{ "power-consumption", PICL_PTYPE_BYTEARRAY},
1717c478bd9Sstevel@tonic-gate 	{ "slot-names", PICL_PTYPE_BYTEARRAY},
1727c478bd9Sstevel@tonic-gate 	{ "burst-sizes", PICL_PTYPE_UNSIGNED_INT},
1737c478bd9Sstevel@tonic-gate 	{ "up-burst-sizes", PICL_PTYPE_UNSIGNED_INT},
1747c478bd9Sstevel@tonic-gate 	{ "slot-address-bits", PICL_PTYPE_UNSIGNED_INT},
1757c478bd9Sstevel@tonic-gate 	{ "eisa-slots", PICL_PTYPE_BYTEARRAY},
1767c478bd9Sstevel@tonic-gate 	{ "dma", PICL_PTYPE_BYTEARRAY},
1777c478bd9Sstevel@tonic-gate 	{ "slot-names-index", PICL_PTYPE_UNSIGNED_INT},
1787c478bd9Sstevel@tonic-gate 	{ "pnp-csn", PICL_PTYPE_UNSIGNED_INT},
1797c478bd9Sstevel@tonic-gate 	{ "pnp-data", PICL_PTYPE_BYTEARRAY},
1807c478bd9Sstevel@tonic-gate 	{ "description", PICL_PTYPE_CHARSTRING},
1817c478bd9Sstevel@tonic-gate 	{ "pnp-id", PICL_PTYPE_CHARSTRING},
1827c478bd9Sstevel@tonic-gate 	{ "max-frame-size", PICL_PTYPE_UNSIGNED_INT},
1837c478bd9Sstevel@tonic-gate 	{ "address-bits", PICL_PTYPE_UNSIGNED_INT},
1847c478bd9Sstevel@tonic-gate 	{ "local-mac-address", PICL_PTYPE_BYTEARRAY},
1857c478bd9Sstevel@tonic-gate 	{ "mac-address", PICL_PTYPE_BYTEARRAY},
1867c478bd9Sstevel@tonic-gate 	{ "character-set", PICL_PTYPE_CHARSTRING},
1877c478bd9Sstevel@tonic-gate 	{ "available", PICL_PTYPE_BYTEARRAY},
1887c478bd9Sstevel@tonic-gate 	{ "port-wwn", PICL_PTYPE_BYTEARRAY},
1897c478bd9Sstevel@tonic-gate 	{ "node-wwn", PICL_PTYPE_BYTEARRAY},
1907c478bd9Sstevel@tonic-gate 	{ "width", PICL_PTYPE_UNSIGNED_INT},
1917c478bd9Sstevel@tonic-gate 	{ "linebytes", PICL_PTYPE_UNSIGNED_INT},
1927c478bd9Sstevel@tonic-gate 	{ "height", PICL_PTYPE_UNSIGNED_INT},
1937c478bd9Sstevel@tonic-gate 	{ "banner-name", PICL_PTYPE_CHARSTRING},
1947c478bd9Sstevel@tonic-gate 	{ "reset-reason", PICL_PTYPE_CHARSTRING},
1957c478bd9Sstevel@tonic-gate 	{ "implementation#", PICL_PTYPE_UNSIGNED_INT},
1967c478bd9Sstevel@tonic-gate 	{ "version#", PICL_PTYPE_UNSIGNED_INT},
1977c478bd9Sstevel@tonic-gate 	{ "icache-size", PICL_PTYPE_UNSIGNED_INT},
1987c478bd9Sstevel@tonic-gate 	{ "icache-line-size", PICL_PTYPE_UNSIGNED_INT},
1997c478bd9Sstevel@tonic-gate 	{ "icache-associativity", PICL_PTYPE_UNSIGNED_INT},
2007c478bd9Sstevel@tonic-gate 	{ "l1-icache-size", PICL_PTYPE_UNSIGNED_INT},
2017c478bd9Sstevel@tonic-gate 	{ "l1-icache-line-size", PICL_PTYPE_UNSIGNED_INT},
2027c478bd9Sstevel@tonic-gate 	{ "l1-icache-associativity", PICL_PTYPE_UNSIGNED_INT},
2037c478bd9Sstevel@tonic-gate 	{ "#itlb-entries", PICL_PTYPE_UNSIGNED_INT},
2047c478bd9Sstevel@tonic-gate 	{ "dcache-size", PICL_PTYPE_UNSIGNED_INT},
2057c478bd9Sstevel@tonic-gate 	{ "dcache-line-size", PICL_PTYPE_UNSIGNED_INT},
2067c478bd9Sstevel@tonic-gate 	{ "dcache-associativity", PICL_PTYPE_UNSIGNED_INT},
2077c478bd9Sstevel@tonic-gate 	{ "l1-dcache-size", PICL_PTYPE_UNSIGNED_INT},
2087c478bd9Sstevel@tonic-gate 	{ "l1-dcache-line-size", PICL_PTYPE_UNSIGNED_INT},
2097c478bd9Sstevel@tonic-gate 	{ "l1-dcache-associativity", PICL_PTYPE_UNSIGNED_INT},
2107c478bd9Sstevel@tonic-gate 	{ "#dtlb-entries", PICL_PTYPE_UNSIGNED_INT},
2117c478bd9Sstevel@tonic-gate 	{ "ecache-size", PICL_PTYPE_UNSIGNED_INT},
2127c478bd9Sstevel@tonic-gate 	{ "ecache-line-size", PICL_PTYPE_UNSIGNED_INT},
2137c478bd9Sstevel@tonic-gate 	{ "ecache-associativity", PICL_PTYPE_UNSIGNED_INT},
2147c478bd9Sstevel@tonic-gate 	{ "l2-cache-size", PICL_PTYPE_UNSIGNED_INT},
2157c478bd9Sstevel@tonic-gate 	{ "l2-cache-line-size", PICL_PTYPE_UNSIGNED_INT},
2167c478bd9Sstevel@tonic-gate 	{ "l2-cache-associativity", PICL_PTYPE_UNSIGNED_INT},
2177c478bd9Sstevel@tonic-gate 	{ "l2-cache-sharing", PICL_PTYPE_BYTEARRAY},
2187c478bd9Sstevel@tonic-gate 	{ "mask#", PICL_PTYPE_UNSIGNED_INT},
2197c478bd9Sstevel@tonic-gate 	{ "manufacturer#", PICL_PTYPE_UNSIGNED_INT},
2207c478bd9Sstevel@tonic-gate 	{ "sparc-version", PICL_PTYPE_UNSIGNED_INT},
2217c478bd9Sstevel@tonic-gate 	{ "version", PICL_PTYPE_CHARSTRING},
2227c478bd9Sstevel@tonic-gate 	{ "cpu-model", PICL_PTYPE_UNSIGNED_INT},
2237c478bd9Sstevel@tonic-gate 	{ "memory-layout", PICL_PTYPE_BYTEARRAY},
2247c478bd9Sstevel@tonic-gate 	{ "#interrupt-cells", PICL_PTYPE_UNSIGNED_INT},
2257c478bd9Sstevel@tonic-gate 	{ "interrupt-map", PICL_PTYPE_BYTEARRAY},
2267c478bd9Sstevel@tonic-gate 	{ "interrupt-map-mask", PICL_PTYPE_BYTEARRAY}
2277c478bd9Sstevel@tonic-gate };
2287c478bd9Sstevel@tonic-gate 
2297c478bd9Sstevel@tonic-gate #define	PNAME_MAP_SIZE	sizeof (pname_type_map) / sizeof (pname_type_map_t)
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate static	builtin_map_t	*builtin_map_ptr = NULL;
2327c478bd9Sstevel@tonic-gate static	int		builtin_map_size = 0;
2337c478bd9Sstevel@tonic-gate static	char		mach_name[SYS_NMLN];
2347c478bd9Sstevel@tonic-gate static	di_prom_handle_t	ph = DI_PROM_HANDLE_NIL;
235bdee4892SMichael Bergknoff static	int		snapshot_stale;
2367c478bd9Sstevel@tonic-gate 
2377c478bd9Sstevel@tonic-gate /*
2387c478bd9Sstevel@tonic-gate  * UnitAddress mapping table
2397c478bd9Sstevel@tonic-gate  */
2407c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_default_unitaddr;
2417c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_optional_unitaddr;
2427c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_scsi_unitaddr;
2437c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_upa_unitaddr;
2447c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_gptwo_jbus_unitaddr;
2457c478bd9Sstevel@tonic-gate static	unitaddr_func_t	encode_pci_unitaddr;
2467c478bd9Sstevel@tonic-gate 
2477c478bd9Sstevel@tonic-gate static	unitaddr_map_t unitaddr_map_table[] = {
2487c478bd9Sstevel@tonic-gate 	{PICL_CLASS_JBUS, encode_gptwo_jbus_unitaddr, 0},
2497c478bd9Sstevel@tonic-gate 	{PICL_CLASS_GPTWO, encode_gptwo_jbus_unitaddr, 0},
2507c478bd9Sstevel@tonic-gate 	{PICL_CLASS_PCI, encode_pci_unitaddr, 0},
2517ef4fcfbSvenki 	{PICL_CLASS_PCIEX, encode_pci_unitaddr, 0},
2527c478bd9Sstevel@tonic-gate 	{PICL_CLASS_UPA, encode_upa_unitaddr, 0},
2537c478bd9Sstevel@tonic-gate 	{PICL_CLASS_SCSI, encode_scsi_unitaddr, 0},
2547c478bd9Sstevel@tonic-gate 	{PICL_CLASS_SCSI2, encode_scsi_unitaddr, 0},
2557c478bd9Sstevel@tonic-gate 	{PICL_CLASS_EBUS, encode_default_unitaddr, 2},
2567c478bd9Sstevel@tonic-gate 	{PICL_CLASS_SBUS, encode_default_unitaddr, 2},
2577c478bd9Sstevel@tonic-gate 	{PICL_CLASS_I2C, encode_default_unitaddr, 2},
2587c478bd9Sstevel@tonic-gate 	{PICL_CLASS_USB, encode_default_unitaddr, 1},
2597c478bd9Sstevel@tonic-gate 	{PICL_CLASS_PMU, encode_optional_unitaddr, 2},
2607c478bd9Sstevel@tonic-gate 	{NULL, encode_default_unitaddr, 0}
2617c478bd9Sstevel@tonic-gate };
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate static int add_unitaddr_prop_to_subtree(picl_nodehdl_t nodeh);
2647c478bd9Sstevel@tonic-gate static int get_unitaddr(picl_nodehdl_t parh, picl_nodehdl_t nodeh,
2657c478bd9Sstevel@tonic-gate 	char *unitaddr, size_t ualen);
2667ef4fcfbSvenki static void set_pci_pciex_deviceid(picl_nodehdl_t plafh);
2677c478bd9Sstevel@tonic-gate 
2687c478bd9Sstevel@tonic-gate /*
2697c478bd9Sstevel@tonic-gate  * The mc event completion handler.
2707c478bd9Sstevel@tonic-gate  * The arguments are event name buffer and a packed nvlist buffer
2717c478bd9Sstevel@tonic-gate  * with the size specifying the size of unpacked nvlist. These
2727c478bd9Sstevel@tonic-gate  * buffers are deallcoated here.
2737c478bd9Sstevel@tonic-gate  *
2747c478bd9Sstevel@tonic-gate  * Also, if a memory controller node is being removed then destroy the
2757c478bd9Sstevel@tonic-gate  * PICL subtree associated with that memory controller.
2767c478bd9Sstevel@tonic-gate  */
2777c478bd9Sstevel@tonic-gate static void
2787c478bd9Sstevel@tonic-gate mc_completion_handler(char *ename, void *earg, size_t size)
2797c478bd9Sstevel@tonic-gate {
2807c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	mch;
2817c478bd9Sstevel@tonic-gate 	nvlist_t	*unpack_nvl;
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate 	if (strcmp(ename, PICLEVENT_MC_REMOVED) == 0 &&
2847c478bd9Sstevel@tonic-gate 	    nvlist_unpack(earg, size, &unpack_nvl, NULL) == 0) {
2857c478bd9Sstevel@tonic-gate 		mch = NULL;
2867c478bd9Sstevel@tonic-gate 		(void) nvlist_lookup_uint64(unpack_nvl,
2877c478bd9Sstevel@tonic-gate 		    PICLEVENTARG_NODEHANDLE, &mch);
2887c478bd9Sstevel@tonic-gate 		if (mch != NULL) {
2897c478bd9Sstevel@tonic-gate 			if (picldevtree_debug)
2907c478bd9Sstevel@tonic-gate 				syslog(LOG_INFO,
2917c478bd9Sstevel@tonic-gate 				    "picldevtree: destroying_node:%llx\n",
2927c478bd9Sstevel@tonic-gate 				    mch);
2937c478bd9Sstevel@tonic-gate 			(void) ptree_destroy_node(mch);
2947c478bd9Sstevel@tonic-gate 		}
2957c478bd9Sstevel@tonic-gate 		nvlist_free(unpack_nvl);
2967c478bd9Sstevel@tonic-gate 	}
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 	free(ename);
2997c478bd9Sstevel@tonic-gate 	free(earg);
3007c478bd9Sstevel@tonic-gate }
3017c478bd9Sstevel@tonic-gate 
3027c478bd9Sstevel@tonic-gate /*
3037c478bd9Sstevel@tonic-gate  * Functions to post memory controller change event
3047c478bd9Sstevel@tonic-gate  */
3057c478bd9Sstevel@tonic-gate static int
3067c478bd9Sstevel@tonic-gate post_mc_event(char *ename, picl_nodehdl_t mch)
3077c478bd9Sstevel@tonic-gate {
3087c478bd9Sstevel@tonic-gate 	nvlist_t	*nvl;
3097c478bd9Sstevel@tonic-gate 	size_t		nvl_size;
3107c478bd9Sstevel@tonic-gate 	char		*pack_buf;
3117c478bd9Sstevel@tonic-gate 	char		*ev_name;
3127c478bd9Sstevel@tonic-gate 
3137c478bd9Sstevel@tonic-gate 	ev_name = strdup(ename);
3147c478bd9Sstevel@tonic-gate 	if (ev_name == NULL)
3157c478bd9Sstevel@tonic-gate 		return (-1);
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, NULL)) {
3187c478bd9Sstevel@tonic-gate 		free(ev_name);
3197c478bd9Sstevel@tonic-gate 		return (-1);
3207c478bd9Sstevel@tonic-gate 	}
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 	pack_buf = NULL;
3237c478bd9Sstevel@tonic-gate 	if (nvlist_add_uint64(nvl, PICLEVENTARG_NODEHANDLE, mch) ||
3247c478bd9Sstevel@tonic-gate 	    nvlist_pack(nvl, &pack_buf, &nvl_size, NV_ENCODE_NATIVE, NULL)) {
3257c478bd9Sstevel@tonic-gate 		free(ev_name);
3267c478bd9Sstevel@tonic-gate 		nvlist_free(nvl);
3277c478bd9Sstevel@tonic-gate 		return (-1);
3287c478bd9Sstevel@tonic-gate 	}
3297c478bd9Sstevel@tonic-gate 
3307c478bd9Sstevel@tonic-gate 	if (picldevtree_debug)
3317c478bd9Sstevel@tonic-gate 		syslog(LOG_INFO,
3327c478bd9Sstevel@tonic-gate 		    "picldevtree: posting MC event ename:%s nodeh:%llx\n",
3337c478bd9Sstevel@tonic-gate 		    ev_name, mch);
3347c478bd9Sstevel@tonic-gate 	if (ptree_post_event(ev_name, pack_buf, nvl_size,
3357c478bd9Sstevel@tonic-gate 	    mc_completion_handler) != PICL_SUCCESS) {
3367c478bd9Sstevel@tonic-gate 		free(ev_name);
3377c478bd9Sstevel@tonic-gate 		nvlist_free(nvl);
3387c478bd9Sstevel@tonic-gate 		return (-1);
3397c478bd9Sstevel@tonic-gate 	}
3407c478bd9Sstevel@tonic-gate 	nvlist_free(nvl);
3417c478bd9Sstevel@tonic-gate 	return (0);
3427c478bd9Sstevel@tonic-gate }
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate /*
3457c478bd9Sstevel@tonic-gate  * Lookup a name in the name to class map tables
3467c478bd9Sstevel@tonic-gate  */
3477c478bd9Sstevel@tonic-gate static int
3487c478bd9Sstevel@tonic-gate lookup_name_class_map(char *classbuf, const char *nm)
3497c478bd9Sstevel@tonic-gate {
3507c478bd9Sstevel@tonic-gate 	conf_entries_t	*ptr;
3517c478bd9Sstevel@tonic-gate 	int		i;
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate 	/*
3547c478bd9Sstevel@tonic-gate 	 * check name to class mapping in conf file
3557c478bd9Sstevel@tonic-gate 	 */
3567c478bd9Sstevel@tonic-gate 	ptr = conf_name_class_map;
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate 	while (ptr != NULL) {
3597c478bd9Sstevel@tonic-gate 		if (strcmp(ptr->name, nm) == 0) {
3607c478bd9Sstevel@tonic-gate 			(void) strlcpy(classbuf, ptr->piclclass,
3617c478bd9Sstevel@tonic-gate 			    PICL_CLASSNAMELEN_MAX);
3627c478bd9Sstevel@tonic-gate 			return (0);
3637c478bd9Sstevel@tonic-gate 		}
3647c478bd9Sstevel@tonic-gate 		ptr = ptr->next;
3657c478bd9Sstevel@tonic-gate 	}
3667c478bd9Sstevel@tonic-gate 
3677c478bd9Sstevel@tonic-gate 	/*
3687c478bd9Sstevel@tonic-gate 	 * check name to class mapping in builtin table
3697c478bd9Sstevel@tonic-gate 	 */
3707c478bd9Sstevel@tonic-gate 	if (builtin_map_ptr == NULL)
3717c478bd9Sstevel@tonic-gate 		return (-1);
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 	for (i = 0; i < builtin_map_size; ++i)
3747c478bd9Sstevel@tonic-gate 		if (strcmp(builtin_map_ptr[i].name, nm) == 0) {
3757c478bd9Sstevel@tonic-gate 			(void) strlcpy(classbuf, builtin_map_ptr[i].piclclass,
3767c478bd9Sstevel@tonic-gate 			    PICL_CLASSNAMELEN_MAX);
3777c478bd9Sstevel@tonic-gate 			return (0);
3787c478bd9Sstevel@tonic-gate 		}
3797c478bd9Sstevel@tonic-gate 	return (-1);
3807c478bd9Sstevel@tonic-gate }
3817c478bd9Sstevel@tonic-gate 
3827c478bd9Sstevel@tonic-gate /*
3837c478bd9Sstevel@tonic-gate  * Lookup a prop name in the pname to class map table
3847c478bd9Sstevel@tonic-gate  */
3857c478bd9Sstevel@tonic-gate static int
3867c478bd9Sstevel@tonic-gate lookup_pname_type_map(const char *pname, picl_prop_type_t *type)
3877c478bd9Sstevel@tonic-gate {
3887c478bd9Sstevel@tonic-gate 	int		i;
3897c478bd9Sstevel@tonic-gate 
3907c478bd9Sstevel@tonic-gate 	for (i = 0; i < PNAME_MAP_SIZE; ++i)
3917c478bd9Sstevel@tonic-gate 		if (strcmp(pname_type_map[i].pname, pname) == 0) {
3927c478bd9Sstevel@tonic-gate 			*type = pname_type_map[i].type;
3937c478bd9Sstevel@tonic-gate 			return (0);
3947c478bd9Sstevel@tonic-gate 		}
3957c478bd9Sstevel@tonic-gate 
3967c478bd9Sstevel@tonic-gate 	return (-1);
3977c478bd9Sstevel@tonic-gate }
3987c478bd9Sstevel@tonic-gate 
3997c478bd9Sstevel@tonic-gate /*
4007c478bd9Sstevel@tonic-gate  * Return the number of strings in the buffer
4017c478bd9Sstevel@tonic-gate  */
4027c478bd9Sstevel@tonic-gate static int
4037c478bd9Sstevel@tonic-gate get_string_count(char *strdat, int length)
4047c478bd9Sstevel@tonic-gate {
4057c478bd9Sstevel@tonic-gate 	int	count;
4067c478bd9Sstevel@tonic-gate 	char	*lastnull;
4077c478bd9Sstevel@tonic-gate 	char	*nullptr;
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate 	count = 1;
4107c478bd9Sstevel@tonic-gate 	for (lastnull = &strdat[length - 1], nullptr = strchr(strdat, '\0');
4117c478bd9Sstevel@tonic-gate 	    nullptr != lastnull; nullptr = strchr(nullptr+1, '\0'))
4127c478bd9Sstevel@tonic-gate 		count++;
4137c478bd9Sstevel@tonic-gate 
4147c478bd9Sstevel@tonic-gate 	return (count);
4157c478bd9Sstevel@tonic-gate }
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate /*
4187c478bd9Sstevel@tonic-gate  * Return 1 if the node has a "reg" property
4197c478bd9Sstevel@tonic-gate  */
4207c478bd9Sstevel@tonic-gate static int
4217c478bd9Sstevel@tonic-gate has_reg_prop(di_node_t dn)
4227c478bd9Sstevel@tonic-gate {
4237c478bd9Sstevel@tonic-gate 	int			*pdata;
4247c478bd9Sstevel@tonic-gate 	int			dret;
4257c478bd9Sstevel@tonic-gate 
4267c478bd9Sstevel@tonic-gate 	dret = di_prop_lookup_ints(DDI_DEV_T_ANY, dn, OBP_REG, &pdata);
4277c478bd9Sstevel@tonic-gate 	if (dret > 0)
4287c478bd9Sstevel@tonic-gate 		return (1);
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 	if (!ph)
4317c478bd9Sstevel@tonic-gate 		return (0);
4327c478bd9Sstevel@tonic-gate 	dret = di_prom_prop_lookup_ints(ph, dn, OBP_REG, &pdata);
4337c478bd9Sstevel@tonic-gate 	return (dret < 0 ? 0 : 1);
4347c478bd9Sstevel@tonic-gate }
4357c478bd9Sstevel@tonic-gate 
4367c478bd9Sstevel@tonic-gate /*
4377c478bd9Sstevel@tonic-gate  * This function copies a PROM node's device_type property value into the
4387c478bd9Sstevel@tonic-gate  * buffer given by outbuf. The buffer size is PICL_CLASSNAMELEN_MAX.
4397c478bd9Sstevel@tonic-gate  *
4407c478bd9Sstevel@tonic-gate  * We reclassify device_type 'fru-prom' to PICL class 'seeprom'
4417c478bd9Sstevel@tonic-gate  * for FRUID support.
4427c478bd9Sstevel@tonic-gate  */
4437c478bd9Sstevel@tonic-gate static int
4447c478bd9Sstevel@tonic-gate get_device_type(char *outbuf, di_node_t dn)
4457c478bd9Sstevel@tonic-gate {
4467c478bd9Sstevel@tonic-gate 	char			*pdata;
4477c478bd9Sstevel@tonic-gate 	char			*pdatap;
4487c478bd9Sstevel@tonic-gate 	int			dret;
4497c478bd9Sstevel@tonic-gate 	int			i;
4507c478bd9Sstevel@tonic-gate 
4517c478bd9Sstevel@tonic-gate 	dret = di_prop_lookup_strings(DDI_DEV_T_ANY, dn, OBP_DEVICETYPE,
4527c478bd9Sstevel@tonic-gate 	    &pdata);
4537c478bd9Sstevel@tonic-gate 	if (dret <= 0) {
4547c478bd9Sstevel@tonic-gate 		if (!ph)
4557c478bd9Sstevel@tonic-gate 			return (-1);
4567c478bd9Sstevel@tonic-gate 
4577c478bd9Sstevel@tonic-gate 		dret = di_prom_prop_lookup_strings(ph, dn, OBP_DEVICETYPE,
4587c478bd9Sstevel@tonic-gate 		    &pdata);
4597c478bd9Sstevel@tonic-gate 		if (dret <= 0) {
4607c478bd9Sstevel@tonic-gate 			return (-1);
4617c478bd9Sstevel@tonic-gate 		}
4627c478bd9Sstevel@tonic-gate 	}
4637c478bd9Sstevel@tonic-gate 
4647c478bd9Sstevel@tonic-gate 	if (dret != 1) {
4657c478bd9Sstevel@tonic-gate 		/*
4667c478bd9Sstevel@tonic-gate 		 * multiple strings
4677c478bd9Sstevel@tonic-gate 		 */
4687c478bd9Sstevel@tonic-gate 		pdatap = pdata;
4697c478bd9Sstevel@tonic-gate 		for (i = 0; i < (dret - 1); ++i) {
4707c478bd9Sstevel@tonic-gate 			pdatap += strlen(pdatap);
4717c478bd9Sstevel@tonic-gate 			*pdatap = '-';	/* replace '\0' with '-' */
4727c478bd9Sstevel@tonic-gate 			pdatap++;
4737c478bd9Sstevel@tonic-gate 		}
4747c478bd9Sstevel@tonic-gate 	}
4757c478bd9Sstevel@tonic-gate 	if (strcasecmp(pdata, "fru-prom") == 0) {
4767c478bd9Sstevel@tonic-gate 		/*
4777c478bd9Sstevel@tonic-gate 		 * Use PICL 'seeprom' class for fru-prom device types
4787c478bd9Sstevel@tonic-gate 		 */
4797c478bd9Sstevel@tonic-gate 		(void) strlcpy(outbuf, PICL_CLASS_SEEPROM,
4807c478bd9Sstevel@tonic-gate 		    PICL_CLASSNAMELEN_MAX);
4817c478bd9Sstevel@tonic-gate 	} else {
4827c478bd9Sstevel@tonic-gate 		(void) strlcpy(outbuf, pdata, PICL_CLASSNAMELEN_MAX);
4837c478bd9Sstevel@tonic-gate 	}
4847c478bd9Sstevel@tonic-gate 	return (0);
4857c478bd9Sstevel@tonic-gate }
4867c478bd9Sstevel@tonic-gate 
4877c478bd9Sstevel@tonic-gate /*
4887c478bd9Sstevel@tonic-gate  * Get the minor node name in the class buffer passed
4897c478bd9Sstevel@tonic-gate  */
4907c478bd9Sstevel@tonic-gate static int
4917c478bd9Sstevel@tonic-gate get_minor_class(char *classbuf, di_node_t dn)
4927c478bd9Sstevel@tonic-gate {
4937c478bd9Sstevel@tonic-gate 	di_minor_t	mi_node;
4947c478bd9Sstevel@tonic-gate 	char		*mi_nodetype;
4957c478bd9Sstevel@tonic-gate 	char		*mi_name;
4967c478bd9Sstevel@tonic-gate 
4977c478bd9Sstevel@tonic-gate 	/* get minor node type */
4987c478bd9Sstevel@tonic-gate 	mi_node = di_minor_next(dn, DI_MINOR_NIL);
4997c478bd9Sstevel@tonic-gate 	if (mi_node == DI_MINOR_NIL)
5007c478bd9Sstevel@tonic-gate 		return (-1);
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate 	mi_nodetype = di_minor_nodetype(mi_node);
5037c478bd9Sstevel@tonic-gate 	if (mi_nodetype == NULL) { /* no type info, return name */
5047c478bd9Sstevel@tonic-gate 		mi_name = di_minor_name(mi_node);
5057c478bd9Sstevel@tonic-gate 		if (mi_name == NULL)
5067c478bd9Sstevel@tonic-gate 			return (-1);
5077c478bd9Sstevel@tonic-gate 		(void) strlcpy(classbuf, mi_name, PICL_CLASSNAMELEN_MAX);
5087c478bd9Sstevel@tonic-gate 		return (0);
5097c478bd9Sstevel@tonic-gate 	}
5107c478bd9Sstevel@tonic-gate 
5117c478bd9Sstevel@tonic-gate #define	DDI_NODETYPE(x, y) (strncmp(x, y, (sizeof (y) - 1)) == 0)
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate 	/*
5147c478bd9Sstevel@tonic-gate 	 * convert the string to the picl class for non-peudo nodes
5157c478bd9Sstevel@tonic-gate 	 */
5167c478bd9Sstevel@tonic-gate 	if (DDI_NODETYPE(mi_nodetype, DDI_PSEUDO))
5177c478bd9Sstevel@tonic-gate 		return (-1);
5187c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_BLOCK_WWN))
5197c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_BLOCK);
5207c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_BLOCK_CHAN))
5217c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_BLOCK);
5227c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_CD))
5237c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_CDROM);
5247c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_CD_CHAN))
5257c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_CDROM);
5267c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_FD))
5277c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_FLOPPY);
5287c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_BLOCK_FABRIC))
5297c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_FABRIC);
530*d88e498aSjiang wu - Sun Microsystems - Beijing China 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_BLOCK_SAS))
531*d88e498aSjiang wu - Sun Microsystems - Beijing China 		(void) strcpy(classbuf, PICL_CLASS_SAS);
5327c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_BLOCK))
5337c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_BLOCK);
5347c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_MOUSE))
5357c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_MOUSE);
5367c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_KEYBOARD))
5377c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_KEYBOARD);
5387c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_ATTACHMENT_POINT))
5397c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_ATTACHMENT_POINT);
5407c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_TAPE))
5417c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_TAPE);
5427c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_SCSI_ENCLOSURE))
5437c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_SCSI);
5447c478bd9Sstevel@tonic-gate 	else if (DDI_NODETYPE(mi_nodetype, DDI_NT_ENCLOSURE)) {
5457c478bd9Sstevel@tonic-gate 		char	*colon;
5467c478bd9Sstevel@tonic-gate 
5477c478bd9Sstevel@tonic-gate 		if ((colon = strchr(mi_nodetype, ':')) == NULL)
5487c478bd9Sstevel@tonic-gate 			return (-1);
5497c478bd9Sstevel@tonic-gate 		++colon;
5507c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, colon);
5517c478bd9Sstevel@tonic-gate 	} else {	/* unrecognized type, return name */
5527c478bd9Sstevel@tonic-gate 		mi_name = di_minor_name(mi_node);
5537c478bd9Sstevel@tonic-gate 		if (mi_name == NULL)
5547c478bd9Sstevel@tonic-gate 			return (-1);
5557c478bd9Sstevel@tonic-gate 		(void) strlcpy(classbuf, mi_name, PICL_CLASSNAMELEN_MAX);
5567c478bd9Sstevel@tonic-gate 	}
5577c478bd9Sstevel@tonic-gate 	return (0);
5587c478bd9Sstevel@tonic-gate }
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate /*
5617c478bd9Sstevel@tonic-gate  * Derive PICL class using the compatible property of the node
5627c478bd9Sstevel@tonic-gate  * We use the map table to map compatible property value to
5637c478bd9Sstevel@tonic-gate  * class.
5647c478bd9Sstevel@tonic-gate  */
5657c478bd9Sstevel@tonic-gate static int
5667c478bd9Sstevel@tonic-gate get_compatible_class(char *outbuf, di_node_t dn)
5677c478bd9Sstevel@tonic-gate {
5687c478bd9Sstevel@tonic-gate 	char			*pdata;
5697c478bd9Sstevel@tonic-gate 	char			*pdatap;
5707c478bd9Sstevel@tonic-gate 	int			dret;
5717c478bd9Sstevel@tonic-gate 	int			i;
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate 	dret = di_prop_lookup_strings(DDI_DEV_T_ANY, dn, OBP_COMPATIBLE,
5747c478bd9Sstevel@tonic-gate 	    &pdata);
5757c478bd9Sstevel@tonic-gate 	if (dret <= 0) {
5767c478bd9Sstevel@tonic-gate 		if (!ph)
5777c478bd9Sstevel@tonic-gate 			return (-1);
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 		dret = di_prom_prop_lookup_strings(ph, dn, OBP_COMPATIBLE,
5807c478bd9Sstevel@tonic-gate 		    &pdata);
5817c478bd9Sstevel@tonic-gate 		if (dret <= 0) {
5827c478bd9Sstevel@tonic-gate 			return (-1);
5837c478bd9Sstevel@tonic-gate 		}
5847c478bd9Sstevel@tonic-gate 	}
5857c478bd9Sstevel@tonic-gate 
5867c478bd9Sstevel@tonic-gate 	pdatap = pdata;
5877c478bd9Sstevel@tonic-gate 	for (i = 0; i < dret; ++i) {
5887c478bd9Sstevel@tonic-gate 		if (lookup_name_class_map(outbuf, pdatap) == 0)
5897c478bd9Sstevel@tonic-gate 			return (0);
5907c478bd9Sstevel@tonic-gate 		pdatap += strlen(pdatap);
5917c478bd9Sstevel@tonic-gate 		pdatap++;
5927c478bd9Sstevel@tonic-gate 	}
5937c478bd9Sstevel@tonic-gate 	return (-1);
5947c478bd9Sstevel@tonic-gate }
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate /*
5977c478bd9Sstevel@tonic-gate  * For a given device node find the PICL class to use. Returns NULL
5987c478bd9Sstevel@tonic-gate  * for non device node
5997c478bd9Sstevel@tonic-gate  */
6007c478bd9Sstevel@tonic-gate static int
6017c478bd9Sstevel@tonic-gate get_node_class(char *classbuf, di_node_t dn, const char *nodename)
6027c478bd9Sstevel@tonic-gate {
6037c478bd9Sstevel@tonic-gate 	if (get_device_type(classbuf, dn) == 0) {
6047c478bd9Sstevel@tonic-gate 		if (di_nodeid(dn) == DI_PROM_NODEID) {
6057c478bd9Sstevel@tonic-gate 			/*
6067c478bd9Sstevel@tonic-gate 			 * discard place holder nodes
6077c478bd9Sstevel@tonic-gate 			 */
6087c478bd9Sstevel@tonic-gate 			if ((strcmp(classbuf, DEVICE_TYPE_BLOCK) == 0) ||
6097c478bd9Sstevel@tonic-gate 			    (strcmp(classbuf, DEVICE_TYPE_BYTE) == 0) ||
6107c478bd9Sstevel@tonic-gate 			    (strcmp(classbuf, DEVICE_TYPE_SES) == 0) ||
6117c478bd9Sstevel@tonic-gate 			    (strcmp(classbuf, DEVICE_TYPE_FP) == 0) ||
6127c478bd9Sstevel@tonic-gate 			    (strcmp(classbuf, DEVICE_TYPE_DISK) == 0))
6137c478bd9Sstevel@tonic-gate 				return (-1);
6147c478bd9Sstevel@tonic-gate 
6157c478bd9Sstevel@tonic-gate 			return (0);
6167c478bd9Sstevel@tonic-gate 		}
6177c478bd9Sstevel@tonic-gate 		return (0);	/* return device_type value */
6187c478bd9Sstevel@tonic-gate 	}
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	if (get_compatible_class(classbuf, dn) == 0) {
6217c478bd9Sstevel@tonic-gate 		return (0);	/* derive class using compatible prop */
6227c478bd9Sstevel@tonic-gate 	}
6237c478bd9Sstevel@tonic-gate 
6247c478bd9Sstevel@tonic-gate 	if (lookup_name_class_map(classbuf, nodename) == 0)
6257c478bd9Sstevel@tonic-gate 		return (0);	/* derive class using name prop */
6267c478bd9Sstevel@tonic-gate 
6277c478bd9Sstevel@tonic-gate 	if (has_reg_prop(dn)) { /* use default obp-device */
6287c478bd9Sstevel@tonic-gate 		(void) strcpy(classbuf, PICL_CLASS_OBP_DEVICE);
6297c478bd9Sstevel@tonic-gate 		return (0);
6307c478bd9Sstevel@tonic-gate 	}
6317c478bd9Sstevel@tonic-gate 
6327c478bd9Sstevel@tonic-gate 	return (get_minor_class(classbuf, dn));
6337c478bd9Sstevel@tonic-gate }
6347c478bd9Sstevel@tonic-gate 
6357c478bd9Sstevel@tonic-gate /*
6367c478bd9Sstevel@tonic-gate  * Add a table property containing nrows with one column
6377c478bd9Sstevel@tonic-gate  */
6387c478bd9Sstevel@tonic-gate static int
6397c478bd9Sstevel@tonic-gate add_string_list_prop(picl_nodehdl_t nodeh, char *name, char *strlist,
6407c478bd9Sstevel@tonic-gate     unsigned int nrows)
6417c478bd9Sstevel@tonic-gate {
6427c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
6437c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
6447c478bd9Sstevel@tonic-gate 	picl_prophdl_t		tblh;
6457c478bd9Sstevel@tonic-gate 	int			err;
6467c478bd9Sstevel@tonic-gate 	unsigned int		i;
6477c478bd9Sstevel@tonic-gate 	unsigned int		j;
6487c478bd9Sstevel@tonic-gate 	picl_prophdl_t		*proprow;
6497c478bd9Sstevel@tonic-gate 	int			len;
6507c478bd9Sstevel@tonic-gate 
6517c478bd9Sstevel@tonic-gate #define	NCOLS_IN_STRING_TABLE	1
6527c478bd9Sstevel@tonic-gate 
6537c478bd9Sstevel@tonic-gate 	err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
6547c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_TABLE, PICL_READ, sizeof (picl_prophdl_t), name,
6557c478bd9Sstevel@tonic-gate 	    NULL, NULL);
6567c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
6577c478bd9Sstevel@tonic-gate 		return (err);
6587c478bd9Sstevel@tonic-gate 
6597c478bd9Sstevel@tonic-gate 	err = ptree_create_table(&tblh);
6607c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
6617c478bd9Sstevel@tonic-gate 		return (err);
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(nodeh, &propinfo, &tblh, &proph);
6647c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
6657c478bd9Sstevel@tonic-gate 		return (err);
6667c478bd9Sstevel@tonic-gate 
6677c478bd9Sstevel@tonic-gate 	proprow = alloca(sizeof (picl_prophdl_t) * nrows);
6687c478bd9Sstevel@tonic-gate 	if (proprow == NULL) {
6697c478bd9Sstevel@tonic-gate 		(void) ptree_destroy_prop(proph);
6707c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
6717c478bd9Sstevel@tonic-gate 	}
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 	for (j = 0; j < nrows; ++j) {
6747c478bd9Sstevel@tonic-gate 		len = strlen(strlist) + 1;
6757c478bd9Sstevel@tonic-gate 		err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
6767c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ, len, name,
6777c478bd9Sstevel@tonic-gate 		    NULL, NULL);
6787c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
6797c478bd9Sstevel@tonic-gate 			break;
6807c478bd9Sstevel@tonic-gate 		err = ptree_create_prop(&propinfo, strlist, &proprow[j]);
6817c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
6827c478bd9Sstevel@tonic-gate 			break;
6837c478bd9Sstevel@tonic-gate 		strlist += len;
6847c478bd9Sstevel@tonic-gate 		err = ptree_add_row_to_table(tblh, NCOLS_IN_STRING_TABLE,
6857c478bd9Sstevel@tonic-gate 		    &proprow[j]);
6867c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
6877c478bd9Sstevel@tonic-gate 			break;
6887c478bd9Sstevel@tonic-gate 	}
6897c478bd9Sstevel@tonic-gate 
6907c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS) {
6917c478bd9Sstevel@tonic-gate 		for (i = 0; i < j; ++i)
6927c478bd9Sstevel@tonic-gate 			(void) ptree_destroy_prop(proprow[i]);
6937c478bd9Sstevel@tonic-gate 		(void) ptree_delete_prop(proph);
6947c478bd9Sstevel@tonic-gate 		(void) ptree_destroy_prop(proph);
6957c478bd9Sstevel@tonic-gate 		return (err);
6967c478bd9Sstevel@tonic-gate 	}
6977c478bd9Sstevel@tonic-gate 
6987c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate /*
7027c478bd9Sstevel@tonic-gate  * return 1 if this node has this property with the given value
7037c478bd9Sstevel@tonic-gate  */
7047c478bd9Sstevel@tonic-gate static int
7057c478bd9Sstevel@tonic-gate compare_string_propval(picl_nodehdl_t nodeh, const char *pname,
7067c478bd9Sstevel@tonic-gate     const char *pval)
7077c478bd9Sstevel@tonic-gate {
7087c478bd9Sstevel@tonic-gate 	char			*pvalbuf;
7097c478bd9Sstevel@tonic-gate 	int			err;
7107c478bd9Sstevel@tonic-gate 	int			len;
7117c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
7127c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
7137c478bd9Sstevel@tonic-gate 
7147c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(nodeh, pname, &proph);
7157c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)	/* prop doesn't exist */
7167c478bd9Sstevel@tonic-gate 		return (0);
7177c478bd9Sstevel@tonic-gate 
7187c478bd9Sstevel@tonic-gate 	err = ptree_get_propinfo(proph, &pinfo);
7197c478bd9Sstevel@tonic-gate 	if (pinfo.piclinfo.type != PICL_PTYPE_CHARSTRING)
7207c478bd9Sstevel@tonic-gate 		return (0);	/* not string prop */
7217c478bd9Sstevel@tonic-gate 
7227c478bd9Sstevel@tonic-gate 	len = strlen(pval) + 1;
7237c478bd9Sstevel@tonic-gate 
7247c478bd9Sstevel@tonic-gate 	pvalbuf = alloca(len);
7257c478bd9Sstevel@tonic-gate 	if (pvalbuf == NULL)
7267c478bd9Sstevel@tonic-gate 		return (0);
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate 	err = ptree_get_propval(proph, pvalbuf, len);
7297c478bd9Sstevel@tonic-gate 	if ((err == PICL_SUCCESS) && (strcmp(pvalbuf, pval) == 0))
7307c478bd9Sstevel@tonic-gate 		return (1);	/* prop match */
7317c478bd9Sstevel@tonic-gate 
7327c478bd9Sstevel@tonic-gate 	return (0);
7337c478bd9Sstevel@tonic-gate }
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate /*
7367c478bd9Sstevel@tonic-gate  * This function recursively searches the tree for a node that has
7377c478bd9Sstevel@tonic-gate  * the specified string property name and value
7387c478bd9Sstevel@tonic-gate  */
7397c478bd9Sstevel@tonic-gate static int
7407c478bd9Sstevel@tonic-gate find_node_by_string_prop(picl_nodehdl_t rooth, const char *pname,
7417c478bd9Sstevel@tonic-gate     const char *pval, picl_nodehdl_t *nodeh)
7427c478bd9Sstevel@tonic-gate {
7437c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		childh;
7447c478bd9Sstevel@tonic-gate 	int			err;
7457c478bd9Sstevel@tonic-gate 
7467c478bd9Sstevel@tonic-gate 	for (err = ptree_get_propval_by_name(rooth, PICL_PROP_CHILD, &childh,
7477c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t)); err != PICL_PROPNOTFOUND;
7485e3e415aSfw 	    err = ptree_get_propval_by_name(childh, PICL_PROP_PEER, &childh,
7495e3e415aSfw 	    sizeof (picl_nodehdl_t))) {
7507c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
7517c478bd9Sstevel@tonic-gate 			return (err);
7527c478bd9Sstevel@tonic-gate 
7537c478bd9Sstevel@tonic-gate 		if (compare_string_propval(childh, pname, pval)) {
7547c478bd9Sstevel@tonic-gate 			*nodeh = childh;
7557c478bd9Sstevel@tonic-gate 			return (PICL_SUCCESS);
7567c478bd9Sstevel@tonic-gate 		}
7577c478bd9Sstevel@tonic-gate 
7587c478bd9Sstevel@tonic-gate 		if (find_node_by_string_prop(childh, pname, pval, nodeh) ==
7597c478bd9Sstevel@tonic-gate 		    PICL_SUCCESS)
7607c478bd9Sstevel@tonic-gate 			return (PICL_SUCCESS);
7617c478bd9Sstevel@tonic-gate 	}
7627c478bd9Sstevel@tonic-gate 
7637c478bd9Sstevel@tonic-gate 	return (PICL_FAILURE);
7647c478bd9Sstevel@tonic-gate }
7657c478bd9Sstevel@tonic-gate 
7667c478bd9Sstevel@tonic-gate /*
7677c478bd9Sstevel@tonic-gate  * check if this is a string prop
7687c478bd9Sstevel@tonic-gate  * If the length is less than or equal to 4, assume it's not a string list.
7697c478bd9Sstevel@tonic-gate  * If there is any non-ascii or non-print char, it's not a string prop
7707c478bd9Sstevel@tonic-gate  * If \0 is in the first char or any two consecutive \0's exist,
7717c478bd9Sstevel@tonic-gate  * it's a bytearray prop.
7727c478bd9Sstevel@tonic-gate  * Return value: 0 means it's not a string prop, 1 means it's a string prop
7737c478bd9Sstevel@tonic-gate  */
7747c478bd9Sstevel@tonic-gate static int
7757c478bd9Sstevel@tonic-gate is_string_propval(unsigned char *pdata, int len)
7767c478bd9Sstevel@tonic-gate {
7777c478bd9Sstevel@tonic-gate 	int	i;
7787c478bd9Sstevel@tonic-gate 	int	lastindex;
7797c478bd9Sstevel@tonic-gate 	int	prevnull = -1;
7807c478bd9Sstevel@tonic-gate 
7817c478bd9Sstevel@tonic-gate 	switch (len) {
7827c478bd9Sstevel@tonic-gate 	case 1:
7837c478bd9Sstevel@tonic-gate 		if (!isascii(pdata[0]) || !isprint(pdata[0]))
7847c478bd9Sstevel@tonic-gate 			return (0);
7857c478bd9Sstevel@tonic-gate 		return (1);
7867c478bd9Sstevel@tonic-gate 	case 2:
7877c478bd9Sstevel@tonic-gate 	case 3:
7887c478bd9Sstevel@tonic-gate 	case 4:
7897c478bd9Sstevel@tonic-gate 		lastindex = len;
7907c478bd9Sstevel@tonic-gate 		if (pdata[len-1] == '\0')
7917c478bd9Sstevel@tonic-gate 			lastindex = len - 1;
7927c478bd9Sstevel@tonic-gate 
7937c478bd9Sstevel@tonic-gate 		for (i = 0; i < lastindex; i++)
7947c478bd9Sstevel@tonic-gate 			if (!isascii(pdata[i]) || !isprint(pdata[i]))
7957c478bd9Sstevel@tonic-gate 				return (0);
7967c478bd9Sstevel@tonic-gate 
7977c478bd9Sstevel@tonic-gate 		return (1);
7987c478bd9Sstevel@tonic-gate 
7997c478bd9Sstevel@tonic-gate 	default:
8007c478bd9Sstevel@tonic-gate 		if (len <= 0)
8017c478bd9Sstevel@tonic-gate 			return (0);
8027c478bd9Sstevel@tonic-gate 		for (i = 0; i < len; i++) {
8037c478bd9Sstevel@tonic-gate 			if (!isascii(pdata[i]) || !isprint(pdata[i])) {
8047c478bd9Sstevel@tonic-gate 				if (pdata[i] != '\0')
8057c478bd9Sstevel@tonic-gate 					return (0);
8067c478bd9Sstevel@tonic-gate 				/*
8077c478bd9Sstevel@tonic-gate 				 * if the null char is in the first char
8087c478bd9Sstevel@tonic-gate 				 * or two consecutive nulls' exist,
8097c478bd9Sstevel@tonic-gate 				 * it's a bytearray prop
8107c478bd9Sstevel@tonic-gate 				 */
8117c478bd9Sstevel@tonic-gate 				if ((i == 0) || ((i - prevnull) == 1))
8127c478bd9Sstevel@tonic-gate 					return (0);
8137c478bd9Sstevel@tonic-gate 
8147c478bd9Sstevel@tonic-gate 				prevnull = i;
8157c478bd9Sstevel@tonic-gate 			}
8167c478bd9Sstevel@tonic-gate 		}
8177c478bd9Sstevel@tonic-gate 		break;
8187c478bd9Sstevel@tonic-gate 	}
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	return (1);
8217c478bd9Sstevel@tonic-gate }
8227c478bd9Sstevel@tonic-gate 
8237c478bd9Sstevel@tonic-gate /*
8247c478bd9Sstevel@tonic-gate  * This function counts the number of strings in the value buffer pdata
8257c478bd9Sstevel@tonic-gate  * and creates a property.
8267c478bd9Sstevel@tonic-gate  * If there is only one string in the buffer, pdata, a charstring property
8277c478bd9Sstevel@tonic-gate  * type is created and added.
8287c478bd9Sstevel@tonic-gate  * If there are more than one string in the buffer, pdata, then a table
8297c478bd9Sstevel@tonic-gate  * of charstrings is added.
8307c478bd9Sstevel@tonic-gate  */
8317c478bd9Sstevel@tonic-gate static int
8327c478bd9Sstevel@tonic-gate process_charstring_data(picl_nodehdl_t nodeh, char *pname, unsigned char *pdata,
8337c478bd9Sstevel@tonic-gate     int retval)
8347c478bd9Sstevel@tonic-gate {
8357c478bd9Sstevel@tonic-gate 	int			err;
8367c478bd9Sstevel@tonic-gate 	int			strcount;
8377c478bd9Sstevel@tonic-gate 	char			*strdat;
8387c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
8397c478bd9Sstevel@tonic-gate 
8407c478bd9Sstevel@tonic-gate 	/*
8417c478bd9Sstevel@tonic-gate 	 * append the null char at the end of string when there is
8427c478bd9Sstevel@tonic-gate 	 * no null terminator
8437c478bd9Sstevel@tonic-gate 	 */
8447c478bd9Sstevel@tonic-gate 	if (pdata[retval - 1] != '\0') {
8457c478bd9Sstevel@tonic-gate 		strdat = alloca(retval + 1);
8467c478bd9Sstevel@tonic-gate 		(void) memcpy(strdat, pdata, retval);
8477c478bd9Sstevel@tonic-gate 		strdat[retval] = '\0';
8487c478bd9Sstevel@tonic-gate 		retval++;
8497c478bd9Sstevel@tonic-gate 	} else {
8507c478bd9Sstevel@tonic-gate 		strdat = alloca(retval);
8517c478bd9Sstevel@tonic-gate 		(void) memcpy(strdat, pdata, retval);
8527c478bd9Sstevel@tonic-gate 	}
8537c478bd9Sstevel@tonic-gate 
8547c478bd9Sstevel@tonic-gate 	/*
8557c478bd9Sstevel@tonic-gate 	 * If it's a string list, create a table prop
8567c478bd9Sstevel@tonic-gate 	 */
8577c478bd9Sstevel@tonic-gate 	strcount = get_string_count(strdat, retval);
8587c478bd9Sstevel@tonic-gate 	if (strcount > 1) {
8597c478bd9Sstevel@tonic-gate 		err = add_string_list_prop(nodeh, pname,
8607c478bd9Sstevel@tonic-gate 		    strdat, strcount);
8617c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
8627c478bd9Sstevel@tonic-gate 			return (err);
8637c478bd9Sstevel@tonic-gate 	} else {
8647c478bd9Sstevel@tonic-gate 		err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
8657c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ,
8667c478bd9Sstevel@tonic-gate 		    strlen(strdat) + 1, pname, NULL,
8677c478bd9Sstevel@tonic-gate 		    NULL);
8687c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
8697c478bd9Sstevel@tonic-gate 			return (err);
8707c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &propinfo,
8717c478bd9Sstevel@tonic-gate 		    strdat, NULL);
8727c478bd9Sstevel@tonic-gate 	}
8737c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
8747c478bd9Sstevel@tonic-gate }
8757c478bd9Sstevel@tonic-gate 
8767c478bd9Sstevel@tonic-gate /*
8777c478bd9Sstevel@tonic-gate  * Add the OBP properties as properties of the PICL node
8787c478bd9Sstevel@tonic-gate  */
8797c478bd9Sstevel@tonic-gate static int
8807c478bd9Sstevel@tonic-gate add_openprom_props(picl_nodehdl_t nodeh, di_node_t di_node)
8817c478bd9Sstevel@tonic-gate {
8827c478bd9Sstevel@tonic-gate 	di_prom_prop_t		promp;
8837c478bd9Sstevel@tonic-gate 	char			*pname;
8847c478bd9Sstevel@tonic-gate 	unsigned char		*pdata;
8857c478bd9Sstevel@tonic-gate 	int			retval;
8867c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
8877c478bd9Sstevel@tonic-gate 	int			err;
8887c478bd9Sstevel@tonic-gate 	picl_prop_type_t	type;
8897c478bd9Sstevel@tonic-gate 
8907c478bd9Sstevel@tonic-gate 	if (!ph)
8917c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
8927c478bd9Sstevel@tonic-gate 
8937c478bd9Sstevel@tonic-gate 	for (promp = di_prom_prop_next(ph, di_node, DI_PROM_PROP_NIL);
8947c478bd9Sstevel@tonic-gate 	    promp != DI_PROM_PROP_NIL;
8955e3e415aSfw 	    promp = di_prom_prop_next(ph, di_node, promp)) {
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 		pname = di_prom_prop_name(promp);
8987c478bd9Sstevel@tonic-gate 
8997c478bd9Sstevel@tonic-gate 		retval = di_prom_prop_data(promp, &pdata);
9007c478bd9Sstevel@tonic-gate 		if (retval < 0) {
9017c478bd9Sstevel@tonic-gate 			return (PICL_SUCCESS);
9027c478bd9Sstevel@tonic-gate 		}
9037c478bd9Sstevel@tonic-gate 		if (retval == 0) {
9047c478bd9Sstevel@tonic-gate 			err = ptree_init_propinfo(&propinfo,
9057c478bd9Sstevel@tonic-gate 			    PTREE_PROPINFO_VERSION, PICL_PTYPE_VOID,
9067c478bd9Sstevel@tonic-gate 			    PICL_READ, (size_t)0, pname, NULL, NULL);
9077c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
9087c478bd9Sstevel@tonic-gate 				return (err);
9097c478bd9Sstevel@tonic-gate 			}
9107c478bd9Sstevel@tonic-gate 			(void) ptree_create_and_add_prop(nodeh, &propinfo, NULL,
9117c478bd9Sstevel@tonic-gate 			    NULL);
9127c478bd9Sstevel@tonic-gate 			continue;
9137c478bd9Sstevel@tonic-gate 		}
9147c478bd9Sstevel@tonic-gate 
9157c478bd9Sstevel@tonic-gate 		/*
9167c478bd9Sstevel@tonic-gate 		 * Get the prop type from pname map table
9177c478bd9Sstevel@tonic-gate 		 */
9187c478bd9Sstevel@tonic-gate 		if (lookup_pname_type_map(pname, &type) == 0) {
9197c478bd9Sstevel@tonic-gate 			if (type == PICL_PTYPE_CHARSTRING) {
9207c478bd9Sstevel@tonic-gate 				err = process_charstring_data(nodeh, pname,
9217c478bd9Sstevel@tonic-gate 				    pdata, retval);
9227c478bd9Sstevel@tonic-gate 				if (err != PICL_SUCCESS) {
9237c478bd9Sstevel@tonic-gate 					return (err);
9247c478bd9Sstevel@tonic-gate 				}
9257c478bd9Sstevel@tonic-gate 				continue;
9267c478bd9Sstevel@tonic-gate 			}
9277c478bd9Sstevel@tonic-gate 
9287c478bd9Sstevel@tonic-gate 			err = ptree_init_propinfo(&propinfo,
9297c478bd9Sstevel@tonic-gate 			    PTREE_PROPINFO_VERSION, type, PICL_READ,
9307c478bd9Sstevel@tonic-gate 			    retval, pname, NULL, NULL);
9317c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
9327c478bd9Sstevel@tonic-gate 				return (err);
9337c478bd9Sstevel@tonic-gate 			}
9347c478bd9Sstevel@tonic-gate 			(void) ptree_create_and_add_prop(nodeh, &propinfo,
9357c478bd9Sstevel@tonic-gate 			    pdata, NULL);
9367c478bd9Sstevel@tonic-gate 		} else if (!is_string_propval(pdata, retval)) {
9377c478bd9Sstevel@tonic-gate 			switch (retval) {
9387c478bd9Sstevel@tonic-gate 			case sizeof (uint8_t):
9397c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
9407c478bd9Sstevel@tonic-gate 			case sizeof (uint16_t):
9417c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
9427c478bd9Sstevel@tonic-gate 			case sizeof (uint32_t):
9437c478bd9Sstevel@tonic-gate 				type = PICL_PTYPE_UNSIGNED_INT;
9447c478bd9Sstevel@tonic-gate 				break;
9457c478bd9Sstevel@tonic-gate 			default:
9467c478bd9Sstevel@tonic-gate 				type = PICL_PTYPE_BYTEARRAY;
9477c478bd9Sstevel@tonic-gate 				break;
9487c478bd9Sstevel@tonic-gate 			}
9497c478bd9Sstevel@tonic-gate 			err = ptree_init_propinfo(&propinfo,
9507c478bd9Sstevel@tonic-gate 			    PTREE_PROPINFO_VERSION, type, PICL_READ,
9517c478bd9Sstevel@tonic-gate 			    retval, pname, NULL, NULL);
9527c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
9537c478bd9Sstevel@tonic-gate 				return (err);
9547c478bd9Sstevel@tonic-gate 			}
9557c478bd9Sstevel@tonic-gate 			(void) ptree_create_and_add_prop(nodeh, &propinfo,
9567c478bd9Sstevel@tonic-gate 			    pdata, NULL);
9577c478bd9Sstevel@tonic-gate 		} else {
9587c478bd9Sstevel@tonic-gate 			err = process_charstring_data(nodeh, pname, pdata,
9597c478bd9Sstevel@tonic-gate 			    retval);
9607c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
9617c478bd9Sstevel@tonic-gate 				return (err);
9627c478bd9Sstevel@tonic-gate 			}
9637c478bd9Sstevel@tonic-gate 		}
9647c478bd9Sstevel@tonic-gate 	}
9657c478bd9Sstevel@tonic-gate 
9667c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
9677c478bd9Sstevel@tonic-gate }
9687c478bd9Sstevel@tonic-gate 
96961db5dcaSrd static void
97061db5dcaSrd add_boolean_prop(picl_nodehdl_t nodeh, ptree_propinfo_t propinfo, char *di_val)
97161db5dcaSrd {
97261db5dcaSrd 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
97361db5dcaSrd 	    PICL_PTYPE_VOID, PICL_READ, (size_t)0, di_val, NULL, NULL);
97461db5dcaSrd 	(void) ptree_create_and_add_prop(nodeh, &propinfo, NULL, NULL);
97561db5dcaSrd }
97661db5dcaSrd 
97761db5dcaSrd static void
97861db5dcaSrd add_uints_prop(picl_nodehdl_t nodeh, ptree_propinfo_t propinfo, char *di_val,
97961db5dcaSrd     int *idata, int len)
98061db5dcaSrd {
98161db5dcaSrd 	if (len == 1)
98261db5dcaSrd 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
98361db5dcaSrd 		    PICL_PTYPE_UNSIGNED_INT, PICL_READ, sizeof (int), di_val,
98461db5dcaSrd 		    NULL, NULL);
98561db5dcaSrd 	else
98661db5dcaSrd 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
98761db5dcaSrd 		    PICL_PTYPE_BYTEARRAY, PICL_READ, len * sizeof (int), di_val,
98861db5dcaSrd 		    NULL, NULL);
98961db5dcaSrd 
99061db5dcaSrd 	(void) ptree_create_and_add_prop(nodeh, &propinfo, idata, NULL);
99161db5dcaSrd }
99261db5dcaSrd 
99361db5dcaSrd static void
99461db5dcaSrd add_strings_prop(picl_nodehdl_t nodeh, ptree_propinfo_t propinfo, char *di_val,
99561db5dcaSrd     char *sdata, int len)
99661db5dcaSrd {
99761db5dcaSrd 	if (len == 1) {
99861db5dcaSrd 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
99961db5dcaSrd 		    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(sdata) + 1, di_val,
100061db5dcaSrd 		    NULL, NULL);
100161db5dcaSrd 		(void) ptree_create_and_add_prop(nodeh, &propinfo, sdata, NULL);
100261db5dcaSrd 	} else {
100361db5dcaSrd 		(void) add_string_list_prop(nodeh, di_val, sdata, len);
100461db5dcaSrd 	}
100561db5dcaSrd }
100661db5dcaSrd 
100761db5dcaSrd static void
100861db5dcaSrd add_bytes_prop(picl_nodehdl_t nodeh, ptree_propinfo_t propinfo, char *di_val,
100961db5dcaSrd     unsigned char *bdata, int len)
101061db5dcaSrd {
101161db5dcaSrd 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
101261db5dcaSrd 	    PICL_PTYPE_BYTEARRAY, PICL_READ, len, di_val, NULL, NULL);
101361db5dcaSrd 	(void) ptree_create_and_add_prop(nodeh, &propinfo, bdata, NULL);
101461db5dcaSrd }
101561db5dcaSrd 
101643e66171SMichael Bergknoff static const char *
101743e66171SMichael Bergknoff path_state_name(di_path_state_t st)
101843e66171SMichael Bergknoff {
101943e66171SMichael Bergknoff 	switch (st) {
102043e66171SMichael Bergknoff 		case DI_PATH_STATE_ONLINE:
102143e66171SMichael Bergknoff 			return ("online");
102243e66171SMichael Bergknoff 		case DI_PATH_STATE_STANDBY:
102343e66171SMichael Bergknoff 			return ("standby");
102443e66171SMichael Bergknoff 		case DI_PATH_STATE_OFFLINE:
102543e66171SMichael Bergknoff 			return ("offline");
102643e66171SMichael Bergknoff 		case DI_PATH_STATE_FAULT:
102743e66171SMichael Bergknoff 			return ("faulted");
102843e66171SMichael Bergknoff 	}
102943e66171SMichael Bergknoff 	return ("unknown");
103043e66171SMichael Bergknoff }
103143e66171SMichael Bergknoff 
103243e66171SMichael Bergknoff /*
103343e66171SMichael Bergknoff  * This function is the volatile property handler for the multipath node
103443e66171SMichael Bergknoff  * "State" property. It must locate the associated devinfo node in order to
103543e66171SMichael Bergknoff  * determine the current state. Since the devinfo node can have multiple
103643e66171SMichael Bergknoff  * paths the devfs_path is used to locate the correct path.
103743e66171SMichael Bergknoff  */
103843e66171SMichael Bergknoff static int
103943e66171SMichael Bergknoff get_path_state_name(ptree_rarg_t *rarg, void *vbuf)
104043e66171SMichael Bergknoff {
104143e66171SMichael Bergknoff 	int		err;
104243e66171SMichael Bergknoff 	picl_nodehdl_t	parh;
104343e66171SMichael Bergknoff 	char		devfs_path[PATH_MAX];
104443e66171SMichael Bergknoff 	di_node_t	di_node;
104543e66171SMichael Bergknoff 	di_node_t	di_root;
104643e66171SMichael Bergknoff 	di_path_t	pi = DI_PATH_NIL;
104743e66171SMichael Bergknoff 	picl_nodehdl_t	mpnode;
104843e66171SMichael Bergknoff 
104943e66171SMichael Bergknoff 	(void) strlcpy(vbuf, "unknown", MAX_STATE_SIZE);
105043e66171SMichael Bergknoff 
105143e66171SMichael Bergknoff 	mpnode = rarg->nodeh;
105243e66171SMichael Bergknoff 
105343e66171SMichael Bergknoff 	/*
105443e66171SMichael Bergknoff 	 * The parent node represents the vHCI.
105543e66171SMichael Bergknoff 	 */
105643e66171SMichael Bergknoff 	err = ptree_get_propval_by_name(mpnode, PICL_PROP_PARENT, &parh,
105743e66171SMichael Bergknoff 	    sizeof (picl_nodehdl_t));
105843e66171SMichael Bergknoff 	if (err != PICL_SUCCESS) {
105943e66171SMichael Bergknoff 		return (PICL_SUCCESS);
106043e66171SMichael Bergknoff 	}
106143e66171SMichael Bergknoff 
106243e66171SMichael Bergknoff 	/*
106343e66171SMichael Bergknoff 	 * The PICL_PROP_DEVFS_PATH property will be used to locate the
106443e66171SMichael Bergknoff 	 * devinfo node for the vHCI driver.
106543e66171SMichael Bergknoff 	 */
106643e66171SMichael Bergknoff 	err = ptree_get_propval_by_name(parh, PICL_PROP_DEVFS_PATH, devfs_path,
106743e66171SMichael Bergknoff 	    sizeof (devfs_path));
106843e66171SMichael Bergknoff 	if (err != PICL_SUCCESS) {
106943e66171SMichael Bergknoff 		return (PICL_SUCCESS);
107043e66171SMichael Bergknoff 	}
107143e66171SMichael Bergknoff 	/*
107243e66171SMichael Bergknoff 	 * Find the di_node for the vHCI driver. It will be used to scan
107343e66171SMichael Bergknoff 	 * the path information nodes.
107443e66171SMichael Bergknoff 	 */
107543e66171SMichael Bergknoff 	di_root = di_init("/", DINFOCACHE);
107643e66171SMichael Bergknoff 	if (di_root == DI_NODE_NIL) {
107743e66171SMichael Bergknoff 		return (PICL_SUCCESS);
107843e66171SMichael Bergknoff 	}
107943e66171SMichael Bergknoff 	di_node = di_lookup_node(di_root, devfs_path);
108043e66171SMichael Bergknoff 	if (di_node == DI_NODE_NIL) {
108143e66171SMichael Bergknoff 		di_fini(di_root);
108243e66171SMichael Bergknoff 		return (PICL_SUCCESS);
108343e66171SMichael Bergknoff 	}
108443e66171SMichael Bergknoff 
108543e66171SMichael Bergknoff 	/*
108643e66171SMichael Bergknoff 	 * The devfs_path will be used below to match the
108743e66171SMichael Bergknoff 	 * proper path information node.
108843e66171SMichael Bergknoff 	 */
108943e66171SMichael Bergknoff 	err = ptree_get_propval_by_name(mpnode, PICL_PROP_DEVFS_PATH,
109043e66171SMichael Bergknoff 	    devfs_path, sizeof (devfs_path));
109143e66171SMichael Bergknoff 	if (err != PICL_SUCCESS) {
109243e66171SMichael Bergknoff 		di_fini(di_root);
109343e66171SMichael Bergknoff 		return (PICL_SUCCESS);
109443e66171SMichael Bergknoff 	}
109543e66171SMichael Bergknoff 
109643e66171SMichael Bergknoff 	/*
109743e66171SMichael Bergknoff 	 * Scan the path information nodes looking for the matching devfs
109843e66171SMichael Bergknoff 	 * path. When found obtain the state information.
109943e66171SMichael Bergknoff 	 */
110043e66171SMichael Bergknoff 	while ((pi = di_path_next_phci(di_node, pi)) != DI_PATH_NIL) {
110143e66171SMichael Bergknoff 		char		*di_path;
110243e66171SMichael Bergknoff 		di_node_t	phci_node = di_path_phci_node(pi);
110343e66171SMichael Bergknoff 
110443e66171SMichael Bergknoff 		if (phci_node == DI_PATH_NIL)
110543e66171SMichael Bergknoff 			continue;
110643e66171SMichael Bergknoff 
110743e66171SMichael Bergknoff 		di_path = di_devfs_path(phci_node);
110843e66171SMichael Bergknoff 		if (di_path) {
110943e66171SMichael Bergknoff 			if (strcmp(di_path, devfs_path) != 0) {
111043e66171SMichael Bergknoff 				di_devfs_path_free(di_path);
111143e66171SMichael Bergknoff 				continue;
111243e66171SMichael Bergknoff 			}
111343e66171SMichael Bergknoff 			(void) strlcpy(vbuf, path_state_name(di_path_state(pi)),
111443e66171SMichael Bergknoff 			    MAX_STATE_SIZE);
111543e66171SMichael Bergknoff 			di_devfs_path_free(di_path);
111643e66171SMichael Bergknoff 			break;
111743e66171SMichael Bergknoff 		}
111843e66171SMichael Bergknoff 	}
111943e66171SMichael Bergknoff 
112043e66171SMichael Bergknoff 	di_fini(di_root);
112143e66171SMichael Bergknoff 	return (PICL_SUCCESS);
112243e66171SMichael Bergknoff }
112343e66171SMichael Bergknoff 
112443e66171SMichael Bergknoff static void
112543e66171SMichael Bergknoff add_di_path_prop(picl_nodehdl_t nodeh, di_path_prop_t di_path_prop)
112643e66171SMichael Bergknoff {
112743e66171SMichael Bergknoff 	int			di_ptype;
112843e66171SMichael Bergknoff 	char			*di_val;
112943e66171SMichael Bergknoff 	ptree_propinfo_t	propinfo;
113043e66171SMichael Bergknoff 	int			*idata;
113143e66171SMichael Bergknoff 	char			*sdata;
113243e66171SMichael Bergknoff 	unsigned char		*bdata;
113343e66171SMichael Bergknoff 	int			len;
113443e66171SMichael Bergknoff 
113543e66171SMichael Bergknoff 	di_ptype = di_path_prop_type(di_path_prop);
113643e66171SMichael Bergknoff 	di_val = di_path_prop_name(di_path_prop);
113743e66171SMichael Bergknoff 
113843e66171SMichael Bergknoff 	switch (di_ptype) {
113943e66171SMichael Bergknoff 	case DI_PROP_TYPE_BOOLEAN:
114043e66171SMichael Bergknoff 		add_boolean_prop(nodeh, propinfo, di_val);
114143e66171SMichael Bergknoff 		break;
114243e66171SMichael Bergknoff 	case DI_PROP_TYPE_INT:
114343e66171SMichael Bergknoff 	case DI_PROP_TYPE_INT64:
114443e66171SMichael Bergknoff 		len = di_path_prop_ints(di_path_prop, &idata);
114543e66171SMichael Bergknoff 		if (len < 0)
114643e66171SMichael Bergknoff 			/* Received error, so ignore prop */
114743e66171SMichael Bergknoff 			break;
114843e66171SMichael Bergknoff 		add_uints_prop(nodeh, propinfo, di_val, idata, len);
114943e66171SMichael Bergknoff 		break;
115043e66171SMichael Bergknoff 	case DI_PROP_TYPE_STRING:
115143e66171SMichael Bergknoff 		len = di_path_prop_strings(di_path_prop, &sdata);
115243e66171SMichael Bergknoff 		if (len <= 0)
115343e66171SMichael Bergknoff 			break;
115443e66171SMichael Bergknoff 		add_strings_prop(nodeh, propinfo, di_val, sdata, len);
115543e66171SMichael Bergknoff 		break;
115643e66171SMichael Bergknoff 	case DI_PROP_TYPE_BYTE:
115743e66171SMichael Bergknoff 		len = di_path_prop_bytes(di_path_prop, &bdata);
115843e66171SMichael Bergknoff 		if (len < 0)
115943e66171SMichael Bergknoff 			break;
116043e66171SMichael Bergknoff 		add_bytes_prop(nodeh, propinfo, di_val, bdata, len);
116143e66171SMichael Bergknoff 		break;
116243e66171SMichael Bergknoff 	case DI_PROP_TYPE_UNKNOWN:
116343e66171SMichael Bergknoff 		/*
116443e66171SMichael Bergknoff 		 * Unknown type, we'll try and guess what it should be.
116543e66171SMichael Bergknoff 		 */
116643e66171SMichael Bergknoff 		len = di_path_prop_strings(di_path_prop, &sdata);
116743e66171SMichael Bergknoff 		if ((len > 0) && (sdata[0] != 0)) {
116843e66171SMichael Bergknoff 			add_strings_prop(nodeh, propinfo, di_val, sdata,
116943e66171SMichael Bergknoff 			    len);
117043e66171SMichael Bergknoff 			break;
117143e66171SMichael Bergknoff 		}
117243e66171SMichael Bergknoff 		len = di_path_prop_ints(di_path_prop, &idata);
117343e66171SMichael Bergknoff 		if (len > 0) {
117443e66171SMichael Bergknoff 			add_uints_prop(nodeh, propinfo, di_val,
117543e66171SMichael Bergknoff 			    idata, len);
117643e66171SMichael Bergknoff 			break;
117743e66171SMichael Bergknoff 		}
117843e66171SMichael Bergknoff 		len = di_path_prop_bytes(di_path_prop, &bdata);
117943e66171SMichael Bergknoff 		if (len > 0)
118043e66171SMichael Bergknoff 			add_bytes_prop(nodeh, propinfo,
118143e66171SMichael Bergknoff 			    di_val, bdata, len);
118243e66171SMichael Bergknoff 		else if (len == 0)
118343e66171SMichael Bergknoff 			add_boolean_prop(nodeh, propinfo,
118443e66171SMichael Bergknoff 			    di_val);
118543e66171SMichael Bergknoff 		break;
118643e66171SMichael Bergknoff 	case DI_PROP_TYPE_UNDEF_IT:
118743e66171SMichael Bergknoff 		break;
118843e66171SMichael Bergknoff 	default:
118943e66171SMichael Bergknoff 		break;
119043e66171SMichael Bergknoff 	}
119143e66171SMichael Bergknoff }
119243e66171SMichael Bergknoff 
119343e66171SMichael Bergknoff /*
119443e66171SMichael Bergknoff  * Add nodes for path information (PSARC/1999/647, PSARC/2008/437)
119543e66171SMichael Bergknoff  */
119643e66171SMichael Bergknoff static void
119743e66171SMichael Bergknoff construct_mpath_node(picl_nodehdl_t parh, di_node_t di_node)
119843e66171SMichael Bergknoff {
119943e66171SMichael Bergknoff 	di_path_t 		pi = DI_PATH_NIL;
120043e66171SMichael Bergknoff 
120143e66171SMichael Bergknoff 	while ((pi = di_path_next_phci(di_node, pi)) != DI_PATH_NIL) {
120243e66171SMichael Bergknoff 		di_node_t 		phci_node = di_path_phci_node(pi);
120343e66171SMichael Bergknoff 		di_path_prop_t 		di_path_prop;
120443e66171SMichael Bergknoff 		picl_nodehdl_t		nodeh;
120543e66171SMichael Bergknoff 		ptree_propinfo_t	propinfo;
120643e66171SMichael Bergknoff 		int			err;
120743e66171SMichael Bergknoff 		int			instance;
120843e66171SMichael Bergknoff 		char			*di_val;
120943e66171SMichael Bergknoff 
121043e66171SMichael Bergknoff 		if (phci_node == DI_PATH_NIL)
121143e66171SMichael Bergknoff 			continue;
121243e66171SMichael Bergknoff 
121343e66171SMichael Bergknoff 		err = ptree_create_and_add_node(parh, PICL_CLASS_MULTIPATH,
121443e66171SMichael Bergknoff 		    PICL_CLASS_MULTIPATH, &nodeh);
121543e66171SMichael Bergknoff 		if (err != PICL_SUCCESS)
121643e66171SMichael Bergknoff 			continue;
121743e66171SMichael Bergknoff 
121843e66171SMichael Bergknoff 		instance = di_instance(phci_node);
121943e66171SMichael Bergknoff 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
122043e66171SMichael Bergknoff 		    PICL_PTYPE_INT, PICL_READ, sizeof (instance),
122143e66171SMichael Bergknoff 		    PICL_PROP_INSTANCE, NULL, NULL);
122243e66171SMichael Bergknoff 		(void) ptree_create_and_add_prop(nodeh, &propinfo, &instance,
122343e66171SMichael Bergknoff 		    NULL);
122443e66171SMichael Bergknoff 
122543e66171SMichael Bergknoff 		di_val = di_devfs_path(phci_node);
122643e66171SMichael Bergknoff 		if (di_val) {
122743e66171SMichael Bergknoff 			(void) ptree_init_propinfo(&propinfo,
122843e66171SMichael Bergknoff 			    PTREE_PROPINFO_VERSION,
122943e66171SMichael Bergknoff 			    PICL_PTYPE_CHARSTRING, PICL_READ,
123043e66171SMichael Bergknoff 			    strlen(di_val) + 1, PICL_PROP_DEVFS_PATH,
123143e66171SMichael Bergknoff 			    NULL, NULL);
123243e66171SMichael Bergknoff 			(void) ptree_create_and_add_prop(nodeh,
123343e66171SMichael Bergknoff 			    &propinfo, di_val, NULL);
123443e66171SMichael Bergknoff 			di_devfs_path_free(di_val);
123543e66171SMichael Bergknoff 		}
123643e66171SMichael Bergknoff 
123743e66171SMichael Bergknoff 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
123843e66171SMichael Bergknoff 		    PICL_PTYPE_CHARSTRING, (PICL_READ|PICL_VOLATILE),
123943e66171SMichael Bergknoff 		    MAX_STATE_SIZE, PICL_PROP_STATE, get_path_state_name, NULL);
124043e66171SMichael Bergknoff 		(void) ptree_create_and_add_prop(nodeh, &propinfo, NULL, NULL);
124143e66171SMichael Bergknoff 
124243e66171SMichael Bergknoff 		for (di_path_prop = di_path_prop_next(pi, DI_PROP_NIL);
124343e66171SMichael Bergknoff 		    di_path_prop != DI_PROP_NIL;
124443e66171SMichael Bergknoff 		    di_path_prop = di_path_prop_next(pi, di_path_prop)) {
124543e66171SMichael Bergknoff 			add_di_path_prop(nodeh, di_path_prop);
124643e66171SMichael Bergknoff 		}
124743e66171SMichael Bergknoff 	}
124843e66171SMichael Bergknoff }
124943e66171SMichael Bergknoff 
12507c478bd9Sstevel@tonic-gate /*
12517c478bd9Sstevel@tonic-gate  * Add properties provided by libdevinfo
12527c478bd9Sstevel@tonic-gate  */
12537c478bd9Sstevel@tonic-gate static void
12547c478bd9Sstevel@tonic-gate add_devinfo_props(picl_nodehdl_t nodeh, di_node_t di_node)
12557c478bd9Sstevel@tonic-gate {
12567c478bd9Sstevel@tonic-gate 	int			instance;
12577c478bd9Sstevel@tonic-gate 	char			*di_val;
12587c478bd9Sstevel@tonic-gate 	di_prop_t		di_prop;
12597c478bd9Sstevel@tonic-gate 	int			di_ptype;
12607c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
126161db5dcaSrd 	char			*sdata;
126261db5dcaSrd 	unsigned char		*bdata;
126361db5dcaSrd 	int			*idata;
126461db5dcaSrd 	int			len;
12657c478bd9Sstevel@tonic-gate 
12667c478bd9Sstevel@tonic-gate 	instance = di_instance(di_node);
12677c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
12687c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_INT, PICL_READ, sizeof (instance), PICL_PROP_INSTANCE,
12697c478bd9Sstevel@tonic-gate 	    NULL, NULL);
12707c478bd9Sstevel@tonic-gate 	(void) ptree_create_and_add_prop(nodeh, &propinfo, &instance, NULL);
12717c478bd9Sstevel@tonic-gate 
12727c478bd9Sstevel@tonic-gate 	di_val = di_bus_addr(di_node);
12737c478bd9Sstevel@tonic-gate 	if (di_val) {
12747c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
12757c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(di_val) + 1,
12767c478bd9Sstevel@tonic-gate 		    PICL_PROP_BUS_ADDR, NULL, NULL);
12777c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &propinfo, di_val,
12787c478bd9Sstevel@tonic-gate 		    NULL);
12797c478bd9Sstevel@tonic-gate 	}
12807c478bd9Sstevel@tonic-gate 
12817c478bd9Sstevel@tonic-gate 	di_val = di_binding_name(di_node);
12827c478bd9Sstevel@tonic-gate 	if (di_val) {
12837c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
12847c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(di_val) + 1,
12857c478bd9Sstevel@tonic-gate 		    PICL_PROP_BINDING_NAME, NULL, NULL);
12867c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &propinfo, di_val,
12877c478bd9Sstevel@tonic-gate 		    NULL);
12887c478bd9Sstevel@tonic-gate 	}
12897c478bd9Sstevel@tonic-gate 
12907c478bd9Sstevel@tonic-gate 	di_val = di_driver_name(di_node);
12917c478bd9Sstevel@tonic-gate 	if (di_val) {
12927c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
12937c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(di_val) + 1,
12947c478bd9Sstevel@tonic-gate 		    PICL_PROP_DRIVER_NAME, NULL, NULL);
12957c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &propinfo, di_val,
12967c478bd9Sstevel@tonic-gate 		    NULL);
12977c478bd9Sstevel@tonic-gate 	}
12987c478bd9Sstevel@tonic-gate 
12997c478bd9Sstevel@tonic-gate 	di_val = di_devfs_path(di_node);
13007c478bd9Sstevel@tonic-gate 	if (di_val) {
13017c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
13027c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(di_val) + 1,
13037c478bd9Sstevel@tonic-gate 		    PICL_PROP_DEVFS_PATH, NULL, NULL);
13047c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &propinfo, di_val,
13057c478bd9Sstevel@tonic-gate 		    NULL);
13067c478bd9Sstevel@tonic-gate 		di_devfs_path_free(di_val);
13077c478bd9Sstevel@tonic-gate 	}
13087c478bd9Sstevel@tonic-gate 
13097c478bd9Sstevel@tonic-gate 	for (di_prop = di_prop_next(di_node, DI_PROP_NIL);
13107c478bd9Sstevel@tonic-gate 	    di_prop != DI_PROP_NIL;
13115e3e415aSfw 	    di_prop = di_prop_next(di_node, di_prop)) {
13127c478bd9Sstevel@tonic-gate 
13137c478bd9Sstevel@tonic-gate 		di_val = di_prop_name(di_prop);
13147c478bd9Sstevel@tonic-gate 		di_ptype = di_prop_type(di_prop);
131561db5dcaSrd 
13167c478bd9Sstevel@tonic-gate 		switch (di_ptype) {
13177c478bd9Sstevel@tonic-gate 		case DI_PROP_TYPE_BOOLEAN:
131861db5dcaSrd 			add_boolean_prop(nodeh, propinfo, di_val);
13197c478bd9Sstevel@tonic-gate 			break;
132061db5dcaSrd 		case DI_PROP_TYPE_INT:
13217c478bd9Sstevel@tonic-gate 			len = di_prop_ints(di_prop, &idata);
13227c478bd9Sstevel@tonic-gate 			if (len < 0)
132361db5dcaSrd 				/* Received error, so ignore prop */
13247c478bd9Sstevel@tonic-gate 				break;
132561db5dcaSrd 			add_uints_prop(nodeh, propinfo, di_val, idata, len);
132661db5dcaSrd 			break;
132761db5dcaSrd 		case DI_PROP_TYPE_STRING:
13287c478bd9Sstevel@tonic-gate 			len = di_prop_strings(di_prop, &sdata);
13297c478bd9Sstevel@tonic-gate 			if (len < 0)
13307c478bd9Sstevel@tonic-gate 				break;
133161db5dcaSrd 			add_strings_prop(nodeh, propinfo, di_val, sdata, len);
133261db5dcaSrd 			break;
133361db5dcaSrd 		case DI_PROP_TYPE_BYTE:
13347c478bd9Sstevel@tonic-gate 			len = di_prop_bytes(di_prop, &bdata);
13357c478bd9Sstevel@tonic-gate 			if (len < 0)
13367c478bd9Sstevel@tonic-gate 				break;
133761db5dcaSrd 			add_bytes_prop(nodeh, propinfo, di_val, bdata, len);
133861db5dcaSrd 			break;
13397c478bd9Sstevel@tonic-gate 		case DI_PROP_TYPE_UNKNOWN:
134061db5dcaSrd 			/*
134161db5dcaSrd 			 * Unknown type, we'll try and guess what it should be.
134261db5dcaSrd 			 */
134361db5dcaSrd 			len = di_prop_strings(di_prop, &sdata);
134461db5dcaSrd 			if ((len > 0) && (sdata[0] != 0)) {
134561db5dcaSrd 				add_strings_prop(nodeh, propinfo, di_val, sdata,
134661db5dcaSrd 				    len);
134761db5dcaSrd 				break;
134861db5dcaSrd 			}
134961db5dcaSrd 			len = di_prop_ints(di_prop, &idata);
135061db5dcaSrd 			if (len > 0) {
135161db5dcaSrd 				add_uints_prop(nodeh, propinfo, di_val,
135261db5dcaSrd 				    idata, len);
135361db5dcaSrd 				break;
135461db5dcaSrd 			}
135561db5dcaSrd 			len = di_prop_rawdata(di_prop, &bdata);
135661db5dcaSrd 			if (len > 0)
135761db5dcaSrd 				add_bytes_prop(nodeh, propinfo,
135861db5dcaSrd 				    di_val, bdata, len);
135961db5dcaSrd 			else if (len == 0)
136061db5dcaSrd 				add_boolean_prop(nodeh, propinfo,
136161db5dcaSrd 				    di_val);
13627c478bd9Sstevel@tonic-gate 			break;
13637c478bd9Sstevel@tonic-gate 		case DI_PROP_TYPE_UNDEF_IT:
13647c478bd9Sstevel@tonic-gate 			break;
13657c478bd9Sstevel@tonic-gate 		default:
13667c478bd9Sstevel@tonic-gate 			break;
13677c478bd9Sstevel@tonic-gate 		}
13687c478bd9Sstevel@tonic-gate 	}
13697c478bd9Sstevel@tonic-gate }
13707c478bd9Sstevel@tonic-gate 
13717c478bd9Sstevel@tonic-gate /*
13727c478bd9Sstevel@tonic-gate  * This function creates the /obp node in the PICL tree for OBP nodes
13737c478bd9Sstevel@tonic-gate  * without a device type class.
13747c478bd9Sstevel@tonic-gate  */
13757c478bd9Sstevel@tonic-gate static int
13767c478bd9Sstevel@tonic-gate construct_picl_openprom(picl_nodehdl_t rooth, picl_nodehdl_t *obph)
13777c478bd9Sstevel@tonic-gate {
13787c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	tmph;
13797c478bd9Sstevel@tonic-gate 	int		err;
13807c478bd9Sstevel@tonic-gate 
13817c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_node(rooth, PICL_NODE_OBP,
13827c478bd9Sstevel@tonic-gate 	    PICL_CLASS_PICL, &tmph);
13837c478bd9Sstevel@tonic-gate 
13847c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
13857c478bd9Sstevel@tonic-gate 		return (err);
13867c478bd9Sstevel@tonic-gate 	*obph = tmph;
13877c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
13887c478bd9Sstevel@tonic-gate }
13897c478bd9Sstevel@tonic-gate 
13907c478bd9Sstevel@tonic-gate /*
13917c478bd9Sstevel@tonic-gate  * This function creates the /platform node in the PICL tree and
13927c478bd9Sstevel@tonic-gate  * its properties. It sets the "platform-name" property to the
13937c478bd9Sstevel@tonic-gate  * platform name
13947c478bd9Sstevel@tonic-gate  */
13957c478bd9Sstevel@tonic-gate static int
13967c478bd9Sstevel@tonic-gate construct_picl_platform(picl_nodehdl_t rooth, di_node_t di_root,
13977c478bd9Sstevel@tonic-gate     picl_nodehdl_t *piclh)
13987c478bd9Sstevel@tonic-gate {
13997c478bd9Sstevel@tonic-gate 	int			err;
14007c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		plafh;
14017c478bd9Sstevel@tonic-gate 	char			*nodename;
14027c478bd9Sstevel@tonic-gate 	char			nodeclass[PICL_CLASSNAMELEN_MAX];
14037c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
14047c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
14057c478bd9Sstevel@tonic-gate 
14067c478bd9Sstevel@tonic-gate 	nodename = di_node_name(di_root);
14077c478bd9Sstevel@tonic-gate 	if (nodename == NULL)
14087c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
14097c478bd9Sstevel@tonic-gate 
14107c478bd9Sstevel@tonic-gate 	err = 0;
14117c478bd9Sstevel@tonic-gate 	if (di_nodeid(di_root) == DI_PROM_NODEID ||
14127c478bd9Sstevel@tonic-gate 	    di_nodeid(di_root) == DI_SID_NODEID)
14137c478bd9Sstevel@tonic-gate 		err = get_device_type(nodeclass, di_root);
14147c478bd9Sstevel@tonic-gate 
14157c478bd9Sstevel@tonic-gate 	if (err < 0)
14167c478bd9Sstevel@tonic-gate 		(void) strcpy(nodeclass, PICL_CLASS_UPA);	/* default */
14177c478bd9Sstevel@tonic-gate 
14187c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_node(rooth, PICL_NODE_PLATFORM,
14197c478bd9Sstevel@tonic-gate 	    nodeclass, &plafh);
14207c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
14217c478bd9Sstevel@tonic-gate 		return (err);
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
14247c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(nodename) + 1,
14257c478bd9Sstevel@tonic-gate 	    PICL_PROP_PLATFORM_NAME, NULL, NULL);
14267c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, nodename, &proph);
14277c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
14287c478bd9Sstevel@tonic-gate 		return (err);
14297c478bd9Sstevel@tonic-gate 
14307c478bd9Sstevel@tonic-gate 	(void) add_devinfo_props(plafh, di_root);
14317c478bd9Sstevel@tonic-gate 
14327c478bd9Sstevel@tonic-gate 	(void) add_openprom_props(plafh, di_root);
14337c478bd9Sstevel@tonic-gate 
14347c478bd9Sstevel@tonic-gate 	*piclh = plafh;
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
14377c478bd9Sstevel@tonic-gate }
14387c478bd9Sstevel@tonic-gate 
14397c478bd9Sstevel@tonic-gate /*
14407c478bd9Sstevel@tonic-gate  * This function creates a node in /obp tree for the libdevinfo handle.
14417c478bd9Sstevel@tonic-gate  */
14427c478bd9Sstevel@tonic-gate static int
14437c478bd9Sstevel@tonic-gate construct_obp_node(picl_nodehdl_t parh, di_node_t dn, picl_nodehdl_t *chdh)
14447c478bd9Sstevel@tonic-gate {
14457c478bd9Sstevel@tonic-gate 	int		err;
14467c478bd9Sstevel@tonic-gate 	char		*nodename;
14477c478bd9Sstevel@tonic-gate 	char		nodeclass[PICL_CLASSNAMELEN_MAX];
14487c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	anodeh;
14497c478bd9Sstevel@tonic-gate 
14507c478bd9Sstevel@tonic-gate 	nodename = di_node_name(dn);	/* PICL_PROP_NAME */
14517c478bd9Sstevel@tonic-gate 	if (nodename == NULL)
14527c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
14537c478bd9Sstevel@tonic-gate 
14547c478bd9Sstevel@tonic-gate 	if (strcmp(nodename, "pseudo") == 0)
14557c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
14567c478bd9Sstevel@tonic-gate 
14577c478bd9Sstevel@tonic-gate 	if ((di_nodeid(dn) == DI_PROM_NODEID) &&
14587c478bd9Sstevel@tonic-gate 	    (get_device_type(nodeclass, dn) == 0))
14597c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
14607c478bd9Sstevel@tonic-gate 
14617c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_node(parh, nodename, nodename, &anodeh);
14627c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
14637c478bd9Sstevel@tonic-gate 		return (err);
14647c478bd9Sstevel@tonic-gate 
14657c478bd9Sstevel@tonic-gate 	add_devinfo_props(anodeh, dn);
14667c478bd9Sstevel@tonic-gate 
14677c478bd9Sstevel@tonic-gate 	(void) add_openprom_props(anodeh, dn);
14687c478bd9Sstevel@tonic-gate 
14697c478bd9Sstevel@tonic-gate 	*chdh = anodeh;
14707c478bd9Sstevel@tonic-gate 
14717c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
14727c478bd9Sstevel@tonic-gate }
14737c478bd9Sstevel@tonic-gate 
14747c478bd9Sstevel@tonic-gate /*
14757c478bd9Sstevel@tonic-gate  * This function creates a PICL node in /platform tree for a device
14767c478bd9Sstevel@tonic-gate  */
14777c478bd9Sstevel@tonic-gate static int
14787c478bd9Sstevel@tonic-gate construct_devtype_node(picl_nodehdl_t parh, char *nodename,
14797c478bd9Sstevel@tonic-gate     char *nodeclass, di_node_t dn, picl_nodehdl_t *chdh)
14807c478bd9Sstevel@tonic-gate {
14817c478bd9Sstevel@tonic-gate 	int			err;
14827c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		anodeh;
14837c478bd9Sstevel@tonic-gate 
14847c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_node(parh, nodename, nodeclass, &anodeh);
14857c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
14867c478bd9Sstevel@tonic-gate 		return (err);
14877c478bd9Sstevel@tonic-gate 
14887c478bd9Sstevel@tonic-gate 	(void) add_devinfo_props(anodeh, dn);
14897c478bd9Sstevel@tonic-gate 	(void) add_openprom_props(anodeh, dn);
149043e66171SMichael Bergknoff 	construct_mpath_node(anodeh, dn);
14917c478bd9Sstevel@tonic-gate 
14927c478bd9Sstevel@tonic-gate 	*chdh = anodeh;
14937c478bd9Sstevel@tonic-gate 	return (err);
14947c478bd9Sstevel@tonic-gate }
14957c478bd9Sstevel@tonic-gate 
14967c478bd9Sstevel@tonic-gate /*
14977c478bd9Sstevel@tonic-gate  * Create a subtree of "picl" class nodes in /obp for these nodes
14987c478bd9Sstevel@tonic-gate  */
14997c478bd9Sstevel@tonic-gate static int
15007c478bd9Sstevel@tonic-gate construct_openprom_tree(picl_nodehdl_t nodeh, di_node_t  dinode)
15017c478bd9Sstevel@tonic-gate {
15027c478bd9Sstevel@tonic-gate 	di_node_t	cnode;
15037c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	chdh;
15047c478bd9Sstevel@tonic-gate 	int		err;
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	err = construct_obp_node(nodeh, dinode, &chdh);
15077c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
15087c478bd9Sstevel@tonic-gate 		return (err);
15097c478bd9Sstevel@tonic-gate 
15107c478bd9Sstevel@tonic-gate 	for (cnode = di_child_node(dinode); cnode != DI_NODE_NIL;
15117c478bd9Sstevel@tonic-gate 	    cnode = di_sibling_node(cnode))
15127c478bd9Sstevel@tonic-gate 		(void) construct_openprom_tree(chdh, cnode);
15137c478bd9Sstevel@tonic-gate 
15147c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
15157c478bd9Sstevel@tonic-gate 
15167c478bd9Sstevel@tonic-gate }
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate /*
15197c478bd9Sstevel@tonic-gate  * Process the libdevinfo device tree and create nodes in /platform or /obp
15207c478bd9Sstevel@tonic-gate  * PICL tree.
15217c478bd9Sstevel@tonic-gate  *
15227c478bd9Sstevel@tonic-gate  * This routine traverses the immediate children of "dinode" device and
15237c478bd9Sstevel@tonic-gate  * determines the node class for that child. If it finds a valid class
15247c478bd9Sstevel@tonic-gate  * name, then it builds a PICL node under /platform subtree and calls itself
15257c478bd9Sstevel@tonic-gate  * recursively to construct the subtree for that child node. Otherwise, if
15267c478bd9Sstevel@tonic-gate  * the parent_class is NULL, then it constructs a node and subtree under /obp
15277c478bd9Sstevel@tonic-gate  * subtree.
15287c478bd9Sstevel@tonic-gate  *
15297c478bd9Sstevel@tonic-gate  * Note that we skip the children nodes that don't have a valid class name
15307c478bd9Sstevel@tonic-gate  * and the parent_class is non NULL to prevent creation of any placeholder
15317c478bd9Sstevel@tonic-gate  * nodes (such as sd,...).
15327c478bd9Sstevel@tonic-gate  */
15337c478bd9Sstevel@tonic-gate static int
15347c478bd9Sstevel@tonic-gate construct_devinfo_tree(picl_nodehdl_t plafh, picl_nodehdl_t obph,
15357c478bd9Sstevel@tonic-gate     di_node_t dinode, char *parent_class)
15367c478bd9Sstevel@tonic-gate {
15377c478bd9Sstevel@tonic-gate 	di_node_t	cnode;
15387c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	chdh;
15397c478bd9Sstevel@tonic-gate 	char		nodeclass[PICL_CLASSNAMELEN_MAX];
15407c478bd9Sstevel@tonic-gate 	char		*nodename;
15417c478bd9Sstevel@tonic-gate 	int		err;
15427c478bd9Sstevel@tonic-gate 
15437c478bd9Sstevel@tonic-gate 	err = PICL_SUCCESS;
15447c478bd9Sstevel@tonic-gate 	for (cnode = di_child_node(dinode); cnode != DI_NODE_NIL;
15457c478bd9Sstevel@tonic-gate 	    cnode = di_sibling_node(cnode)) {
15467c478bd9Sstevel@tonic-gate 		nodename = di_node_name(cnode);	/* PICL_PROP_NAME */
15477c478bd9Sstevel@tonic-gate 		if (nodename == NULL)
15487c478bd9Sstevel@tonic-gate 			continue;
15497c478bd9Sstevel@tonic-gate 
15507c478bd9Sstevel@tonic-gate 		err = get_node_class(nodeclass, cnode, nodename);
15517c478bd9Sstevel@tonic-gate 
15527c478bd9Sstevel@tonic-gate 		if (err == 0) {
15537c478bd9Sstevel@tonic-gate 			err = construct_devtype_node(plafh, nodename,
15547c478bd9Sstevel@tonic-gate 			    nodeclass, cnode, &chdh);
15557c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
15567c478bd9Sstevel@tonic-gate 				return (err);
15577c478bd9Sstevel@tonic-gate 			err = construct_devinfo_tree(chdh, obph, cnode,
15587c478bd9Sstevel@tonic-gate 			    nodeclass);
15597c478bd9Sstevel@tonic-gate 		} else if (parent_class == NULL)
15607c478bd9Sstevel@tonic-gate 			err = construct_openprom_tree(obph, cnode);
15617c478bd9Sstevel@tonic-gate 		else
15627c478bd9Sstevel@tonic-gate 			continue;
15637c478bd9Sstevel@tonic-gate 		/*
15647c478bd9Sstevel@tonic-gate 		 * if parent_class is non NULL, skip the children nodes
15657c478bd9Sstevel@tonic-gate 		 * that don't have a valid device class - eliminates
15667c478bd9Sstevel@tonic-gate 		 * placeholder nodes (sd,...) from being created.
15677c478bd9Sstevel@tonic-gate 		 */
15687c478bd9Sstevel@tonic-gate 	}
15697c478bd9Sstevel@tonic-gate 
15707c478bd9Sstevel@tonic-gate 	return (err);
15717c478bd9Sstevel@tonic-gate 
15727c478bd9Sstevel@tonic-gate }
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate /*
15757c478bd9Sstevel@tonic-gate  * This function is called from the event handler called from the daemon
15767c478bd9Sstevel@tonic-gate  * on PICL events.
15777c478bd9Sstevel@tonic-gate  *
15787c478bd9Sstevel@tonic-gate  * This routine traverses the children of the "dinode" device and
15797c478bd9Sstevel@tonic-gate  * creates a PICL node for each child not found in the PICL tree and
15807c478bd9Sstevel@tonic-gate  * invokes itself recursively to create a subtree for the newly created
15817c478bd9Sstevel@tonic-gate  * child node. It also checks if the node being created is a meory
15827c478bd9Sstevel@tonic-gate  * controller. If so, it posts PICLEVENT_MC_ADDED PICL event to the PICL
15837c478bd9Sstevel@tonic-gate  * framework.
15847c478bd9Sstevel@tonic-gate  */
15857c478bd9Sstevel@tonic-gate static int
15867c478bd9Sstevel@tonic-gate update_subtree(picl_nodehdl_t nodeh, di_node_t dinode)
15877c478bd9Sstevel@tonic-gate {
15887c478bd9Sstevel@tonic-gate 	di_node_t	cnode;
15897c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	chdh;
15907c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	nh;
15917c478bd9Sstevel@tonic-gate 	char		*nodename;
15927c478bd9Sstevel@tonic-gate 	char		nodeclass[PICL_CLASSNAMELEN_MAX];
15937c478bd9Sstevel@tonic-gate 	char		*path_buf;
15947c478bd9Sstevel@tonic-gate 	char		buf[MAX_UNIT_ADDRESS_LEN];
15957c478bd9Sstevel@tonic-gate 	char		unitaddr[MAX_UNIT_ADDRESS_LEN];
15967c478bd9Sstevel@tonic-gate 	char		path_w_ua[MAXPATHLEN];
15977c478bd9Sstevel@tonic-gate 	char		path_wo_ua[MAXPATHLEN];
15987c478bd9Sstevel@tonic-gate 	char		*strp;
15997c478bd9Sstevel@tonic-gate 	int		gotit;
16007c478bd9Sstevel@tonic-gate 	int		err;
16017c478bd9Sstevel@tonic-gate 
16027c478bd9Sstevel@tonic-gate 	for (cnode = di_child_node(dinode); cnode != DI_NODE_NIL;
16037c478bd9Sstevel@tonic-gate 	    cnode = di_sibling_node(cnode)) {
16047c478bd9Sstevel@tonic-gate 		path_buf = di_devfs_path(cnode);
16057c478bd9Sstevel@tonic-gate 		if (path_buf == NULL)
16067c478bd9Sstevel@tonic-gate 			continue;
16077c478bd9Sstevel@tonic-gate 
16087c478bd9Sstevel@tonic-gate 		nodename = di_node_name(cnode);
16097c478bd9Sstevel@tonic-gate 		if (nodename == NULL) {
16107c478bd9Sstevel@tonic-gate 			di_devfs_path_free(path_buf);
16117c478bd9Sstevel@tonic-gate 			continue;
16127c478bd9Sstevel@tonic-gate 		}
16137c478bd9Sstevel@tonic-gate 
16147c478bd9Sstevel@tonic-gate 		err = get_node_class(nodeclass, cnode, nodename);
16157c478bd9Sstevel@tonic-gate 
16167c478bd9Sstevel@tonic-gate 		if (err < 0) {
16177c478bd9Sstevel@tonic-gate 			di_devfs_path_free(path_buf);
16187c478bd9Sstevel@tonic-gate 			continue;
16197c478bd9Sstevel@tonic-gate 		}
16207c478bd9Sstevel@tonic-gate 
16217c478bd9Sstevel@tonic-gate 		/*
16227c478bd9Sstevel@tonic-gate 		 * this is quite complicated - both path_buf and any nodes
16237c478bd9Sstevel@tonic-gate 		 * already in the picl tree may, or may not, have the
16247c478bd9Sstevel@tonic-gate 		 * @<unit_addr> at the end of their names. So we must
16257c478bd9Sstevel@tonic-gate 		 * take path_buf and work out what the device path would
16267c478bd9Sstevel@tonic-gate 		 * be both with and without the unit_address, then search
16277c478bd9Sstevel@tonic-gate 		 * the picl tree for both forms.
16287c478bd9Sstevel@tonic-gate 		 */
16297c478bd9Sstevel@tonic-gate 		if (((strp = strrchr(path_buf, '/')) != NULL) &&
16307c478bd9Sstevel@tonic-gate 		    strchr(strp, '@') == NULL) {
16317c478bd9Sstevel@tonic-gate 			/*
1632f4730842STrevor Thompson 			 * This is an unattached node - so the path is not
16337c478bd9Sstevel@tonic-gate 			 * unique. Need to find out which node it is.
1634f4730842STrevor Thompson 			 * Find the unit_address from the OBP or devinfo
1635f4730842STrevor Thompson 			 * properties.
16367c478bd9Sstevel@tonic-gate 			 */
16377c478bd9Sstevel@tonic-gate 			err = ptree_create_node(nodename, nodeclass, &chdh);
16387c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
16397c478bd9Sstevel@tonic-gate 				return (err);
1640f4730842STrevor Thompson 
1641f4730842STrevor Thompson 			(void) add_devinfo_props(chdh, cnode);
16427c478bd9Sstevel@tonic-gate 			(void) add_openprom_props(chdh, cnode);
1643f4730842STrevor Thompson 
16447c478bd9Sstevel@tonic-gate 			err = get_unitaddr(nodeh, chdh, unitaddr,
16457c478bd9Sstevel@tonic-gate 			    sizeof (unitaddr));
16467c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
16477c478bd9Sstevel@tonic-gate 				return (err);
16487c478bd9Sstevel@tonic-gate 			(void) ptree_destroy_node(chdh);
16497c478bd9Sstevel@tonic-gate 			(void) snprintf(path_w_ua, sizeof (path_w_ua), "%s@%s",
16507c478bd9Sstevel@tonic-gate 			    path_buf, unitaddr);
16517c478bd9Sstevel@tonic-gate 			(void) snprintf(path_wo_ua, sizeof (path_wo_ua), "%s",
16527c478bd9Sstevel@tonic-gate 			    path_buf);
16537c478bd9Sstevel@tonic-gate 		} else {
16547c478bd9Sstevel@tonic-gate 			/*
16557c478bd9Sstevel@tonic-gate 			 * this is an attached node - so the path is unique
16567c478bd9Sstevel@tonic-gate 			 */
16577c478bd9Sstevel@tonic-gate 			(void) snprintf(path_w_ua, sizeof (path_w_ua), "%s",
16587c478bd9Sstevel@tonic-gate 			    path_buf);
16597c478bd9Sstevel@tonic-gate 			(void) snprintf(path_wo_ua, sizeof (path_wo_ua), "%s",
16607c478bd9Sstevel@tonic-gate 			    path_buf);
16617c478bd9Sstevel@tonic-gate 			strp = strrchr(path_wo_ua, '@');
16627c478bd9Sstevel@tonic-gate 			*strp++ = '\0';
16637c478bd9Sstevel@tonic-gate 			(void) snprintf(unitaddr, sizeof (unitaddr), "%s",
16647c478bd9Sstevel@tonic-gate 			    strp);
16657c478bd9Sstevel@tonic-gate 		}
16667c478bd9Sstevel@tonic-gate 		/*
16677c478bd9Sstevel@tonic-gate 		 * first look for node with unit address in devfs_path
16687c478bd9Sstevel@tonic-gate 		 */
16697c478bd9Sstevel@tonic-gate 		if (ptree_find_node(nodeh, PICL_PROP_DEVFS_PATH,
16707c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_CHARSTRING, path_w_ua, strlen(path_w_ua) + 1,
16717c478bd9Sstevel@tonic-gate 		    &nh) == PICL_SUCCESS) {
16727c478bd9Sstevel@tonic-gate 			/*
16737c478bd9Sstevel@tonic-gate 			 * node already there - there's nothing we need to do
16747c478bd9Sstevel@tonic-gate 			 */
16757c478bd9Sstevel@tonic-gate 			if (picldevtree_debug > 1)
16767c478bd9Sstevel@tonic-gate 				syslog(LOG_INFO,
16777c478bd9Sstevel@tonic-gate 				    "update_subtree: path:%s node exists\n",
16787c478bd9Sstevel@tonic-gate 				    path_buf);
16797c478bd9Sstevel@tonic-gate 			di_devfs_path_free(path_buf);
16807c478bd9Sstevel@tonic-gate 			continue;
16817c478bd9Sstevel@tonic-gate 		}
16827c478bd9Sstevel@tonic-gate 		/*
16837c478bd9Sstevel@tonic-gate 		 * now look for node without unit address in devfs_path.
16847c478bd9Sstevel@tonic-gate 		 * This might be just one out of several
16857c478bd9Sstevel@tonic-gate 		 * nodes - need to check all siblings
16867c478bd9Sstevel@tonic-gate 		 */
16877c478bd9Sstevel@tonic-gate 		err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD,
16887c478bd9Sstevel@tonic-gate 		    &chdh, sizeof (chdh));
16897c478bd9Sstevel@tonic-gate 		if ((err != PICL_SUCCESS) && (err != PICL_PROPNOTFOUND))
16907c478bd9Sstevel@tonic-gate 			return (err);
16917c478bd9Sstevel@tonic-gate 		gotit = 0;
16927c478bd9Sstevel@tonic-gate 		while (err == PICL_SUCCESS) {
16937c478bd9Sstevel@tonic-gate 			err = ptree_get_propval_by_name(chdh,
16947c478bd9Sstevel@tonic-gate 			    PICL_PROP_DEVFS_PATH, buf, sizeof (buf));
16957c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
16967c478bd9Sstevel@tonic-gate 				return (err);
16977c478bd9Sstevel@tonic-gate 			if (strcmp(buf, path_wo_ua) == 0) {
16987c478bd9Sstevel@tonic-gate 				err = ptree_get_propval_by_name(chdh,
16997c478bd9Sstevel@tonic-gate 				    PICL_PROP_UNIT_ADDRESS, buf, sizeof (buf));
17007c478bd9Sstevel@tonic-gate 				if (err != PICL_SUCCESS)
17017c478bd9Sstevel@tonic-gate 					return (err);
17027c478bd9Sstevel@tonic-gate 				if (strcmp(buf, unitaddr) == 0) {
17037c478bd9Sstevel@tonic-gate 					gotit = 1;
17047c478bd9Sstevel@tonic-gate 					break;
17057c478bd9Sstevel@tonic-gate 				}
17067c478bd9Sstevel@tonic-gate 			}
17077c478bd9Sstevel@tonic-gate 			err = ptree_get_propval_by_name(chdh,
17087c478bd9Sstevel@tonic-gate 			    PICL_PROP_PEER, &chdh, sizeof (chdh));
17097c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
17107c478bd9Sstevel@tonic-gate 				break;
17117c478bd9Sstevel@tonic-gate 		}
17127c478bd9Sstevel@tonic-gate 		if (gotit) {
17137c478bd9Sstevel@tonic-gate 			/*
17147c478bd9Sstevel@tonic-gate 			 * node already there - there's nothing we need to do
17157c478bd9Sstevel@tonic-gate 			 */
17167c478bd9Sstevel@tonic-gate 			if (picldevtree_debug > 1)
17177c478bd9Sstevel@tonic-gate 				syslog(LOG_INFO,
17187c478bd9Sstevel@tonic-gate 				    "update_subtree: path:%s node exists\n",
17197c478bd9Sstevel@tonic-gate 				    path_buf);
17207c478bd9Sstevel@tonic-gate 			di_devfs_path_free(path_buf);
17217c478bd9Sstevel@tonic-gate 			continue;
17227c478bd9Sstevel@tonic-gate 		}
17237c478bd9Sstevel@tonic-gate 
17247c478bd9Sstevel@tonic-gate #define	IS_MC(x)	(strcmp(x, PICL_CLASS_MEMORY_CONTROLLER) == 0 ? 1 : 0)
17257c478bd9Sstevel@tonic-gate 
17267c478bd9Sstevel@tonic-gate 		if (construct_devtype_node(nodeh, nodename, nodeclass, cnode,
17277c478bd9Sstevel@tonic-gate 		    &chdh) == PICL_SUCCESS) {
17287c478bd9Sstevel@tonic-gate 			if (picldevtree_debug)
17297c478bd9Sstevel@tonic-gate 				syslog(LOG_INFO,
17307c478bd9Sstevel@tonic-gate 				    "picldevtree: added node:%s path:%s\n",
17317c478bd9Sstevel@tonic-gate 				    nodename, path_buf);
17327c478bd9Sstevel@tonic-gate 			if (IS_MC(nodeclass)) {
17337c478bd9Sstevel@tonic-gate 				if (post_mc_event(PICLEVENT_MC_ADDED, chdh) !=
17347c478bd9Sstevel@tonic-gate 				    PICL_SUCCESS)
17357c478bd9Sstevel@tonic-gate 					syslog(LOG_WARNING, PICL_EVENT_DROPPED,
17367c478bd9Sstevel@tonic-gate 					    PICLEVENT_MC_ADDED);
17377c478bd9Sstevel@tonic-gate 			}
17387c478bd9Sstevel@tonic-gate 
17397c478bd9Sstevel@tonic-gate 			di_devfs_path_free(path_buf);
17407c478bd9Sstevel@tonic-gate 			(void) update_subtree(chdh, cnode);
17417c478bd9Sstevel@tonic-gate 		}
17427c478bd9Sstevel@tonic-gate 	}
17437c478bd9Sstevel@tonic-gate 
17447c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
17457c478bd9Sstevel@tonic-gate 
17467c478bd9Sstevel@tonic-gate }
17477c478bd9Sstevel@tonic-gate 
1748bdee4892SMichael Bergknoff /*
1749bdee4892SMichael Bergknoff  * Check for a stale OBP node. EINVAL is returned from the openprom(7D) driver
1750bdee4892SMichael Bergknoff  * if the nodeid stored in the snapshot is not valid.
1751bdee4892SMichael Bergknoff  */
1752bdee4892SMichael Bergknoff static int
1753bdee4892SMichael Bergknoff check_stale_node(di_node_t node, void *arg)
1754bdee4892SMichael Bergknoff {
1755bdee4892SMichael Bergknoff 	di_prom_prop_t	promp;
1756bdee4892SMichael Bergknoff 
1757bdee4892SMichael Bergknoff 	errno = 0;
1758bdee4892SMichael Bergknoff 	promp = di_prom_prop_next(ph, node, DI_PROM_PROP_NIL);
1759bdee4892SMichael Bergknoff 	if (promp == DI_PROM_PROP_NIL && errno == EINVAL) {
1760bdee4892SMichael Bergknoff 		snapshot_stale = 1;
1761bdee4892SMichael Bergknoff 		return (DI_WALK_TERMINATE);
1762bdee4892SMichael Bergknoff 	}
1763bdee4892SMichael Bergknoff 	return (DI_WALK_CONTINUE);
1764bdee4892SMichael Bergknoff }
1765bdee4892SMichael Bergknoff 
1766bdee4892SMichael Bergknoff /*
1767bdee4892SMichael Bergknoff  * Walk the snapshot and check the OBP properties of each node.
1768bdee4892SMichael Bergknoff  */
1769bdee4892SMichael Bergknoff static int
1770bdee4892SMichael Bergknoff is_snapshot_stale(di_node_t root)
1771bdee4892SMichael Bergknoff {
1772bdee4892SMichael Bergknoff 	snapshot_stale = 0;
1773bdee4892SMichael Bergknoff 	di_walk_node(root, DI_WALK_CLDFIRST, NULL, check_stale_node);
1774bdee4892SMichael Bergknoff 	return (snapshot_stale);
1775bdee4892SMichael Bergknoff }
1776bdee4892SMichael Bergknoff 
17777c478bd9Sstevel@tonic-gate /*
17787c478bd9Sstevel@tonic-gate  * This function processes the data from libdevinfo and creates nodes
17797c478bd9Sstevel@tonic-gate  * in the PICL tree.
17807c478bd9Sstevel@tonic-gate  */
17817c478bd9Sstevel@tonic-gate static int
17827c478bd9Sstevel@tonic-gate libdevinfo_init(picl_nodehdl_t rooth)
17837c478bd9Sstevel@tonic-gate {
17847c478bd9Sstevel@tonic-gate 	di_node_t	di_root;
17857c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	plafh;
17867c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	obph;
17877c478bd9Sstevel@tonic-gate 	int		err;
17887c478bd9Sstevel@tonic-gate 
1789ad159281Sarutz 	/*
1790ad159281Sarutz 	 * Use DINFOCACHE so that we obtain all attributes for all
1791ad159281Sarutz 	 * device instances (without necessarily doing a load/attach
1792ad159281Sarutz 	 * of all drivers).  Once the (on-disk) cache file is built, it
1793ad159281Sarutz 	 * exists over a reboot and can be read into memory at a very
1794ad159281Sarutz 	 * low cost.
1795ad159281Sarutz 	 */
1796ad159281Sarutz 	if ((di_root = di_init("/", DINFOCACHE)) == DI_NODE_NIL)
17977c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
17987c478bd9Sstevel@tonic-gate 
17997c478bd9Sstevel@tonic-gate 	if ((ph = di_prom_init()) == NULL)
18007c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
1801bdee4892SMichael Bergknoff 
1802bdee4892SMichael Bergknoff 	/*
1803bdee4892SMichael Bergknoff 	 * Check if the snapshot cache contains stale OBP nodeid references.
1804bdee4892SMichael Bergknoff 	 * If it does release the snapshot and obtain a live snapshot from the
1805bdee4892SMichael Bergknoff 	 * kernel.
1806bdee4892SMichael Bergknoff 	 */
1807bdee4892SMichael Bergknoff 	if (is_snapshot_stale(di_root)) {
1808bdee4892SMichael Bergknoff 		syslog(LOG_INFO, "picld detected stale snapshot cache");
1809bdee4892SMichael Bergknoff 		di_fini(di_root);
1810bdee4892SMichael Bergknoff 		if ((di_root = di_init("/", DINFOCPYALL | DINFOFORCE)) ==
1811bdee4892SMichael Bergknoff 		    DI_NODE_NIL) {
1812bdee4892SMichael Bergknoff 			return (PICL_FAILURE);
1813bdee4892SMichael Bergknoff 		}
1814bdee4892SMichael Bergknoff 	}
1815bdee4892SMichael Bergknoff 
18167c478bd9Sstevel@tonic-gate 	/*
18177c478bd9Sstevel@tonic-gate 	 * create platform PICL node using di_root node
18187c478bd9Sstevel@tonic-gate 	 */
18197c478bd9Sstevel@tonic-gate 	err = construct_picl_platform(rooth, di_root, &plafh);
18207c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS) {
18217c478bd9Sstevel@tonic-gate 		di_fini(di_root);
18227c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
18237c478bd9Sstevel@tonic-gate 	}
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate 	err = construct_picl_openprom(rooth, &obph);
18267c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS) {
18277c478bd9Sstevel@tonic-gate 		di_fini(di_root);
18287c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
18297c478bd9Sstevel@tonic-gate 	}
18307c478bd9Sstevel@tonic-gate 
18317c478bd9Sstevel@tonic-gate 	(void) construct_devinfo_tree(plafh, obph, di_root, NULL);
18327c478bd9Sstevel@tonic-gate 	if (ph) {
18337c478bd9Sstevel@tonic-gate 		di_prom_fini(ph);
18347c478bd9Sstevel@tonic-gate 		ph = NULL;
18357c478bd9Sstevel@tonic-gate 	}
18367c478bd9Sstevel@tonic-gate 	di_fini(di_root);
18377c478bd9Sstevel@tonic-gate 	return (err);
18387c478bd9Sstevel@tonic-gate }
18397c478bd9Sstevel@tonic-gate 
18407c478bd9Sstevel@tonic-gate /*
18417c478bd9Sstevel@tonic-gate  * This function returns the integer property value
18427c478bd9Sstevel@tonic-gate  */
18437c478bd9Sstevel@tonic-gate static int
18447c478bd9Sstevel@tonic-gate get_int_propval_by_name(picl_nodehdl_t	nodeh, char *pname, int *ival)
18457c478bd9Sstevel@tonic-gate {
18467c478bd9Sstevel@tonic-gate 	int	err;
18477c478bd9Sstevel@tonic-gate 
18487c478bd9Sstevel@tonic-gate 	err = ptree_get_propval_by_name(nodeh, pname, ival,
18497c478bd9Sstevel@tonic-gate 	    sizeof (int));
18507c478bd9Sstevel@tonic-gate 
18517c478bd9Sstevel@tonic-gate 	return (err);
18527c478bd9Sstevel@tonic-gate }
18537c478bd9Sstevel@tonic-gate 
18547c478bd9Sstevel@tonic-gate /*
18557c478bd9Sstevel@tonic-gate  * This function returns the port ID (or CPU ID in the case of CMP cores)
18567c478bd9Sstevel@tonic-gate  * of the specific CPU node handle.  If upa_portid exists, return its value.
18577c478bd9Sstevel@tonic-gate  * Otherwise, return portid/cpuid.
18587c478bd9Sstevel@tonic-gate  */
18597c478bd9Sstevel@tonic-gate static int
18607c478bd9Sstevel@tonic-gate get_cpu_portid(picl_nodehdl_t modh, int *id)
18617c478bd9Sstevel@tonic-gate {
18627c478bd9Sstevel@tonic-gate 	int	err;
18637c478bd9Sstevel@tonic-gate 
18645e3e415aSfw 	if (strcmp(mach_name, "sun4u") == 0 ||
18655e3e415aSfw 	    strcmp(mach_name, "sun4v") == 0) {
18667c478bd9Sstevel@tonic-gate 		err = get_int_propval_by_name(modh, OBP_PROP_UPA_PORTID, id);
18677c478bd9Sstevel@tonic-gate 		if (err == PICL_SUCCESS)
18687c478bd9Sstevel@tonic-gate 			return (err);
18697c478bd9Sstevel@tonic-gate 		err = get_int_propval_by_name(modh, OBP_PROP_PORTID, id);
18707c478bd9Sstevel@tonic-gate 		if (err == PICL_SUCCESS)
18717c478bd9Sstevel@tonic-gate 			return (err);
18727c478bd9Sstevel@tonic-gate 		return (get_int_propval_by_name(modh, OBP_PROP_CPUID, id));
18737c478bd9Sstevel@tonic-gate 	}
18747c478bd9Sstevel@tonic-gate 	if (strcmp(mach_name, "i86pc") == 0)
187548556476SJustin Frank 		return (get_int_propval_by_name(modh, OBP_REG, id));
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate 	return (PICL_FAILURE);
18787c478bd9Sstevel@tonic-gate }
18797c478bd9Sstevel@tonic-gate 
18807c478bd9Sstevel@tonic-gate /*
18817c478bd9Sstevel@tonic-gate  * This function is the volatile read access function of CPU state
18827c478bd9Sstevel@tonic-gate  * property
18837c478bd9Sstevel@tonic-gate  */
18847c478bd9Sstevel@tonic-gate static int
18857c478bd9Sstevel@tonic-gate get_pi_state(ptree_rarg_t *rarg, void *vbuf)
18867c478bd9Sstevel@tonic-gate {
18877c478bd9Sstevel@tonic-gate 	int	id;
18887c478bd9Sstevel@tonic-gate 	int	err;
18897c478bd9Sstevel@tonic-gate 
18907c478bd9Sstevel@tonic-gate 	err = get_int_propval_by_name(rarg->nodeh, PICL_PROP_ID, &id);
18917c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
18927c478bd9Sstevel@tonic-gate 		return (err);
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 	switch (p_online(id, P_STATUS)) {
18957c478bd9Sstevel@tonic-gate 	case P_ONLINE:
18967c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_ONLINE, MAX_STATE_SIZE);
18977c478bd9Sstevel@tonic-gate 		break;
18987c478bd9Sstevel@tonic-gate 	case P_OFFLINE:
18997c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_OFFLINE, MAX_STATE_SIZE);
19007c478bd9Sstevel@tonic-gate 		break;
19017c478bd9Sstevel@tonic-gate 	case P_NOINTR:
19027c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_NOINTR, MAX_STATE_SIZE);
19037c478bd9Sstevel@tonic-gate 		break;
19047c478bd9Sstevel@tonic-gate 	case P_SPARE:
19057c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_SPARE, MAX_STATE_SIZE);
19067c478bd9Sstevel@tonic-gate 		break;
19077c478bd9Sstevel@tonic-gate 	case P_FAULTED:
19087c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_FAULTED, MAX_STATE_SIZE);
19097c478bd9Sstevel@tonic-gate 		break;
19107c478bd9Sstevel@tonic-gate 	case P_POWEROFF:
19117c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, PS_POWEROFF, MAX_STATE_SIZE);
19127c478bd9Sstevel@tonic-gate 		break;
19137c478bd9Sstevel@tonic-gate 	default:
19147c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, "unknown", MAX_STATE_SIZE);
19157c478bd9Sstevel@tonic-gate 		break;
19167c478bd9Sstevel@tonic-gate 	}
19177c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
19187c478bd9Sstevel@tonic-gate }
19197c478bd9Sstevel@tonic-gate 
19207c478bd9Sstevel@tonic-gate /*
19217c478bd9Sstevel@tonic-gate  * This function is the volatile read access function of CPU processor_type
19227c478bd9Sstevel@tonic-gate  * property
19237c478bd9Sstevel@tonic-gate  */
19247c478bd9Sstevel@tonic-gate static int
19257c478bd9Sstevel@tonic-gate get_processor_type(ptree_rarg_t *rarg, void *vbuf)
19267c478bd9Sstevel@tonic-gate {
19277c478bd9Sstevel@tonic-gate 	processor_info_t	cpu_info;
19287c478bd9Sstevel@tonic-gate 	int	id;
19297c478bd9Sstevel@tonic-gate 	int	err;
19307c478bd9Sstevel@tonic-gate 
19317c478bd9Sstevel@tonic-gate 	err = get_int_propval_by_name(rarg->nodeh, PICL_PROP_ID, &id);
19327c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
19337c478bd9Sstevel@tonic-gate 		return (err);
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	if (processor_info(id, &cpu_info) >= 0) {
19367c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, cpu_info.pi_processor_type, PI_TYPELEN);
19377c478bd9Sstevel@tonic-gate 	}
19387c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
19397c478bd9Sstevel@tonic-gate }
19407c478bd9Sstevel@tonic-gate 
19417c478bd9Sstevel@tonic-gate /*
19427c478bd9Sstevel@tonic-gate  * This function is the volatile read access function of CPU fputypes
19437c478bd9Sstevel@tonic-gate  * property
19447c478bd9Sstevel@tonic-gate  */
19457c478bd9Sstevel@tonic-gate static int
19467c478bd9Sstevel@tonic-gate get_fputypes(ptree_rarg_t *rarg, void *vbuf)
19477c478bd9Sstevel@tonic-gate {
19487c478bd9Sstevel@tonic-gate 	processor_info_t	cpu_info;
19497c478bd9Sstevel@tonic-gate 	int	id;
19507c478bd9Sstevel@tonic-gate 	int	err;
19517c478bd9Sstevel@tonic-gate 
19527c478bd9Sstevel@tonic-gate 	err = get_int_propval_by_name(rarg->nodeh, PICL_PROP_ID, &id);
19537c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
19547c478bd9Sstevel@tonic-gate 		return (err);
19557c478bd9Sstevel@tonic-gate 
19567c478bd9Sstevel@tonic-gate 	if (processor_info(id, &cpu_info) >= 0) {
19577c478bd9Sstevel@tonic-gate 		(void) strlcpy(vbuf, cpu_info.pi_fputypes, PI_FPUTYPE);
19587c478bd9Sstevel@tonic-gate 	}
19597c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
19607c478bd9Sstevel@tonic-gate }
19617c478bd9Sstevel@tonic-gate 
19627c478bd9Sstevel@tonic-gate /*
19637c478bd9Sstevel@tonic-gate  * This function is the volatile read access function of CPU StateBegin
19647c478bd9Sstevel@tonic-gate  * property. To minimize overhead, use kstat_chain_update() to refresh
19657c478bd9Sstevel@tonic-gate  * the kstat header info as opposed to invoking kstat_open() every time.
19667c478bd9Sstevel@tonic-gate  */
19677c478bd9Sstevel@tonic-gate static int
19687c478bd9Sstevel@tonic-gate get_pi_state_begin(ptree_rarg_t *rarg, void *vbuf)
19697c478bd9Sstevel@tonic-gate {
19707c478bd9Sstevel@tonic-gate 	int 			err;
19717c478bd9Sstevel@tonic-gate 	int			cpu_id;
19727c478bd9Sstevel@tonic-gate 	static kstat_ctl_t	*kc = NULL;
19737c478bd9Sstevel@tonic-gate 	static pthread_mutex_t	kc_mutex = PTHREAD_MUTEX_INITIALIZER;
19747c478bd9Sstevel@tonic-gate 	kstat_t			*kp;
19757c478bd9Sstevel@tonic-gate 	kstat_named_t		*kn;
19767c478bd9Sstevel@tonic-gate 
19777c478bd9Sstevel@tonic-gate 	err = get_int_propval_by_name(rarg->nodeh, PICL_PROP_ID, &cpu_id);
19787c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
19797c478bd9Sstevel@tonic-gate 		return (err);
19807c478bd9Sstevel@tonic-gate 
19817c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&kc_mutex);
19827c478bd9Sstevel@tonic-gate 	if (kc == NULL)
19837c478bd9Sstevel@tonic-gate 		kc = kstat_open();
19847c478bd9Sstevel@tonic-gate 	else if (kstat_chain_update(kc) == -1) {
19857c478bd9Sstevel@tonic-gate 		(void) kstat_close(kc);
19867c478bd9Sstevel@tonic-gate 		kc = kstat_open();
19877c478bd9Sstevel@tonic-gate 	}
19887c478bd9Sstevel@tonic-gate 
19897c478bd9Sstevel@tonic-gate 	if (kc == NULL) {
19907c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&kc_mutex);
19917c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
19927c478bd9Sstevel@tonic-gate 	}
19937c478bd9Sstevel@tonic-gate 
19947c478bd9Sstevel@tonic-gate 	/* Get the state_begin from kstat */
19957c478bd9Sstevel@tonic-gate 	if ((kp = kstat_lookup(kc, KSTAT_CPU_INFO, cpu_id, NULL)) == NULL ||
19967c478bd9Sstevel@tonic-gate 	    kp->ks_type != KSTAT_TYPE_NAMED || kstat_read(kc, kp, 0) < 0) {
19977c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&kc_mutex);
19987c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
19997c478bd9Sstevel@tonic-gate 	}
20007c478bd9Sstevel@tonic-gate 
20017c478bd9Sstevel@tonic-gate 	kn = kstat_data_lookup(kp, KSTAT_STATE_BEGIN);
20027c478bd9Sstevel@tonic-gate 	if (kn) {
20037c478bd9Sstevel@tonic-gate 		*(uint64_t *)vbuf = (uint64_t)kn->value.l;
20047c478bd9Sstevel@tonic-gate 		err = PICL_SUCCESS;
20057c478bd9Sstevel@tonic-gate 	} else
20067c478bd9Sstevel@tonic-gate 		err = PICL_FAILURE;
20077c478bd9Sstevel@tonic-gate 
20087c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&kc_mutex);
20097c478bd9Sstevel@tonic-gate 	return (err);
20107c478bd9Sstevel@tonic-gate }
20117c478bd9Sstevel@tonic-gate 
20127c478bd9Sstevel@tonic-gate /*
20137c478bd9Sstevel@tonic-gate  * This function adds CPU information to the CPU nodes
20147c478bd9Sstevel@tonic-gate  */
20157c478bd9Sstevel@tonic-gate /* ARGSUSED */
20167c478bd9Sstevel@tonic-gate static int
20177c478bd9Sstevel@tonic-gate add_processor_info(picl_nodehdl_t cpuh, void *args)
20187c478bd9Sstevel@tonic-gate {
20197c478bd9Sstevel@tonic-gate 	int 			err;
20207c478bd9Sstevel@tonic-gate 	int			cpu_id;
20217c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
20227c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
20237c478bd9Sstevel@tonic-gate 
20247c478bd9Sstevel@tonic-gate 	err = get_cpu_portid(cpuh, &cpu_id);
20257c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
20267c478bd9Sstevel@tonic-gate 		return (PICL_WALK_CONTINUE);
2027f4730842STrevor Thompson 
2028f4730842STrevor Thompson 	/*
2029f4730842STrevor Thompson 	 * Check to make sure that the CPU is still present, i.e. that it
2030f4730842STrevor Thompson 	 * has not been DR'ed out of the system.
2031f4730842STrevor Thompson 	 */
2032f4730842STrevor Thompson 	if (p_online(cpu_id, P_STATUS) == -1) {
2033f4730842STrevor Thompson 		if (picldevtree_debug)
2034f4730842STrevor Thompson 			syslog(LOG_INFO,
2035f4730842STrevor Thompson 			    "picldevtree: cpu %d (%llx) does not exist - "
2036f4730842STrevor Thompson 			    "deleting node\n", cpu_id, cpuh);
2037f4730842STrevor Thompson 
2038f4730842STrevor Thompson 		if (ptree_delete_node(cpuh) == PICL_SUCCESS)
2039f4730842STrevor Thompson 			(void) ptree_destroy_node(cpuh);
2040f4730842STrevor Thompson 
2041f4730842STrevor Thompson 		return (PICL_WALK_CONTINUE);
2042f4730842STrevor Thompson 	}
2043f4730842STrevor Thompson 
20447c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
20457c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_INT, PICL_READ, sizeof (int), PICL_PROP_ID, NULL, NULL);
20467c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(cpuh, &propinfo, &cpu_id, NULL);
20477c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
20487c478bd9Sstevel@tonic-gate 		return (PICL_WALK_CONTINUE);
20497c478bd9Sstevel@tonic-gate 
20507c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
20517c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, (PICL_READ|PICL_VOLATILE), MAX_STATE_SIZE,
20527c478bd9Sstevel@tonic-gate 	    PICL_PROP_STATE, get_pi_state, NULL);
20537c478bd9Sstevel@tonic-gate 	(void) ptree_create_and_add_prop(cpuh, &pinfo, NULL, NULL);
20547c478bd9Sstevel@tonic-gate 
20557c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
20567c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, (PICL_READ|PICL_VOLATILE), PI_TYPELEN,
20577c478bd9Sstevel@tonic-gate 	    PICL_PROP_PROCESSOR_TYPE, get_processor_type, NULL);
20587c478bd9Sstevel@tonic-gate 	(void) ptree_create_and_add_prop(cpuh, &pinfo, NULL, NULL);
20597c478bd9Sstevel@tonic-gate 
20607c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
20617c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, (PICL_READ|PICL_VOLATILE), PI_FPUTYPE,
20627c478bd9Sstevel@tonic-gate 	    PICL_PROP_FPUTYPE, get_fputypes, NULL);
20637c478bd9Sstevel@tonic-gate 	(void) ptree_create_and_add_prop(cpuh, &pinfo, NULL, NULL);
20647c478bd9Sstevel@tonic-gate 
20657c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
20667c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_TIMESTAMP, PICL_READ|PICL_VOLATILE, sizeof (uint64_t),
20677c478bd9Sstevel@tonic-gate 	    PICL_PROP_STATE_BEGIN, get_pi_state_begin, NULL);
20687c478bd9Sstevel@tonic-gate 	(void) ptree_create_and_add_prop(cpuh, &pinfo, NULL, NULL);
20697c478bd9Sstevel@tonic-gate 
20707c478bd9Sstevel@tonic-gate 	return (PICL_WALK_CONTINUE);
20717c478bd9Sstevel@tonic-gate }
20727c478bd9Sstevel@tonic-gate 
20737c478bd9Sstevel@tonic-gate /*
20747c478bd9Sstevel@tonic-gate  * This function sets up the "ID" property in every CPU nodes
20757c478bd9Sstevel@tonic-gate  * and adds processor info
20767c478bd9Sstevel@tonic-gate  */
20777c478bd9Sstevel@tonic-gate static int
20787c478bd9Sstevel@tonic-gate setup_cpus(picl_nodehdl_t plafh)
20797c478bd9Sstevel@tonic-gate {
20807c478bd9Sstevel@tonic-gate 	int 			err;
20817c478bd9Sstevel@tonic-gate 
20827c478bd9Sstevel@tonic-gate 	err = ptree_walk_tree_by_class(plafh, PICL_CLASS_CPU, NULL,
20837c478bd9Sstevel@tonic-gate 	    add_processor_info);
20847c478bd9Sstevel@tonic-gate 
20857c478bd9Sstevel@tonic-gate 	return (err);
20867c478bd9Sstevel@tonic-gate }
20877c478bd9Sstevel@tonic-gate 
20887c478bd9Sstevel@tonic-gate /*
20897c478bd9Sstevel@tonic-gate  * This function format's the manufacture's information for FFB display
20907c478bd9Sstevel@tonic-gate  * devices
20917c478bd9Sstevel@tonic-gate  */
20927c478bd9Sstevel@tonic-gate static void
20937c478bd9Sstevel@tonic-gate fmt_manf_id(manuf_t manufid, int bufsz, char *outbuf)
20947c478bd9Sstevel@tonic-gate {
20957c478bd9Sstevel@tonic-gate 	/*
20967c478bd9Sstevel@tonic-gate 	 * Format the manufacturer's info.  Note a small inconsistency we
20977c478bd9Sstevel@tonic-gate 	 * have to work around - Brooktree has it's part number in decimal,
20987c478bd9Sstevel@tonic-gate 	 * while Mitsubishi has it's part number in hex.
20997c478bd9Sstevel@tonic-gate 	 */
21007c478bd9Sstevel@tonic-gate 	switch (manufid.fld.manf) {
21017c478bd9Sstevel@tonic-gate 	case MANF_BROOKTREE:
21027c478bd9Sstevel@tonic-gate 		(void) snprintf(outbuf, bufsz, "%s %d, version %d",
21037c478bd9Sstevel@tonic-gate 		    "Brooktree", manufid.fld.partno, manufid.fld.version);
21047c478bd9Sstevel@tonic-gate 		break;
21057c478bd9Sstevel@tonic-gate 
21067c478bd9Sstevel@tonic-gate 	case MANF_MITSUBISHI:
21077c478bd9Sstevel@tonic-gate 		(void) snprintf(outbuf, bufsz, "%s %x, version %d",
21087c478bd9Sstevel@tonic-gate 		    "Mitsubishi", manufid.fld.partno, manufid.fld.version);
21097c478bd9Sstevel@tonic-gate 		break;
21107c478bd9Sstevel@tonic-gate 
21117c478bd9Sstevel@tonic-gate 	default:
21127c478bd9Sstevel@tonic-gate 		(void) snprintf(outbuf, bufsz,
21137c478bd9Sstevel@tonic-gate 		    "JED code %d, Part num 0x%x, version %d",
21147c478bd9Sstevel@tonic-gate 		    manufid.fld.manf, manufid.fld.partno, manufid.fld.version);
21157c478bd9Sstevel@tonic-gate 	}
21167c478bd9Sstevel@tonic-gate }
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate /*
21197c478bd9Sstevel@tonic-gate  * If it's an ffb device, open ffb devices and return PICL_SUCCESS
21207c478bd9Sstevel@tonic-gate  */
21217c478bd9Sstevel@tonic-gate static int
21227c478bd9Sstevel@tonic-gate open_ffb_device(picl_nodehdl_t ffbh, int *fd)
21237c478bd9Sstevel@tonic-gate {
21247c478bd9Sstevel@tonic-gate 	DIR 			*dirp;
21257c478bd9Sstevel@tonic-gate 	char 			devfs_path[PATH_MAX];
21267c478bd9Sstevel@tonic-gate 	char 			dev_path[PATH_MAX];
21277c478bd9Sstevel@tonic-gate 	char 			*devp;
21287c478bd9Sstevel@tonic-gate 	struct dirent 		*direntp;
21297c478bd9Sstevel@tonic-gate 	int			err;
21307c478bd9Sstevel@tonic-gate 	int			tmpfd;
21317c478bd9Sstevel@tonic-gate 
21327c478bd9Sstevel@tonic-gate 	/* Get the devfs_path of the ffb devices */
21337c478bd9Sstevel@tonic-gate 	err = ptree_get_propval_by_name(ffbh, PICL_PROP_DEVFS_PATH, devfs_path,
21347c478bd9Sstevel@tonic-gate 	    sizeof (devfs_path));
21357c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
21367c478bd9Sstevel@tonic-gate 		return (err);
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate 	/* Get the device node name */
21397c478bd9Sstevel@tonic-gate 	devp = strrchr(devfs_path, '/');
21407c478bd9Sstevel@tonic-gate 	if (devp == NULL)
21417c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
21427c478bd9Sstevel@tonic-gate 	*devp = '\0';
21437c478bd9Sstevel@tonic-gate 	++devp;
21447c478bd9Sstevel@tonic-gate 
21457c478bd9Sstevel@tonic-gate 	/*
21467c478bd9Sstevel@tonic-gate 	 * Check if device node name has the ffb string
21477c478bd9Sstevel@tonic-gate 	 * If not, assume it's not a ffb device.
21487c478bd9Sstevel@tonic-gate 	 */
21497c478bd9Sstevel@tonic-gate 	if (strstr(devp, FFB_NAME) == NULL)
21507c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
21517c478bd9Sstevel@tonic-gate 
21527c478bd9Sstevel@tonic-gate 	/*
21537c478bd9Sstevel@tonic-gate 	 * Get the parent path of the ffb device node.
21547c478bd9Sstevel@tonic-gate 	 */
21557c478bd9Sstevel@tonic-gate 	(void) snprintf(dev_path, sizeof (dev_path), "%s/%s", "/devices",
21567c478bd9Sstevel@tonic-gate 	    devfs_path);
21577c478bd9Sstevel@tonic-gate 
21587c478bd9Sstevel@tonic-gate 	/*
21597c478bd9Sstevel@tonic-gate 	 * Since we don't know ffb's minor nodename,
21607c478bd9Sstevel@tonic-gate 	 * we need to search all the devices under its
21617c478bd9Sstevel@tonic-gate 	 * parent dir by comparing the node name
21627c478bd9Sstevel@tonic-gate 	 */
21637c478bd9Sstevel@tonic-gate 	if ((dirp = opendir(dev_path)) == NULL)
21647c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
21657c478bd9Sstevel@tonic-gate 
21667c478bd9Sstevel@tonic-gate 	while ((direntp = readdir(dirp)) != NULL) {
21677c478bd9Sstevel@tonic-gate 		if (strstr(direntp->d_name, devp) != NULL) {
21687c478bd9Sstevel@tonic-gate 			(void) strcat(dev_path, "/");
21697c478bd9Sstevel@tonic-gate 			(void) strcat(dev_path, direntp->d_name);
21707c478bd9Sstevel@tonic-gate 			tmpfd = open(dev_path, O_RDWR);
21717c478bd9Sstevel@tonic-gate 			if (tmpfd < 0)
21727c478bd9Sstevel@tonic-gate 				continue;
21737c478bd9Sstevel@tonic-gate 			*fd = tmpfd;
21747c478bd9Sstevel@tonic-gate 			(void) closedir(dirp);
21757c478bd9Sstevel@tonic-gate 			return (PICL_SUCCESS);
21767c478bd9Sstevel@tonic-gate 		}
21777c478bd9Sstevel@tonic-gate 	}
21787c478bd9Sstevel@tonic-gate 
21797c478bd9Sstevel@tonic-gate 	(void) closedir(dirp);
21807c478bd9Sstevel@tonic-gate 	return (PICL_FAILURE);
21817c478bd9Sstevel@tonic-gate }
21827c478bd9Sstevel@tonic-gate 
21837c478bd9Sstevel@tonic-gate /*
21847c478bd9Sstevel@tonic-gate  * This function recursively searches the tree for ffb display devices
21857c478bd9Sstevel@tonic-gate  * and add ffb config information
21867c478bd9Sstevel@tonic-gate  */
21877c478bd9Sstevel@tonic-gate static int
21887c478bd9Sstevel@tonic-gate add_ffb_config_info(picl_nodehdl_t rooth)
21897c478bd9Sstevel@tonic-gate {
21907c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		nodeh;
21917c478bd9Sstevel@tonic-gate 	int			err;
21927c478bd9Sstevel@tonic-gate 	char 			piclclass[PICL_CLASSNAMELEN_MAX];
21937c478bd9Sstevel@tonic-gate 	char 			manfidbuf[FFB_MANUF_BUFSIZE];
21947c478bd9Sstevel@tonic-gate 	int 			fd;
21957c478bd9Sstevel@tonic-gate 	int			board_rev;
21967c478bd9Sstevel@tonic-gate 	ffb_sys_info_t		fsi;
21977c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
21987c478bd9Sstevel@tonic-gate 
21997c478bd9Sstevel@tonic-gate 	for (err = ptree_get_propval_by_name(rooth, PICL_PROP_CHILD, &nodeh,
22007c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t)); err != PICL_PROPNOTFOUND;
22015e3e415aSfw 	    err = ptree_get_propval_by_name(nodeh, PICL_PROP_PEER,
22025e3e415aSfw 	    &nodeh, sizeof (picl_nodehdl_t))) {
22037c478bd9Sstevel@tonic-gate 
22047c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
22057c478bd9Sstevel@tonic-gate 			return (err);
22067c478bd9Sstevel@tonic-gate 
22077c478bd9Sstevel@tonic-gate 		err = ptree_get_propval_by_name(nodeh, PICL_PROP_CLASSNAME,
22087c478bd9Sstevel@tonic-gate 		    piclclass, PICL_CLASSNAMELEN_MAX);
22097c478bd9Sstevel@tonic-gate 
22107c478bd9Sstevel@tonic-gate 		if ((err == PICL_SUCCESS) &&
22117c478bd9Sstevel@tonic-gate 		    (strcmp(piclclass, PICL_CLASS_DISPLAY) == 0)) {
22127c478bd9Sstevel@tonic-gate 
22137c478bd9Sstevel@tonic-gate 			err = open_ffb_device(nodeh, &fd);
22147c478bd9Sstevel@tonic-gate 			if ((err == PICL_SUCCESS) &&
22157c478bd9Sstevel@tonic-gate 			    (ioctl(fd, FFB_SYS_INFO, &fsi) >= 0)) {
22167c478bd9Sstevel@tonic-gate 				(void) ptree_init_propinfo(&pinfo,
22177c478bd9Sstevel@tonic-gate 				    PTREE_PROPINFO_VERSION,
22187c478bd9Sstevel@tonic-gate 				    PICL_PTYPE_UNSIGNED_INT, PICL_READ,
22197c478bd9Sstevel@tonic-gate 				    sizeof (int), PICL_PROP_FFB_BOARD_REV,
22207c478bd9Sstevel@tonic-gate 				    NULL, NULL);
22217c478bd9Sstevel@tonic-gate 				board_rev = fsi.ffb_strap_bits.fld.board_rev;
22227c478bd9Sstevel@tonic-gate 				(void) ptree_create_and_add_prop(nodeh, &pinfo,
22237c478bd9Sstevel@tonic-gate 				    &board_rev, NULL);
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate 				fmt_manf_id(fsi.dac_version,
22267c478bd9Sstevel@tonic-gate 				    sizeof (manfidbuf), manfidbuf);
22277c478bd9Sstevel@tonic-gate 				(void) ptree_init_propinfo(&pinfo,
22287c478bd9Sstevel@tonic-gate 				    PTREE_PROPINFO_VERSION,
22297c478bd9Sstevel@tonic-gate 				    PICL_PTYPE_CHARSTRING, PICL_READ,
22307c478bd9Sstevel@tonic-gate 				    strlen(manfidbuf) + 1,
22317c478bd9Sstevel@tonic-gate 				    PICL_PROP_FFB_DAC_VER, NULL, NULL);
22327c478bd9Sstevel@tonic-gate 				(void) ptree_create_and_add_prop(nodeh, &pinfo,
22337c478bd9Sstevel@tonic-gate 				    manfidbuf, NULL);
22347c478bd9Sstevel@tonic-gate 
22357c478bd9Sstevel@tonic-gate 				fmt_manf_id(fsi.fbram_version,
22367c478bd9Sstevel@tonic-gate 				    sizeof (manfidbuf), manfidbuf);
22377c478bd9Sstevel@tonic-gate 				(void) ptree_init_propinfo(&pinfo,
22387c478bd9Sstevel@tonic-gate 				    PTREE_PROPINFO_VERSION,
22397c478bd9Sstevel@tonic-gate 				    PICL_PTYPE_CHARSTRING, PICL_READ,
22407c478bd9Sstevel@tonic-gate 				    strlen(manfidbuf) + 1,
22417c478bd9Sstevel@tonic-gate 				    PICL_PROP_FFB_FBRAM_VER, NULL,
22427c478bd9Sstevel@tonic-gate 				    NULL);
22437c478bd9Sstevel@tonic-gate 				(void) ptree_create_and_add_prop(nodeh, &pinfo,
22447c478bd9Sstevel@tonic-gate 				    manfidbuf, NULL);
22457c478bd9Sstevel@tonic-gate 				(void) close(fd);
22467c478bd9Sstevel@tonic-gate 			}
22477c478bd9Sstevel@tonic-gate 		} else if (add_ffb_config_info(nodeh) != PICL_SUCCESS)
22487c478bd9Sstevel@tonic-gate 			return (PICL_FAILURE);
22497c478bd9Sstevel@tonic-gate 	}
22507c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
22517c478bd9Sstevel@tonic-gate }
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate static conf_entries_t *
22547c478bd9Sstevel@tonic-gate free_conf_entries(conf_entries_t *list)
22557c478bd9Sstevel@tonic-gate {
22567c478bd9Sstevel@tonic-gate 	conf_entries_t	*el;
22577c478bd9Sstevel@tonic-gate 	conf_entries_t	*del;
22587c478bd9Sstevel@tonic-gate 
22597c478bd9Sstevel@tonic-gate 	if (list == NULL)
22607c478bd9Sstevel@tonic-gate 		return (NULL);
22617c478bd9Sstevel@tonic-gate 	el = list;
22627c478bd9Sstevel@tonic-gate 	while (el != NULL) {
22637c478bd9Sstevel@tonic-gate 		del = el;
22647c478bd9Sstevel@tonic-gate 		el = el->next;
22657c478bd9Sstevel@tonic-gate 		free(del->name);
22667c478bd9Sstevel@tonic-gate 		free(del->piclclass);
22677c478bd9Sstevel@tonic-gate 		free(del);
22687c478bd9Sstevel@tonic-gate 	}
22697c478bd9Sstevel@tonic-gate 	return (el);
22707c478bd9Sstevel@tonic-gate }
22717c478bd9Sstevel@tonic-gate 
22727c478bd9Sstevel@tonic-gate /*
22737c478bd9Sstevel@tonic-gate  * Reading config order: platform, common
22747c478bd9Sstevel@tonic-gate  */
22757c478bd9Sstevel@tonic-gate static conf_entries_t *
22767c478bd9Sstevel@tonic-gate read_conf_file(char *fname, conf_entries_t *list)
22777c478bd9Sstevel@tonic-gate {
22787c478bd9Sstevel@tonic-gate 	FILE		*fp;
22797c478bd9Sstevel@tonic-gate 	char		lbuf[CONFFILE_LINELEN_MAX];
22807c478bd9Sstevel@tonic-gate 	char		*nametok;
22817c478bd9Sstevel@tonic-gate 	char		*classtok;
22827c478bd9Sstevel@tonic-gate 	conf_entries_t	*el;
22837c478bd9Sstevel@tonic-gate 	conf_entries_t	*ptr;
22847c478bd9Sstevel@tonic-gate 
22857c478bd9Sstevel@tonic-gate 	if (fname == NULL)
22867c478bd9Sstevel@tonic-gate 		return (list);
22877c478bd9Sstevel@tonic-gate 
22887c478bd9Sstevel@tonic-gate 	fp = fopen(fname, "r");
22897c478bd9Sstevel@tonic-gate 
22907c478bd9Sstevel@tonic-gate 	if (fp == NULL)
22917c478bd9Sstevel@tonic-gate 		return (list);
22927c478bd9Sstevel@tonic-gate 
22937c478bd9Sstevel@tonic-gate 	while (fgets(lbuf, CONFFILE_LINELEN_MAX, fp) != NULL) {
22947c478bd9Sstevel@tonic-gate 		if ((lbuf[0] == CONFFILE_COMMENT_CHAR) || (lbuf[0] == '\n'))
22957c478bd9Sstevel@tonic-gate 			continue;
22967c478bd9Sstevel@tonic-gate 
22977c478bd9Sstevel@tonic-gate 		nametok = strtok(lbuf, " \t\n");
22987c478bd9Sstevel@tonic-gate 		if (nametok == NULL)
22997c478bd9Sstevel@tonic-gate 			continue;
23007c478bd9Sstevel@tonic-gate 
23017c478bd9Sstevel@tonic-gate 		classtok = strtok(NULL, " \t\n");
23027c478bd9Sstevel@tonic-gate 		if (classtok == NULL)
23037c478bd9Sstevel@tonic-gate 			continue;
23047c478bd9Sstevel@tonic-gate 
23057c478bd9Sstevel@tonic-gate 		el = malloc(sizeof (conf_entries_t));
23067c478bd9Sstevel@tonic-gate 		if (el == NULL)
23077c478bd9Sstevel@tonic-gate 			break;
23087c478bd9Sstevel@tonic-gate 		el->name = strdup(nametok);
23097c478bd9Sstevel@tonic-gate 		el->piclclass = strdup(classtok);
23107c478bd9Sstevel@tonic-gate 		if ((el->name == NULL) || (el->piclclass == NULL)) {
23117c478bd9Sstevel@tonic-gate 			free(el);
23127c478bd9Sstevel@tonic-gate 			return (list);
23137c478bd9Sstevel@tonic-gate 		}
23147c478bd9Sstevel@tonic-gate 		el->next = NULL;
23157c478bd9Sstevel@tonic-gate 
23167c478bd9Sstevel@tonic-gate 		/*
23177c478bd9Sstevel@tonic-gate 		 * Add it to the end of list
23187c478bd9Sstevel@tonic-gate 		 */
23197c478bd9Sstevel@tonic-gate 		if (list == NULL)
23207c478bd9Sstevel@tonic-gate 			list = el;
23217c478bd9Sstevel@tonic-gate 		else {
23227c478bd9Sstevel@tonic-gate 			ptr = list;
23237c478bd9Sstevel@tonic-gate 			while (ptr->next != NULL)
23247c478bd9Sstevel@tonic-gate 				ptr = ptr->next;
23257c478bd9Sstevel@tonic-gate 			ptr->next = el;
23267c478bd9Sstevel@tonic-gate 		}
23277c478bd9Sstevel@tonic-gate 
23287c478bd9Sstevel@tonic-gate 	}
23297c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
23307c478bd9Sstevel@tonic-gate 	return (list);
23317c478bd9Sstevel@tonic-gate }
23327c478bd9Sstevel@tonic-gate 
23337c478bd9Sstevel@tonic-gate /*
23347c478bd9Sstevel@tonic-gate  * Process the devtree conf file and set up the conf_name_class_map list
23357c478bd9Sstevel@tonic-gate  */
23367c478bd9Sstevel@tonic-gate static void
23377c478bd9Sstevel@tonic-gate process_devtree_conf_file(void)
23387c478bd9Sstevel@tonic-gate {
23397c478bd9Sstevel@tonic-gate 	char	nmbuf[SYS_NMLN];
23407c478bd9Sstevel@tonic-gate 	char	pname[PATH_MAX];
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 	conf_name_class_map = NULL;
23437c478bd9Sstevel@tonic-gate 
23447c478bd9Sstevel@tonic-gate 	if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
23457c478bd9Sstevel@tonic-gate 		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
23467c478bd9Sstevel@tonic-gate 		(void) strlcat(pname, DEVTREE_CONFFILE_NAME, PATH_MAX);
23477c478bd9Sstevel@tonic-gate 		conf_name_class_map = read_conf_file(pname,
23487c478bd9Sstevel@tonic-gate 		    conf_name_class_map);
23497c478bd9Sstevel@tonic-gate 	}
23507c478bd9Sstevel@tonic-gate 
23517c478bd9Sstevel@tonic-gate 	if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
23527c478bd9Sstevel@tonic-gate 		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
23537c478bd9Sstevel@tonic-gate 		(void) strlcat(pname, DEVTREE_CONFFILE_NAME, PATH_MAX);
23547c478bd9Sstevel@tonic-gate 		conf_name_class_map = read_conf_file(pname,
23557c478bd9Sstevel@tonic-gate 		    conf_name_class_map);
23567c478bd9Sstevel@tonic-gate 	}
23577c478bd9Sstevel@tonic-gate 
23587c478bd9Sstevel@tonic-gate 	(void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
23597c478bd9Sstevel@tonic-gate 	    DEVTREE_CONFFILE_NAME);
23607c478bd9Sstevel@tonic-gate 	conf_name_class_map = read_conf_file(pname, conf_name_class_map);
23617c478bd9Sstevel@tonic-gate }
23627c478bd9Sstevel@tonic-gate 
23637c478bd9Sstevel@tonic-gate static	asr_conf_entries_t	*conf_name_asr_map = NULL;
23647c478bd9Sstevel@tonic-gate 
23657c478bd9Sstevel@tonic-gate static void
23667c478bd9Sstevel@tonic-gate free_asr_conf_entries(asr_conf_entries_t *list) {
23677c478bd9Sstevel@tonic-gate 	asr_conf_entries_t  *el;
23687c478bd9Sstevel@tonic-gate 	asr_conf_entries_t  *del;
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 	el = list;
23717c478bd9Sstevel@tonic-gate 	while (el != NULL) {
23727c478bd9Sstevel@tonic-gate 		del = el;
23737c478bd9Sstevel@tonic-gate 		el = el->next;
23747c478bd9Sstevel@tonic-gate 		if (del->name)
23757c478bd9Sstevel@tonic-gate 			free(del->name);
23767c478bd9Sstevel@tonic-gate 		if (del->address)
23777c478bd9Sstevel@tonic-gate 			free(del->address);
23787c478bd9Sstevel@tonic-gate 		if (del->status)
23797c478bd9Sstevel@tonic-gate 			free(del->status);
23807c478bd9Sstevel@tonic-gate 		if (del->piclclass)
23817c478bd9Sstevel@tonic-gate 			free(del->piclclass);
23827c478bd9Sstevel@tonic-gate 		if (del->props)
23837c478bd9Sstevel@tonic-gate 			free(del->props);
23847c478bd9Sstevel@tonic-gate 		free(del);
23857c478bd9Sstevel@tonic-gate 	}
23867c478bd9Sstevel@tonic-gate }
23877c478bd9Sstevel@tonic-gate 
23887c478bd9Sstevel@tonic-gate /*
23897c478bd9Sstevel@tonic-gate  * Reading config order: platform, common
23907c478bd9Sstevel@tonic-gate  */
23917c478bd9Sstevel@tonic-gate static asr_conf_entries_t *
23927c478bd9Sstevel@tonic-gate read_asr_conf_file(char *fname, asr_conf_entries_t *list)
23937c478bd9Sstevel@tonic-gate {
23947c478bd9Sstevel@tonic-gate 	FILE		*fp;
23957c478bd9Sstevel@tonic-gate 	char		lbuf[CONFFILE_LINELEN_MAX];
23967c478bd9Sstevel@tonic-gate 	char		*nametok;
23977c478bd9Sstevel@tonic-gate 	char		*classtok;
23987c478bd9Sstevel@tonic-gate 	char		*statustok;
23997c478bd9Sstevel@tonic-gate 	char		*addresstok;
24007c478bd9Sstevel@tonic-gate 	char		*propstok;
24017c478bd9Sstevel@tonic-gate 	asr_conf_entries_t	*el;
24027c478bd9Sstevel@tonic-gate 	asr_conf_entries_t	*ptr;
24037c478bd9Sstevel@tonic-gate 
24047c478bd9Sstevel@tonic-gate 	if (fname == NULL)
24057c478bd9Sstevel@tonic-gate 		return (list);
24067c478bd9Sstevel@tonic-gate 
24077c478bd9Sstevel@tonic-gate 	fp = fopen(fname, "r");
24087c478bd9Sstevel@tonic-gate 	if (fp == NULL)
24097c478bd9Sstevel@tonic-gate 		return (list);
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate 	while (fgets(lbuf, CONFFILE_LINELEN_MAX, fp) != NULL) {
24127c478bd9Sstevel@tonic-gate 		if ((lbuf[0] == CONFFILE_COMMENT_CHAR) || (lbuf[0] == '\n'))
24137c478bd9Sstevel@tonic-gate 			continue;
24147c478bd9Sstevel@tonic-gate 
24157c478bd9Sstevel@tonic-gate 		nametok = strtok(lbuf, " \t\n");
24167c478bd9Sstevel@tonic-gate 		if (nametok == NULL)
24177c478bd9Sstevel@tonic-gate 			continue;
24187c478bd9Sstevel@tonic-gate 
24197c478bd9Sstevel@tonic-gate 		classtok = strtok(NULL, " \t\n");
24207c478bd9Sstevel@tonic-gate 		if (classtok == NULL)
24217c478bd9Sstevel@tonic-gate 			continue;
24227c478bd9Sstevel@tonic-gate 
24237c478bd9Sstevel@tonic-gate 		statustok = strtok(NULL, " \t\n");
24247c478bd9Sstevel@tonic-gate 		if (statustok == NULL)
24257c478bd9Sstevel@tonic-gate 			continue;
24267c478bd9Sstevel@tonic-gate 
24277c478bd9Sstevel@tonic-gate 		addresstok = strtok(NULL, " \t\n");
24287c478bd9Sstevel@tonic-gate 		if (addresstok == NULL)
24297c478bd9Sstevel@tonic-gate 			continue;
24307c478bd9Sstevel@tonic-gate 
24317c478bd9Sstevel@tonic-gate 		/*
24327c478bd9Sstevel@tonic-gate 		 * props are optional
24337c478bd9Sstevel@tonic-gate 		 */
24347c478bd9Sstevel@tonic-gate 		propstok = strtok(NULL, " \t\n");
24357c478bd9Sstevel@tonic-gate 
24367c478bd9Sstevel@tonic-gate 		el = malloc(sizeof (asr_conf_entries_t));
24377c478bd9Sstevel@tonic-gate 		if (el == NULL)
24387c478bd9Sstevel@tonic-gate 			break;
24397c478bd9Sstevel@tonic-gate 		el->name = strdup(nametok);
24407c478bd9Sstevel@tonic-gate 		el->piclclass = strdup(classtok);
24417c478bd9Sstevel@tonic-gate 		el->status = strdup(statustok);
24427c478bd9Sstevel@tonic-gate 		el->address = strdup(addresstok);
24437c478bd9Sstevel@tonic-gate 		if (propstok != NULL)
24447c478bd9Sstevel@tonic-gate 			el->props = strdup(propstok);
24457c478bd9Sstevel@tonic-gate 		else
24467c478bd9Sstevel@tonic-gate 			el->props = NULL;
24477c478bd9Sstevel@tonic-gate 		if ((el->name == NULL) || (el->piclclass == NULL) ||
24487c478bd9Sstevel@tonic-gate 		    (el->address == NULL) || (el->status == NULL)) {
24497c478bd9Sstevel@tonic-gate 			if (el->name)
24507c478bd9Sstevel@tonic-gate 				free(el->name);
24517c478bd9Sstevel@tonic-gate 			if (el->address)
24527c478bd9Sstevel@tonic-gate 				free(el->address);
24537c478bd9Sstevel@tonic-gate 			if (el->status)
24547c478bd9Sstevel@tonic-gate 				free(el->status);
24557c478bd9Sstevel@tonic-gate 			if (el->piclclass)
24567c478bd9Sstevel@tonic-gate 				free(el->piclclass);
24577c478bd9Sstevel@tonic-gate 			if (el->props)
24587c478bd9Sstevel@tonic-gate 				free(el->props);
24597c478bd9Sstevel@tonic-gate 			free(el);
24607c478bd9Sstevel@tonic-gate 			break;
24617c478bd9Sstevel@tonic-gate 		}
24627c478bd9Sstevel@tonic-gate 		el->next = NULL;
24637c478bd9Sstevel@tonic-gate 
24647c478bd9Sstevel@tonic-gate 		/*
24657c478bd9Sstevel@tonic-gate 		 * Add it to the end of list
24667c478bd9Sstevel@tonic-gate 		 */
24677c478bd9Sstevel@tonic-gate 		if (list == NULL)
24687c478bd9Sstevel@tonic-gate 			list = el;
24697c478bd9Sstevel@tonic-gate 		else {
24707c478bd9Sstevel@tonic-gate 			ptr = list;
24717c478bd9Sstevel@tonic-gate 			while (ptr->next != NULL)
24727c478bd9Sstevel@tonic-gate 				ptr = ptr->next;
24737c478bd9Sstevel@tonic-gate 			ptr->next = el;
24747c478bd9Sstevel@tonic-gate 		}
24757c478bd9Sstevel@tonic-gate 
24767c478bd9Sstevel@tonic-gate 	}
24777c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
24787c478bd9Sstevel@tonic-gate 	return (list);
24797c478bd9Sstevel@tonic-gate }
24807c478bd9Sstevel@tonic-gate 
24817c478bd9Sstevel@tonic-gate /*
24827c478bd9Sstevel@tonic-gate  * Process the asr conf file
24837c478bd9Sstevel@tonic-gate  */
24847c478bd9Sstevel@tonic-gate static void
24857c478bd9Sstevel@tonic-gate process_asrtree_conf_file(void)
24867c478bd9Sstevel@tonic-gate {
24877c478bd9Sstevel@tonic-gate 	char	nmbuf[SYS_NMLN];
24887c478bd9Sstevel@tonic-gate 	char	pname[PATH_MAX];
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate 	if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
24917c478bd9Sstevel@tonic-gate 		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
24927c478bd9Sstevel@tonic-gate 		(void) strlcat(pname, ASRTREE_CONFFILE_NAME, PATH_MAX);
24937c478bd9Sstevel@tonic-gate 		conf_name_asr_map = read_asr_conf_file(pname,
24945e3e415aSfw 		    conf_name_asr_map);
24957c478bd9Sstevel@tonic-gate 	}
24967c478bd9Sstevel@tonic-gate 
24977c478bd9Sstevel@tonic-gate 	if (sysinfo(SI_MACHINE, nmbuf, sizeof (nmbuf)) != -1) {
24987c478bd9Sstevel@tonic-gate 		(void) snprintf(pname, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF, nmbuf);
24997c478bd9Sstevel@tonic-gate 		(void) strlcat(pname, ASRTREE_CONFFILE_NAME, PATH_MAX);
25007c478bd9Sstevel@tonic-gate 		conf_name_asr_map = read_asr_conf_file(pname,
25015e3e415aSfw 		    conf_name_asr_map);
25027c478bd9Sstevel@tonic-gate 	}
25037c478bd9Sstevel@tonic-gate 
25047c478bd9Sstevel@tonic-gate 	(void) snprintf(pname, PATH_MAX, "%s/%s", PICLD_COMMON_PLUGIN_DIR,
25057c478bd9Sstevel@tonic-gate 	    ASRTREE_CONFFILE_NAME);
25067c478bd9Sstevel@tonic-gate 	conf_name_asr_map = read_asr_conf_file(pname, conf_name_asr_map);
25077c478bd9Sstevel@tonic-gate }
25087c478bd9Sstevel@tonic-gate 
25097c478bd9Sstevel@tonic-gate /*
25107c478bd9Sstevel@tonic-gate  * This function reads the export file list from ASR
25117c478bd9Sstevel@tonic-gate  */
25127c478bd9Sstevel@tonic-gate static int
25137c478bd9Sstevel@tonic-gate get_asr_export_list(char **exportlist, int *exportlistlen)
25147c478bd9Sstevel@tonic-gate {
25157c478bd9Sstevel@tonic-gate 	struct openpromio oppbuf;
25167c478bd9Sstevel@tonic-gate 	struct openpromio *opp = &oppbuf;
25177c478bd9Sstevel@tonic-gate 	int d;
25187c478bd9Sstevel@tonic-gate 	int listsize;
25197c478bd9Sstevel@tonic-gate 
25207c478bd9Sstevel@tonic-gate 	d = open("/dev/openprom", O_RDWR);
25217c478bd9Sstevel@tonic-gate 	if (d < 0)
25227c478bd9Sstevel@tonic-gate 		return (0);
25237c478bd9Sstevel@tonic-gate 
25247c478bd9Sstevel@tonic-gate 	if (ioctl(d, OPROMEXPORTLEN, opp) == -1) {
25257c478bd9Sstevel@tonic-gate 		(void) close(d);
25267c478bd9Sstevel@tonic-gate 		return (0);
25277c478bd9Sstevel@tonic-gate 	}
25287c478bd9Sstevel@tonic-gate 	listsize = opp->oprom_size;
25297c478bd9Sstevel@tonic-gate 	opp = (struct openpromio *)malloc(sizeof (struct openpromio) +
25307c478bd9Sstevel@tonic-gate 	    listsize);
25317c478bd9Sstevel@tonic-gate 	if (opp == NULL) {
25327c478bd9Sstevel@tonic-gate 		(void) close(d);
25337c478bd9Sstevel@tonic-gate 		return (0);
25347c478bd9Sstevel@tonic-gate 	}
25357c478bd9Sstevel@tonic-gate 	(void) memset(opp, '\0', sizeof (struct openpromio) + listsize);
25367c478bd9Sstevel@tonic-gate 	opp->oprom_size = listsize;
25377c478bd9Sstevel@tonic-gate 	if (ioctl(d, OPROMEXPORT, opp) == -1) {
25387c478bd9Sstevel@tonic-gate 		free(opp);
25397c478bd9Sstevel@tonic-gate 		(void) close(d);
25407c478bd9Sstevel@tonic-gate 		return (0);
25417c478bd9Sstevel@tonic-gate 	}
25427c478bd9Sstevel@tonic-gate 	*exportlist = malloc(listsize);
25437c478bd9Sstevel@tonic-gate 	if (*exportlist == NULL) {
25447c478bd9Sstevel@tonic-gate 		free(opp);
25457c478bd9Sstevel@tonic-gate 		(void) close(d);
25467c478bd9Sstevel@tonic-gate 		return (0);
25477c478bd9Sstevel@tonic-gate 	}
25487c478bd9Sstevel@tonic-gate 	(void) memcpy(*exportlist, opp->oprom_array, opp->oprom_size);
25497c478bd9Sstevel@tonic-gate 	free(opp);
25507c478bd9Sstevel@tonic-gate 	*exportlistlen = opp->oprom_size;
25517c478bd9Sstevel@tonic-gate 	(void) close(d);
25527c478bd9Sstevel@tonic-gate 	return (1);
25537c478bd9Sstevel@tonic-gate }
25547c478bd9Sstevel@tonic-gate 
25557c478bd9Sstevel@tonic-gate /*
25567c478bd9Sstevel@tonic-gate  * Parses properties string, fills in triplet structure with first
25577c478bd9Sstevel@tonic-gate  * type, name, val triplet and returns pointer to next property.
25587c478bd9Sstevel@tonic-gate  * Returns NULL if no valid triplet found
25597c478bd9Sstevel@tonic-gate  * CAUTION: drops \0 characters over separator characters: if you
25607c478bd9Sstevel@tonic-gate  * want to parse the string twice, you'll have to take a copy.
25617c478bd9Sstevel@tonic-gate  */
25627c478bd9Sstevel@tonic-gate static char *
25637c478bd9Sstevel@tonic-gate parse_props_string(char *props, asr_prop_triplet_t *triplet)
25647c478bd9Sstevel@tonic-gate {
25657c478bd9Sstevel@tonic-gate 	char	*prop_name;
25667c478bd9Sstevel@tonic-gate 	char	*prop_val;
25677c478bd9Sstevel@tonic-gate 	char	*prop_next;
25687c478bd9Sstevel@tonic-gate 
25697c478bd9Sstevel@tonic-gate 	prop_name = strchr(props, '?');
25707c478bd9Sstevel@tonic-gate 	if (prop_name == NULL)
25717c478bd9Sstevel@tonic-gate 		return (NULL);
25727c478bd9Sstevel@tonic-gate 	*prop_name++ = '\0';
25737c478bd9Sstevel@tonic-gate 	prop_val = strchr(prop_name, '=');
25747c478bd9Sstevel@tonic-gate 	if (prop_val == NULL)
25757c478bd9Sstevel@tonic-gate 		return (NULL);
25767c478bd9Sstevel@tonic-gate 	*prop_val++ = '\0';
25777c478bd9Sstevel@tonic-gate 	triplet->proptype = props;
25787c478bd9Sstevel@tonic-gate 	triplet->propname = prop_name;
25797c478bd9Sstevel@tonic-gate 	triplet->propval = prop_val;
25807c478bd9Sstevel@tonic-gate 	prop_next = strchr(prop_val, ':');
25817c478bd9Sstevel@tonic-gate 	if (prop_next == NULL)
25827c478bd9Sstevel@tonic-gate 		return (prop_val - 1);
25837c478bd9Sstevel@tonic-gate 	*prop_next++ = '\0';
25847c478bd9Sstevel@tonic-gate 	return (prop_next);
25857c478bd9Sstevel@tonic-gate }
25867c478bd9Sstevel@tonic-gate 
25877c478bd9Sstevel@tonic-gate static int
25887c478bd9Sstevel@tonic-gate add_status_prop(picl_nodehdl_t chdh, char *status)
25897c478bd9Sstevel@tonic-gate {
25907c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
25917c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
25927c478bd9Sstevel@tonic-gate 	int			err;
25937c478bd9Sstevel@tonic-gate 
25947c478bd9Sstevel@tonic-gate 	err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
25957c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(status) + 1,
25967c478bd9Sstevel@tonic-gate 	    PICL_PROP_STATUS, NULL, NULL);
25977c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
25987c478bd9Sstevel@tonic-gate 		return (err);
25997c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(chdh, &propinfo, status, &proph);
26007c478bd9Sstevel@tonic-gate 	return (err);
26017c478bd9Sstevel@tonic-gate }
26027c478bd9Sstevel@tonic-gate 
26037c478bd9Sstevel@tonic-gate static void
26047c478bd9Sstevel@tonic-gate create_asr_node(char *parent, char *child, char *unitaddr, char *class,
26057c478bd9Sstevel@tonic-gate 	char *status, char *props)
26067c478bd9Sstevel@tonic-gate {
26077c478bd9Sstevel@tonic-gate 	char			ptreepath[PATH_MAX];
26087c478bd9Sstevel@tonic-gate 	char			nodename[PICL_PROPNAMELEN_MAX];
26097c478bd9Sstevel@tonic-gate 	char			ua[MAX_UNIT_ADDRESS_LEN];
26107c478bd9Sstevel@tonic-gate 	char			*props_copy = NULL;
26117c478bd9Sstevel@tonic-gate 	char			*next;
26127c478bd9Sstevel@tonic-gate 	char			*prop_string;
26137c478bd9Sstevel@tonic-gate 	boolean_t		found = B_FALSE;
26147c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		nodeh;
26157c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		chdh;
26167c478bd9Sstevel@tonic-gate 	asr_prop_triplet_t	triple;
26177c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
26187c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
26197c478bd9Sstevel@tonic-gate 	int			val;
26207c478bd9Sstevel@tonic-gate 	int			err;
26217c478bd9Sstevel@tonic-gate 
26227c478bd9Sstevel@tonic-gate 	(void) strlcpy(ptreepath, PLATFORM_PATH, PATH_MAX);
26237c478bd9Sstevel@tonic-gate 	(void) strlcat(ptreepath, parent, PATH_MAX);
26247c478bd9Sstevel@tonic-gate 
26257c478bd9Sstevel@tonic-gate 	if (ptree_get_node_by_path(ptreepath, &nodeh) != PICL_SUCCESS)
26267c478bd9Sstevel@tonic-gate 		return;
26277c478bd9Sstevel@tonic-gate 	/*
26287c478bd9Sstevel@tonic-gate 	 * see if the required child node already exists
26297c478bd9Sstevel@tonic-gate 	 */
26307c478bd9Sstevel@tonic-gate 	for (err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
26317c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t)); err != PICL_PROPNOTFOUND;
26327c478bd9Sstevel@tonic-gate 	    err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
26335e3e415aSfw 	    sizeof (picl_nodehdl_t))) {
26347c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
26357c478bd9Sstevel@tonic-gate 			break;
26367c478bd9Sstevel@tonic-gate 		err = ptree_get_propval_by_name(chdh, PICL_PROP_NAME,
26377c478bd9Sstevel@tonic-gate 		    (void *)nodename, PICL_PROPNAMELEN_MAX);
26387c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
26397c478bd9Sstevel@tonic-gate 			break;
26407c478bd9Sstevel@tonic-gate 		if (strcmp(nodename, child) != 0)
26417c478bd9Sstevel@tonic-gate 			continue;
26427c478bd9Sstevel@tonic-gate 		/*
26437c478bd9Sstevel@tonic-gate 		 * found a candidate child node
26447c478bd9Sstevel@tonic-gate 		 */
26457c478bd9Sstevel@tonic-gate 		if (unitaddr) {
26467c478bd9Sstevel@tonic-gate 			/*
26477c478bd9Sstevel@tonic-gate 			 * does it match the required unit address?
26487c478bd9Sstevel@tonic-gate 			 */
26497c478bd9Sstevel@tonic-gate 			err = ptree_get_propval_by_name(chdh,
26507c478bd9Sstevel@tonic-gate 			    PICL_PROP_UNIT_ADDRESS, ua, sizeof (ua));
26517c478bd9Sstevel@tonic-gate 			if (err == PICL_PROPNOTFOUND)
26527c478bd9Sstevel@tonic-gate 				continue;
26537c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
26547c478bd9Sstevel@tonic-gate 				break;
26557c478bd9Sstevel@tonic-gate 			if (strcmp(unitaddr, ua) != 0)
26567c478bd9Sstevel@tonic-gate 				continue;
26577c478bd9Sstevel@tonic-gate 		}
26587c478bd9Sstevel@tonic-gate 		if (props == NULL) {
26597c478bd9Sstevel@tonic-gate 			next = "";
26607c478bd9Sstevel@tonic-gate 		} else if (props_copy == NULL) {
26617c478bd9Sstevel@tonic-gate 			props_copy = strdup(props);
26627c478bd9Sstevel@tonic-gate 			if (props_copy == NULL)
26637c478bd9Sstevel@tonic-gate 				return;
26647c478bd9Sstevel@tonic-gate 			next = props_copy;
26657c478bd9Sstevel@tonic-gate 		}
26667c478bd9Sstevel@tonic-gate 		while ((next = parse_props_string(next, &triple)) != NULL) {
26677c478bd9Sstevel@tonic-gate 			err = ptree_get_prop_by_name(chdh, triple.propname,
26687c478bd9Sstevel@tonic-gate 			    &proph);
26697c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
26707c478bd9Sstevel@tonic-gate 				break;
26717c478bd9Sstevel@tonic-gate 			err = ptree_get_propinfo(proph, &propinfo);
26727c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS)
26737c478bd9Sstevel@tonic-gate 				break;
26747c478bd9Sstevel@tonic-gate 			err = PICL_FAILURE;
26757c478bd9Sstevel@tonic-gate 			switch (propinfo.piclinfo.type) {
26767c478bd9Sstevel@tonic-gate 			case PICL_PTYPE_INT:
26777c478bd9Sstevel@tonic-gate 			case PICL_PTYPE_UNSIGNED_INT:
26787c478bd9Sstevel@tonic-gate 				if (strcmp(triple.proptype, "I") != 0)
26797c478bd9Sstevel@tonic-gate 					break;
26807c478bd9Sstevel@tonic-gate 				err = ptree_get_propval(proph, (void  *)&val,
26817c478bd9Sstevel@tonic-gate 				    sizeof (val));
26827c478bd9Sstevel@tonic-gate 				if (err != PICL_SUCCESS)
26837c478bd9Sstevel@tonic-gate 					break;
26847c478bd9Sstevel@tonic-gate 				if (val != atoi(triple.propval))
26857c478bd9Sstevel@tonic-gate 					err = PICL_FAILURE;
26867c478bd9Sstevel@tonic-gate 				break;
26877c478bd9Sstevel@tonic-gate 			case PICL_PTYPE_CHARSTRING:
26887c478bd9Sstevel@tonic-gate 				if (strcmp(triple.proptype, "S") != 0)
26897c478bd9Sstevel@tonic-gate 					break;
26907c478bd9Sstevel@tonic-gate 				prop_string = malloc(propinfo.piclinfo.size);
26917c478bd9Sstevel@tonic-gate 				if (prop_string == NULL)
26927c478bd9Sstevel@tonic-gate 					break;
26937c478bd9Sstevel@tonic-gate 				err = ptree_get_propval(proph,
26947c478bd9Sstevel@tonic-gate 				    (void *)prop_string,
26957c478bd9Sstevel@tonic-gate 				    propinfo.piclinfo.size);
26967c478bd9Sstevel@tonic-gate 				if (err != PICL_SUCCESS) {
26977c478bd9Sstevel@tonic-gate 					free(prop_string);
26987c478bd9Sstevel@tonic-gate 					break;
26997c478bd9Sstevel@tonic-gate 				}
27007c478bd9Sstevel@tonic-gate 				if (strcmp(prop_string, triple.propval) != 0)
27017c478bd9Sstevel@tonic-gate 					err = PICL_FAILURE;
27027c478bd9Sstevel@tonic-gate 				free(prop_string);
27037c478bd9Sstevel@tonic-gate 				break;
27047c478bd9Sstevel@tonic-gate 			default:
27057c478bd9Sstevel@tonic-gate 				break;
27067c478bd9Sstevel@tonic-gate 			}
27077c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
27087c478bd9Sstevel@tonic-gate 				break;
27097c478bd9Sstevel@tonic-gate 			}
27107c478bd9Sstevel@tonic-gate 		}
27117c478bd9Sstevel@tonic-gate 		if (next == NULL) {
27127c478bd9Sstevel@tonic-gate 			found = B_TRUE;
27137c478bd9Sstevel@tonic-gate 			break;
27147c478bd9Sstevel@tonic-gate 		}
27157c478bd9Sstevel@tonic-gate 	}
27167c478bd9Sstevel@tonic-gate 	if (props_copy)
27177c478bd9Sstevel@tonic-gate 		free(props_copy);
27187c478bd9Sstevel@tonic-gate 	if (found) {
27197c478bd9Sstevel@tonic-gate 		/*
27207c478bd9Sstevel@tonic-gate 		 * does the pre-existing node have a status property?
27217c478bd9Sstevel@tonic-gate 		 */
27227c478bd9Sstevel@tonic-gate 		err = ptree_get_propval_by_name(chdh, PICL_PROP_STATUS,
27237c478bd9Sstevel@tonic-gate 		    ua, sizeof (ua));
27247c478bd9Sstevel@tonic-gate 		if (err == PICL_PROPNOTFOUND)
27257c478bd9Sstevel@tonic-gate 			(void) add_status_prop(chdh, status);
27267c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
27277c478bd9Sstevel@tonic-gate 			return;
27287c478bd9Sstevel@tonic-gate 		if ((strcmp(ua, ASR_DISABLED) == 0) ||
27297c478bd9Sstevel@tonic-gate 		    (strcmp(ua, ASR_FAILED) == 0) ||
27307c478bd9Sstevel@tonic-gate 		    ((strcmp(status, ASR_DISABLED) != 0) &&
27317c478bd9Sstevel@tonic-gate 		    (strcmp(status, ASR_FAILED) != 0))) {
27327c478bd9Sstevel@tonic-gate 			return;
27337c478bd9Sstevel@tonic-gate 		}
27347c478bd9Sstevel@tonic-gate 		/*
27357c478bd9Sstevel@tonic-gate 		 * more urgent status now, so replace existing value
27367c478bd9Sstevel@tonic-gate 		 */
27377c478bd9Sstevel@tonic-gate 		err = ptree_get_prop_by_name(chdh, PICL_PROP_STATUS, &proph);
27387c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
27397c478bd9Sstevel@tonic-gate 			return;
27407c478bd9Sstevel@tonic-gate 		(void) ptree_delete_prop(proph);
27417c478bd9Sstevel@tonic-gate 		(void) ptree_destroy_prop(proph);
27427c478bd9Sstevel@tonic-gate 		err = add_status_prop(chdh, status);
27437c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
27447c478bd9Sstevel@tonic-gate 			return;
27457c478bd9Sstevel@tonic-gate 		return;
27467c478bd9Sstevel@tonic-gate 	}
27477c478bd9Sstevel@tonic-gate 
27487c478bd9Sstevel@tonic-gate 	/*
27497c478bd9Sstevel@tonic-gate 	 * typical case, node needs adding together with a set of properties
27507c478bd9Sstevel@tonic-gate 	 */
27517c478bd9Sstevel@tonic-gate 	if (ptree_create_and_add_node(nodeh, child, class, &chdh) ==
27527c478bd9Sstevel@tonic-gate 	    PICL_SUCCESS) {
27537c478bd9Sstevel@tonic-gate 		(void) add_status_prop(chdh, status);
27547c478bd9Sstevel@tonic-gate 		if (unitaddr) {
27557c478bd9Sstevel@tonic-gate 			(void) ptree_init_propinfo(&propinfo,
27567c478bd9Sstevel@tonic-gate 			    PTREE_PROPINFO_VERSION, PICL_PTYPE_CHARSTRING,
27577c478bd9Sstevel@tonic-gate 			    PICL_READ, strlen(unitaddr) + 1,
27587c478bd9Sstevel@tonic-gate 			    PICL_PROP_UNIT_ADDRESS, NULL, NULL);
27597c478bd9Sstevel@tonic-gate 			(void) ptree_create_and_add_prop(chdh, &propinfo,
27607c478bd9Sstevel@tonic-gate 			    unitaddr, &proph);
27617c478bd9Sstevel@tonic-gate 			(void) strlcpy(ptreepath, parent, PATH_MAX);
27627c478bd9Sstevel@tonic-gate 			(void) strlcat(ptreepath, "/", PATH_MAX);
27637c478bd9Sstevel@tonic-gate 			(void) strlcat(ptreepath, child, PATH_MAX);
27647c478bd9Sstevel@tonic-gate 			(void) strlcat(ptreepath, "@", PATH_MAX);
27657c478bd9Sstevel@tonic-gate 			(void) strlcat(ptreepath, unitaddr, PATH_MAX);
27667c478bd9Sstevel@tonic-gate 			(void) ptree_init_propinfo(&propinfo,
27677c478bd9Sstevel@tonic-gate 			    PTREE_PROPINFO_VERSION, PICL_PTYPE_CHARSTRING,
27687c478bd9Sstevel@tonic-gate 			    PICL_READ, strlen(ptreepath) + 1,
27697c478bd9Sstevel@tonic-gate 			    PICL_PROP_DEVFS_PATH, NULL, NULL);
27707c478bd9Sstevel@tonic-gate 			(void) ptree_create_and_add_prop(chdh, &propinfo,
27717c478bd9Sstevel@tonic-gate 			    ptreepath, &proph);
27727c478bd9Sstevel@tonic-gate 		}
27737c478bd9Sstevel@tonic-gate 		next = props;
27747c478bd9Sstevel@tonic-gate 		while ((next = parse_props_string(next, &triple)) != NULL) {
27757c478bd9Sstevel@tonic-gate 			/*
27767c478bd9Sstevel@tonic-gate 			 * only handle int and string properties for
27777c478bd9Sstevel@tonic-gate 			 * simplicity
27787c478bd9Sstevel@tonic-gate 			 */
27797c478bd9Sstevel@tonic-gate 			if (strcmp(triple.proptype, "I") == 0) {
27807c478bd9Sstevel@tonic-gate 				(void) ptree_init_propinfo(&propinfo,
27817c478bd9Sstevel@tonic-gate 				    PTREE_PROPINFO_VERSION,
27827c478bd9Sstevel@tonic-gate 				    PICL_PTYPE_INT, PICL_READ,
27837c478bd9Sstevel@tonic-gate 				    sizeof (int), triple.propname, NULL, NULL);
27847c478bd9Sstevel@tonic-gate 				val = atoi(triple.propval);
27857c478bd9Sstevel@tonic-gate 				(void) ptree_create_and_add_prop(chdh,
27867c478bd9Sstevel@tonic-gate 				    &propinfo, &val, &proph);
27877c478bd9Sstevel@tonic-gate 			} else {
27887c478bd9Sstevel@tonic-gate 				(void) ptree_init_propinfo(&propinfo,
27897c478bd9Sstevel@tonic-gate 				    PTREE_PROPINFO_VERSION,
27907c478bd9Sstevel@tonic-gate 				    PICL_PTYPE_CHARSTRING, PICL_READ,
27917c478bd9Sstevel@tonic-gate 				    strlen(triple.propval) + 1,
27925e3e415aSfw 				    triple.propname, NULL, NULL);
27937c478bd9Sstevel@tonic-gate 				(void) ptree_create_and_add_prop(chdh,
27947c478bd9Sstevel@tonic-gate 				    &propinfo, triple.propval, &proph);
27957c478bd9Sstevel@tonic-gate 			}
27967c478bd9Sstevel@tonic-gate 		}
27977c478bd9Sstevel@tonic-gate 	}
27987c478bd9Sstevel@tonic-gate }
27997c478bd9Sstevel@tonic-gate 
28007c478bd9Sstevel@tonic-gate static void
28017c478bd9Sstevel@tonic-gate add_asr_nodes()
28027c478bd9Sstevel@tonic-gate {
28037c478bd9Sstevel@tonic-gate 	char			*asrexport;
28047c478bd9Sstevel@tonic-gate 	int			asrexportlen;
28057c478bd9Sstevel@tonic-gate 	asr_conf_entries_t	*c = NULL;
28067c478bd9Sstevel@tonic-gate 	int			i;
28077c478bd9Sstevel@tonic-gate 	char			*key;
28087c478bd9Sstevel@tonic-gate 	char			*child;
28097c478bd9Sstevel@tonic-gate 	char			*unitaddr;
28107c478bd9Sstevel@tonic-gate 	uint16_t		count;
28117c478bd9Sstevel@tonic-gate 	int			disabled;
28127c478bd9Sstevel@tonic-gate 
28137c478bd9Sstevel@tonic-gate 	if (get_asr_export_list(&asrexport, &asrexportlen) == 0)
28147c478bd9Sstevel@tonic-gate 		return;
28157c478bd9Sstevel@tonic-gate 	process_asrtree_conf_file();
28167c478bd9Sstevel@tonic-gate 	if (conf_name_asr_map == NULL)
28177c478bd9Sstevel@tonic-gate 		return;
28187c478bd9Sstevel@tonic-gate 	i = 0;
28197c478bd9Sstevel@tonic-gate 	while (i < asrexportlen) {
28207c478bd9Sstevel@tonic-gate 		key = &asrexport[i];
28217c478bd9Sstevel@tonic-gate 		i += strlen(key) + 1;
28227c478bd9Sstevel@tonic-gate 		if (i >= asrexportlen)
28237c478bd9Sstevel@tonic-gate 			break;
28247c478bd9Sstevel@tonic-gate 
28257c478bd9Sstevel@tonic-gate 		/*
28267c478bd9Sstevel@tonic-gate 		 * next byte tells us whether failed by diags or manually
28277c478bd9Sstevel@tonic-gate 		 * disabled
28287c478bd9Sstevel@tonic-gate 		 */
28297c478bd9Sstevel@tonic-gate 		disabled = asrexport[i];
28307c478bd9Sstevel@tonic-gate 		i++;
28317c478bd9Sstevel@tonic-gate 		if (i >= asrexportlen)
28327c478bd9Sstevel@tonic-gate 			break;
28337c478bd9Sstevel@tonic-gate 
28347c478bd9Sstevel@tonic-gate 		/*
28357c478bd9Sstevel@tonic-gate 		 * only type 1 supported
28367c478bd9Sstevel@tonic-gate 		 */
28377c478bd9Sstevel@tonic-gate 		if (asrexport[i] != 1)
28387c478bd9Sstevel@tonic-gate 			break;
28397c478bd9Sstevel@tonic-gate 		i++;
28407c478bd9Sstevel@tonic-gate 		if (i >= asrexportlen)
28417c478bd9Sstevel@tonic-gate 			break;
28427c478bd9Sstevel@tonic-gate 
28437c478bd9Sstevel@tonic-gate 		/*
28447c478bd9Sstevel@tonic-gate 		 * next two bytes give size of reason string
28457c478bd9Sstevel@tonic-gate 		 */
28467c478bd9Sstevel@tonic-gate 		count = (asrexport[i] << 8) | asrexport[i + 1];
28477c478bd9Sstevel@tonic-gate 		i += count + 2;
28487c478bd9Sstevel@tonic-gate 		if (i > asrexportlen)
28497c478bd9Sstevel@tonic-gate 			break;
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate 		/*
28527c478bd9Sstevel@tonic-gate 		 * now look for key in conf file info
28537c478bd9Sstevel@tonic-gate 		 */
28547c478bd9Sstevel@tonic-gate 		c = conf_name_asr_map;
28557c478bd9Sstevel@tonic-gate 		while (c != NULL) {
28567c478bd9Sstevel@tonic-gate 			if (strcmp(key, c->name) == 0) {
28577c478bd9Sstevel@tonic-gate 				child = strrchr(c->address, '/');
28587c478bd9Sstevel@tonic-gate 				*child++ = '\0';
28597c478bd9Sstevel@tonic-gate 				unitaddr = strchr(child, '@');
28607c478bd9Sstevel@tonic-gate 				if (unitaddr)
28617c478bd9Sstevel@tonic-gate 					*unitaddr++ = '\0';
28627c478bd9Sstevel@tonic-gate 				if (strcmp(c->status, ASR_DISABLED) == 0) {
28637c478bd9Sstevel@tonic-gate 					create_asr_node(c->address, child,
28647c478bd9Sstevel@tonic-gate 					    unitaddr, c->piclclass, disabled ?
28657c478bd9Sstevel@tonic-gate 					    ASR_DISABLED : ASR_FAILED,
28667c478bd9Sstevel@tonic-gate 					    c->props);
28677c478bd9Sstevel@tonic-gate 				} else {
28687c478bd9Sstevel@tonic-gate 					create_asr_node(c->address, child,
28697c478bd9Sstevel@tonic-gate 					    unitaddr, c->piclclass, c->status,
28707c478bd9Sstevel@tonic-gate 					    c->props);
28717c478bd9Sstevel@tonic-gate 				}
28727c478bd9Sstevel@tonic-gate 			}
28737c478bd9Sstevel@tonic-gate 			c = c->next;
28747c478bd9Sstevel@tonic-gate 		}
28757c478bd9Sstevel@tonic-gate 	}
28767c478bd9Sstevel@tonic-gate 
28777c478bd9Sstevel@tonic-gate 	free_asr_conf_entries(conf_name_asr_map);
28787c478bd9Sstevel@tonic-gate 	free(asrexport);
28797c478bd9Sstevel@tonic-gate }
28807c478bd9Sstevel@tonic-gate 
28817c478bd9Sstevel@tonic-gate /*
28827c478bd9Sstevel@tonic-gate  * This function adds information to the /platform node
28837c478bd9Sstevel@tonic-gate  */
28847c478bd9Sstevel@tonic-gate static int
28857c478bd9Sstevel@tonic-gate add_platform_info(picl_nodehdl_t plafh)
28867c478bd9Sstevel@tonic-gate {
28877c478bd9Sstevel@tonic-gate 	struct utsname		uts_info;
28887c478bd9Sstevel@tonic-gate 	int			err;
28897c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	propinfo;
28907c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
28917c478bd9Sstevel@tonic-gate 
28927c478bd9Sstevel@tonic-gate 	if (uname(&uts_info) < 0)
28937c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
28947c478bd9Sstevel@tonic-gate 
28957c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
28967c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(uts_info.sysname) + 1,
28977c478bd9Sstevel@tonic-gate 	    PICL_PROP_SYSNAME, NULL, NULL);
28987c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, uts_info.sysname,
28997c478bd9Sstevel@tonic-gate 	    &proph);
29007c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29017c478bd9Sstevel@tonic-gate 		return (err);
29027c478bd9Sstevel@tonic-gate 
29037c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
29047c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(uts_info.nodename) + 1,
29057c478bd9Sstevel@tonic-gate 	    PICL_PROP_NODENAME, NULL, NULL);
29067c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, uts_info.nodename,
29077c478bd9Sstevel@tonic-gate 	    &proph);
29087c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29097c478bd9Sstevel@tonic-gate 		return (err);
29107c478bd9Sstevel@tonic-gate 
29117c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
29127c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(uts_info.release) + 1,
29137c478bd9Sstevel@tonic-gate 	    PICL_PROP_RELEASE, NULL, NULL);
29147c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, uts_info.release,
29157c478bd9Sstevel@tonic-gate 	    &proph);
29167c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29177c478bd9Sstevel@tonic-gate 		return (err);
29187c478bd9Sstevel@tonic-gate 
29197c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
29207c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(uts_info.version) + 1,
29217c478bd9Sstevel@tonic-gate 	    PICL_PROP_VERSION, NULL, NULL);
29227c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, uts_info.version,
29237c478bd9Sstevel@tonic-gate 	    &proph);
29247c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29257c478bd9Sstevel@tonic-gate 		return (err);
29267c478bd9Sstevel@tonic-gate 
29277c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
29287c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(uts_info.machine) + 1,
29297c478bd9Sstevel@tonic-gate 	    PICL_PROP_MACHINE, NULL, NULL);
29307c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(plafh, &propinfo, uts_info.machine,
29317c478bd9Sstevel@tonic-gate 	    &proph);
29327c478bd9Sstevel@tonic-gate 	return (err);
29337c478bd9Sstevel@tonic-gate }
29347c478bd9Sstevel@tonic-gate 
29357c478bd9Sstevel@tonic-gate /*
29367c478bd9Sstevel@tonic-gate  * Get first 32-bit value from the reg property
29377c478bd9Sstevel@tonic-gate  */
29387c478bd9Sstevel@tonic-gate static int
29397c478bd9Sstevel@tonic-gate get_first_reg_word(picl_nodehdl_t nodeh, uint32_t *regval)
29407c478bd9Sstevel@tonic-gate {
29417c478bd9Sstevel@tonic-gate 	int			err;
29427c478bd9Sstevel@tonic-gate 	uint32_t		*regbuf;
29437c478bd9Sstevel@tonic-gate 	picl_prophdl_t  	regh;
29447c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
29457c478bd9Sstevel@tonic-gate 
29467c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(nodeh, OBP_REG, &regh);
29477c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS) 	/* no reg property */
29487c478bd9Sstevel@tonic-gate 		return (err);
29497c478bd9Sstevel@tonic-gate 	err = ptree_get_propinfo(regh, &pinfo);
29507c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29517c478bd9Sstevel@tonic-gate 		return (err);
29527c478bd9Sstevel@tonic-gate 	if (pinfo.piclinfo.size < sizeof (uint32_t)) /* too small */
29537c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
29547c478bd9Sstevel@tonic-gate 	regbuf = alloca(pinfo.piclinfo.size);
29557c478bd9Sstevel@tonic-gate 	if (regbuf == NULL)
29567c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
29577c478bd9Sstevel@tonic-gate 	err = ptree_get_propval(regh, regbuf, pinfo.piclinfo.size);
29587c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29597c478bd9Sstevel@tonic-gate 		return (err);
29607c478bd9Sstevel@tonic-gate 	*regval = *regbuf;	/* get first 32-bit value */
29617c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
29627c478bd9Sstevel@tonic-gate }
29637c478bd9Sstevel@tonic-gate 
29647c478bd9Sstevel@tonic-gate /*
29657c478bd9Sstevel@tonic-gate  * Get device ID from the reg property
29667c478bd9Sstevel@tonic-gate  */
29677c478bd9Sstevel@tonic-gate static int
29687c478bd9Sstevel@tonic-gate get_device_id(picl_nodehdl_t nodeh, uint32_t *dev_id)
29697c478bd9Sstevel@tonic-gate {
29707c478bd9Sstevel@tonic-gate 	int			err;
29717c478bd9Sstevel@tonic-gate 	uint32_t		regval;
29727c478bd9Sstevel@tonic-gate 
29737c478bd9Sstevel@tonic-gate 	err = get_first_reg_word(nodeh, &regval);
29747c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
29757c478bd9Sstevel@tonic-gate 		return (err);
29767c478bd9Sstevel@tonic-gate 
29777c478bd9Sstevel@tonic-gate 	*dev_id = PCI_DEVICE_ID(regval);
29787c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
29797c478bd9Sstevel@tonic-gate }
29807c478bd9Sstevel@tonic-gate 
29817c478bd9Sstevel@tonic-gate /*
29827c478bd9Sstevel@tonic-gate  * add Slot property for children of SBUS node
29837c478bd9Sstevel@tonic-gate  */
29847c478bd9Sstevel@tonic-gate /* ARGSUSED */
29857c478bd9Sstevel@tonic-gate static int
29867c478bd9Sstevel@tonic-gate add_sbus_slots(picl_nodehdl_t pcih, void *args)
29877c478bd9Sstevel@tonic-gate {
29887c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		nodeh;
29897c478bd9Sstevel@tonic-gate 	uint32_t		slot;
29907c478bd9Sstevel@tonic-gate 	int			err;
29917c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
29927c478bd9Sstevel@tonic-gate 
29937c478bd9Sstevel@tonic-gate 	for (err = ptree_get_propval_by_name(pcih, PICL_PROP_CHILD, &nodeh,
29947c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t)); err != PICL_PROPNOTFOUND;
29955e3e415aSfw 	    err = ptree_get_propval_by_name(nodeh, PICL_PROP_PEER, &nodeh,
29965e3e415aSfw 	    sizeof (picl_nodehdl_t))) {
29977c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
29987c478bd9Sstevel@tonic-gate 			return (err);
29997c478bd9Sstevel@tonic-gate 
30007c478bd9Sstevel@tonic-gate 		if (get_first_reg_word(nodeh, &slot) != 0)
30017c478bd9Sstevel@tonic-gate 			continue;
30027c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
30037c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_UNSIGNED_INT, PICL_READ, sizeof (uint32_t),
30047c478bd9Sstevel@tonic-gate 		    PICL_PROP_SLOT, NULL, NULL);
30057c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &pinfo, &slot, NULL);
30067c478bd9Sstevel@tonic-gate 	}
30077c478bd9Sstevel@tonic-gate 
30087c478bd9Sstevel@tonic-gate 	return (PICL_WALK_CONTINUE);
30097c478bd9Sstevel@tonic-gate }
30107c478bd9Sstevel@tonic-gate 
30117c478bd9Sstevel@tonic-gate /*
30127c478bd9Sstevel@tonic-gate  * This function creates a Slot property for SBUS child nodes
30137c478bd9Sstevel@tonic-gate  * which can be correlated with the slot they are plugged into
30147c478bd9Sstevel@tonic-gate  * on the motherboard.
30157c478bd9Sstevel@tonic-gate  */
30167c478bd9Sstevel@tonic-gate static int
30177c478bd9Sstevel@tonic-gate set_sbus_slot(picl_nodehdl_t plafh)
30187c478bd9Sstevel@tonic-gate {
30197c478bd9Sstevel@tonic-gate 	int		err;
30207c478bd9Sstevel@tonic-gate 
30217c478bd9Sstevel@tonic-gate 	err = ptree_walk_tree_by_class(plafh, PICL_CLASS_SBUS, NULL,
30227c478bd9Sstevel@tonic-gate 	    add_sbus_slots);
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate 	return (err);
30257c478bd9Sstevel@tonic-gate }
30267c478bd9Sstevel@tonic-gate 
30277c478bd9Sstevel@tonic-gate /*
30287ef4fcfbSvenki  * add DeviceID property for children of PCI/PCIEX node
30297c478bd9Sstevel@tonic-gate  */
30307c478bd9Sstevel@tonic-gate /* ARGSUSED */
30317c478bd9Sstevel@tonic-gate static int
30327c478bd9Sstevel@tonic-gate add_pci_deviceids(picl_nodehdl_t pcih, void *args)
30337c478bd9Sstevel@tonic-gate {
30347c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		nodeh;
30357c478bd9Sstevel@tonic-gate 	uint32_t		dev_id;
30367c478bd9Sstevel@tonic-gate 	int			err;
30377c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
30387c478bd9Sstevel@tonic-gate 
30397c478bd9Sstevel@tonic-gate 	for (err = ptree_get_propval_by_name(pcih, PICL_PROP_CHILD, &nodeh,
30407c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t)); err != PICL_PROPNOTFOUND;
30415e3e415aSfw 	    err = ptree_get_propval_by_name(nodeh, PICL_PROP_PEER, &nodeh,
30425e3e415aSfw 	    sizeof (picl_nodehdl_t))) {
30437c478bd9Sstevel@tonic-gate 		if (err != PICL_SUCCESS)
30447c478bd9Sstevel@tonic-gate 			return (err);
30457c478bd9Sstevel@tonic-gate 
30467c478bd9Sstevel@tonic-gate 		if (get_device_id(nodeh, &dev_id) != 0)
30477c478bd9Sstevel@tonic-gate 			continue;
30487c478bd9Sstevel@tonic-gate 		(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
30497c478bd9Sstevel@tonic-gate 		    PICL_PTYPE_UNSIGNED_INT, PICL_READ, sizeof (uint32_t),
30507c478bd9Sstevel@tonic-gate 		    PICL_PROP_DEVICE_ID, NULL, NULL);
30517c478bd9Sstevel@tonic-gate 		(void) ptree_create_and_add_prop(nodeh, &pinfo, &dev_id, NULL);
30527c478bd9Sstevel@tonic-gate 	}
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 	return (PICL_WALK_CONTINUE);
30557c478bd9Sstevel@tonic-gate }
30567c478bd9Sstevel@tonic-gate 
30577c478bd9Sstevel@tonic-gate /*
30587ef4fcfbSvenki  * This function creates a DeviceID property for PCI/PCIEX child nodes
30597c478bd9Sstevel@tonic-gate  * which can be correlated with the slot they are plugged into
30607c478bd9Sstevel@tonic-gate  * on the motherboard.
30617c478bd9Sstevel@tonic-gate  */
30627ef4fcfbSvenki static void
30637ef4fcfbSvenki set_pci_pciex_deviceid(picl_nodehdl_t plafh)
30647c478bd9Sstevel@tonic-gate {
30657ef4fcfbSvenki 	(void) ptree_walk_tree_by_class(plafh, PICL_CLASS_PCI, NULL,
30667c478bd9Sstevel@tonic-gate 	    add_pci_deviceids);
30677c478bd9Sstevel@tonic-gate 
30687ef4fcfbSvenki 	(void) ptree_walk_tree_by_class(plafh, PICL_CLASS_PCIEX, NULL,
30697ef4fcfbSvenki 	    add_pci_deviceids);
30707c478bd9Sstevel@tonic-gate }
30717c478bd9Sstevel@tonic-gate 
30727c478bd9Sstevel@tonic-gate /*
30737c478bd9Sstevel@tonic-gate  * Default UnitAddress encode function
30747c478bd9Sstevel@tonic-gate  */
30757c478bd9Sstevel@tonic-gate static int
30767c478bd9Sstevel@tonic-gate encode_default_unitaddr(char *buf, int sz, uint32_t *regprop, uint_t addrcells)
30777c478bd9Sstevel@tonic-gate {
30787c478bd9Sstevel@tonic-gate 	int	i, len;
30797c478bd9Sstevel@tonic-gate 
30807c478bd9Sstevel@tonic-gate 	/*
30817c478bd9Sstevel@tonic-gate 	 * Encode UnitAddress as %a,%b,%c,...,%n
30827c478bd9Sstevel@tonic-gate 	 */
30837c478bd9Sstevel@tonic-gate 	if (addrcells < 1)
30847c478bd9Sstevel@tonic-gate 		return (-1);
30857c478bd9Sstevel@tonic-gate 
30867c478bd9Sstevel@tonic-gate 	len = snprintf(buf, sz, "%x", *regprop);
30877c478bd9Sstevel@tonic-gate 	for (i = 1; i < addrcells && len < sz; i++)
30887c478bd9Sstevel@tonic-gate 		len += snprintf(&buf[len], sz-len, ",%x", regprop[i]);
30897c478bd9Sstevel@tonic-gate 
30907c478bd9Sstevel@tonic-gate 	return ((len >= sz) ? -1 : 0);
30917c478bd9Sstevel@tonic-gate }
30927c478bd9Sstevel@tonic-gate 
30937c478bd9Sstevel@tonic-gate /*
30947c478bd9Sstevel@tonic-gate  * UnitAddress encode function where the last component is not printed
30957c478bd9Sstevel@tonic-gate  * unless non-zero.
30967c478bd9Sstevel@tonic-gate  */
30977c478bd9Sstevel@tonic-gate static int
30987c478bd9Sstevel@tonic-gate encode_optional_unitaddr(char *buf, int sz, uint32_t *regprop, uint_t addrcells)
30997c478bd9Sstevel@tonic-gate {
31007c478bd9Sstevel@tonic-gate 	int	retval;
31017c478bd9Sstevel@tonic-gate 
31027c478bd9Sstevel@tonic-gate 	/*
31037c478bd9Sstevel@tonic-gate 	 * Encode UnitAddress as %a,%b,%c,...,%n where the last component
31047c478bd9Sstevel@tonic-gate 	 * is printed only if non-zero.
31057c478bd9Sstevel@tonic-gate 	 */
31067c478bd9Sstevel@tonic-gate 	if (addrcells > 1 && regprop[addrcells-1] == 0)
31077c478bd9Sstevel@tonic-gate 		retval = encode_default_unitaddr(buf, sz, regprop, addrcells-1);
31087c478bd9Sstevel@tonic-gate 	else
31097c478bd9Sstevel@tonic-gate 		retval = encode_default_unitaddr(buf, sz, regprop, addrcells);
31107c478bd9Sstevel@tonic-gate 
31117c478bd9Sstevel@tonic-gate 	return (retval);
31127c478bd9Sstevel@tonic-gate }
31137c478bd9Sstevel@tonic-gate 
31147c478bd9Sstevel@tonic-gate 
31157c478bd9Sstevel@tonic-gate /*
31167c478bd9Sstevel@tonic-gate  * UnitAddress encode function for SCSI class of devices
31177c478bd9Sstevel@tonic-gate  */
31187c478bd9Sstevel@tonic-gate static int
31197c478bd9Sstevel@tonic-gate encode_scsi_unitaddr(char *buf, int sz, uint32_t *regprop, uint_t addrcells)
31207c478bd9Sstevel@tonic-gate {
31217c478bd9Sstevel@tonic-gate 	int	len, retval;
31227c478bd9Sstevel@tonic-gate 
31237c478bd9Sstevel@tonic-gate 	/*
31247c478bd9Sstevel@tonic-gate 	 * #address-cells	Format
31257c478bd9Sstevel@tonic-gate 	 *	2		second component printed only if non-zero
31267c478bd9Sstevel@tonic-gate 	 *
31277c478bd9Sstevel@tonic-gate 	 *	4		regprop:   phys_hi phys_lo lun_hi lun_lo
31287c478bd9Sstevel@tonic-gate 	 *			UnitAddr:  w<phys_hi><phys_lo>,<lun_lo>
31297c478bd9Sstevel@tonic-gate 	 */
31307c478bd9Sstevel@tonic-gate 
31317c478bd9Sstevel@tonic-gate 	if (addrcells == 2) {
31327c478bd9Sstevel@tonic-gate 		retval = encode_optional_unitaddr(buf, sz, regprop, addrcells);
31337c478bd9Sstevel@tonic-gate 	} else if (addrcells == 4) {
31347c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "w%08x%08x,%x", regprop[0], regprop[1],
31357c478bd9Sstevel@tonic-gate 		    regprop[3]);
31367c478bd9Sstevel@tonic-gate 		retval = (len >= sz) ? -1 : 0;
31377c478bd9Sstevel@tonic-gate 	} else
31387c478bd9Sstevel@tonic-gate 		retval = -1;
31397c478bd9Sstevel@tonic-gate 
31407c478bd9Sstevel@tonic-gate 	return (retval);
31417c478bd9Sstevel@tonic-gate }
31427c478bd9Sstevel@tonic-gate 
31437c478bd9Sstevel@tonic-gate /*
31447c478bd9Sstevel@tonic-gate  * UnitAddress encode function for UPA devices
31457c478bd9Sstevel@tonic-gate  */
31467c478bd9Sstevel@tonic-gate static int
31477c478bd9Sstevel@tonic-gate encode_upa_unitaddr(char *buf, int sz, uint32_t *regprop, uint_t addrcells)
31487c478bd9Sstevel@tonic-gate {
31497c478bd9Sstevel@tonic-gate 	int	len;
31507c478bd9Sstevel@tonic-gate 
31517c478bd9Sstevel@tonic-gate 	if (addrcells != 2)
31527c478bd9Sstevel@tonic-gate 		return (-1);
31537c478bd9Sstevel@tonic-gate 
31547c478bd9Sstevel@tonic-gate 	len = snprintf(buf, sz, "%x,%x", (regprop[0]/2)&0x1f, regprop[1]);
31557c478bd9Sstevel@tonic-gate 	return ((len >= sz) ? -1 : 0);
31567c478bd9Sstevel@tonic-gate }
31577c478bd9Sstevel@tonic-gate 
31587c478bd9Sstevel@tonic-gate /*
31597c478bd9Sstevel@tonic-gate  * UnitAddress encode function for GPTWO, JBUS devices
31607c478bd9Sstevel@tonic-gate  */
31617c478bd9Sstevel@tonic-gate static int
31627c478bd9Sstevel@tonic-gate encode_gptwo_jbus_unitaddr(char *buf, int sz, uint32_t *regprop,
31637c478bd9Sstevel@tonic-gate     uint_t addrcells)
31647c478bd9Sstevel@tonic-gate {
31657c478bd9Sstevel@tonic-gate 	uint32_t	hi, lo;
31667c478bd9Sstevel@tonic-gate 	int		len, id, off;
31677c478bd9Sstevel@tonic-gate 
31687c478bd9Sstevel@tonic-gate 	if (addrcells != 2)
31697c478bd9Sstevel@tonic-gate 		return (-1);
31707c478bd9Sstevel@tonic-gate 
31717c478bd9Sstevel@tonic-gate 	hi = regprop[0];
31727c478bd9Sstevel@tonic-gate 	lo = regprop[1];
31737c478bd9Sstevel@tonic-gate 
31747c478bd9Sstevel@tonic-gate 	if (hi & 0x400) {
31757c478bd9Sstevel@tonic-gate 		id = ((hi & 0x1) << 9) | (lo >> 23);	/* agent id */
31767c478bd9Sstevel@tonic-gate 		off = lo & 0x7fffff;			/* config offset */
31777c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "%x,%x", id, off);
31787c478bd9Sstevel@tonic-gate 	} else {
31797c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "m%x,%x", hi, lo);
31807c478bd9Sstevel@tonic-gate 	}
31817c478bd9Sstevel@tonic-gate 	return ((len >= sz) ? -1 : 0);
31827c478bd9Sstevel@tonic-gate }
31837c478bd9Sstevel@tonic-gate 
31847c478bd9Sstevel@tonic-gate /*
31857c478bd9Sstevel@tonic-gate  * UnitAddress encode function for PCI devices
31867c478bd9Sstevel@tonic-gate  */
31877c478bd9Sstevel@tonic-gate static int
31887c478bd9Sstevel@tonic-gate encode_pci_unitaddr(char *buf, int sz, uint32_t *regprop, uint_t addrcells)
31897c478bd9Sstevel@tonic-gate {
31907c478bd9Sstevel@tonic-gate 	typedef struct {
31917c478bd9Sstevel@tonic-gate 		uint32_t	n:1,		/* relocatable */
31927c478bd9Sstevel@tonic-gate 				p:1,		/* prefetchable */
31937c478bd9Sstevel@tonic-gate 				t:1,		/* address region aliases */
31947c478bd9Sstevel@tonic-gate 				zero:3,		/* must be zero */
31957c478bd9Sstevel@tonic-gate 				ss:2,		/* address space type */
31967c478bd9Sstevel@tonic-gate 				bus:8,		/* bus number */
31977c478bd9Sstevel@tonic-gate 				dev:5,		/* device number */
31987c478bd9Sstevel@tonic-gate 				fn:3,		/* function number */
31997c478bd9Sstevel@tonic-gate 				reg:8;		/* register number */
32007c478bd9Sstevel@tonic-gate 		uint32_t	phys_hi;	/* high physical address */
32017c478bd9Sstevel@tonic-gate 		uint32_t	phys_lo;	/* low physical address */
32027c478bd9Sstevel@tonic-gate 	} pci_addrcell_t;
32037c478bd9Sstevel@tonic-gate 
32047c478bd9Sstevel@tonic-gate 	pci_addrcell_t	*p;
32057c478bd9Sstevel@tonic-gate 	int		len;
32067c478bd9Sstevel@tonic-gate 
32077c478bd9Sstevel@tonic-gate 	if (addrcells != 3)
32087c478bd9Sstevel@tonic-gate 		return (-1);
32097c478bd9Sstevel@tonic-gate 
32107c478bd9Sstevel@tonic-gate 	p = (pci_addrcell_t *)regprop;
32117c478bd9Sstevel@tonic-gate 	switch (p->ss) {
32127c478bd9Sstevel@tonic-gate 	case 0:		/* Config */
32137c478bd9Sstevel@tonic-gate 		if (p->fn)
32147c478bd9Sstevel@tonic-gate 			len = snprintf(buf, sz, "%x,%x", p->dev, p->fn);
32157c478bd9Sstevel@tonic-gate 		else
32167c478bd9Sstevel@tonic-gate 			len = snprintf(buf, sz, "%x", p->dev);
32177c478bd9Sstevel@tonic-gate 		break;
32187c478bd9Sstevel@tonic-gate 	case 1:		/* IO */
32197c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "i%x,%x,%x,%x", p->dev, p->fn, p->reg,
32207c478bd9Sstevel@tonic-gate 		    p->phys_lo);
32217c478bd9Sstevel@tonic-gate 		break;
32227c478bd9Sstevel@tonic-gate 	case 2:		/* Mem32 */
32237c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "m%x,%x,%x,%x", p->dev, p->fn, p->reg,
32247c478bd9Sstevel@tonic-gate 		    p->phys_lo);
32257c478bd9Sstevel@tonic-gate 		break;
32267c478bd9Sstevel@tonic-gate 	case 3:		/* Mem64 */
32277c478bd9Sstevel@tonic-gate 		len = snprintf(buf, sz, "x%x,%x,%x,%x%08x", p->dev, p->fn,
32287c478bd9Sstevel@tonic-gate 		    p->reg, p->phys_hi, p->phys_lo);
32297c478bd9Sstevel@tonic-gate 		break;
32307c478bd9Sstevel@tonic-gate 	}
32317c478bd9Sstevel@tonic-gate 	return ((len >= sz) ? -1 : 0);
32327c478bd9Sstevel@tonic-gate }
32337c478bd9Sstevel@tonic-gate 
32347c478bd9Sstevel@tonic-gate /*
32357c478bd9Sstevel@tonic-gate  * Get #address-cells property value
32367c478bd9Sstevel@tonic-gate  */
32377c478bd9Sstevel@tonic-gate static uint_t
32387c478bd9Sstevel@tonic-gate get_addrcells_prop(picl_nodehdl_t nodeh)
32397c478bd9Sstevel@tonic-gate {
32407c478bd9Sstevel@tonic-gate 	int			len, err;
32417c478bd9Sstevel@tonic-gate 	uint32_t		addrcells;
32427c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
32437c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
32447c478bd9Sstevel@tonic-gate 
32457c478bd9Sstevel@tonic-gate 	/*
32467c478bd9Sstevel@tonic-gate 	 * Get #address-cells property.  If not present, use default value.
32477c478bd9Sstevel@tonic-gate 	 */
32487c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(nodeh, OBP_PROP_ADDRESS_CELLS, &proph);
32497c478bd9Sstevel@tonic-gate 	if (err == PICL_SUCCESS)
32507c478bd9Sstevel@tonic-gate 		err = ptree_get_propinfo(proph, &pinfo);
32517c478bd9Sstevel@tonic-gate 
32527c478bd9Sstevel@tonic-gate 	len = pinfo.piclinfo.size;
32537c478bd9Sstevel@tonic-gate 	if (err == PICL_SUCCESS && len >= sizeof (uint8_t) &&
32547c478bd9Sstevel@tonic-gate 	    len <= sizeof (addrcells)) {
32557c478bd9Sstevel@tonic-gate 		err = ptree_get_propval(proph, &addrcells, len);
32567c478bd9Sstevel@tonic-gate 		if (err == PICL_SUCCESS) {
32577c478bd9Sstevel@tonic-gate 			if (len == sizeof (uint8_t))
32587c478bd9Sstevel@tonic-gate 				addrcells = *(uint8_t *)&addrcells;
32597c478bd9Sstevel@tonic-gate 			else if (len == sizeof (uint16_t))
32607c478bd9Sstevel@tonic-gate 				addrcells = *(uint16_t *)&addrcells;
32617c478bd9Sstevel@tonic-gate 		} else
32627c478bd9Sstevel@tonic-gate 			addrcells = DEFAULT_ADDRESS_CELLS;
32637c478bd9Sstevel@tonic-gate 	} else
32647c478bd9Sstevel@tonic-gate 		addrcells = DEFAULT_ADDRESS_CELLS;
32657c478bd9Sstevel@tonic-gate 
32667c478bd9Sstevel@tonic-gate 	return (addrcells);
32677c478bd9Sstevel@tonic-gate }
32687c478bd9Sstevel@tonic-gate 
32697c478bd9Sstevel@tonic-gate /*
32707c478bd9Sstevel@tonic-gate  * Get UnitAddress mapping entry for a node
32717c478bd9Sstevel@tonic-gate  */
32727c478bd9Sstevel@tonic-gate static unitaddr_map_t *
32737c478bd9Sstevel@tonic-gate get_unitaddr_mapping(picl_nodehdl_t nodeh)
32747c478bd9Sstevel@tonic-gate {
32757c478bd9Sstevel@tonic-gate 	int		err;
32767c478bd9Sstevel@tonic-gate 	unitaddr_map_t	*uamap;
32777c478bd9Sstevel@tonic-gate 	char		clname[PICL_CLASSNAMELEN_MAX];
32787c478bd9Sstevel@tonic-gate 
32797c478bd9Sstevel@tonic-gate 	/*
32807c478bd9Sstevel@tonic-gate 	 * Get my classname and locate a function to translate "reg" prop
32817c478bd9Sstevel@tonic-gate 	 * into "UnitAddress" prop for my children.
32827c478bd9Sstevel@tonic-gate 	 */
32837c478bd9Sstevel@tonic-gate 	err = ptree_get_propval_by_name(nodeh, PICL_PROP_CLASSNAME, clname,
32847c478bd9Sstevel@tonic-gate 	    sizeof (clname));
32857c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
32867c478bd9Sstevel@tonic-gate 		(void) strcpy(clname, "");	/* NULL class name */
32877c478bd9Sstevel@tonic-gate 
32887c478bd9Sstevel@tonic-gate 	for (uamap = &unitaddr_map_table[0]; uamap->class != NULL; uamap++)
32897c478bd9Sstevel@tonic-gate 		if (strcmp(clname, uamap->class) == 0)
32907c478bd9Sstevel@tonic-gate 			break;
32917c478bd9Sstevel@tonic-gate 
32927c478bd9Sstevel@tonic-gate 	return (uamap);
32937c478bd9Sstevel@tonic-gate }
32947c478bd9Sstevel@tonic-gate 
32957c478bd9Sstevel@tonic-gate /*
32967c478bd9Sstevel@tonic-gate  * Add UnitAddress property to the specified node
32977c478bd9Sstevel@tonic-gate  */
32987c478bd9Sstevel@tonic-gate static int
32997c478bd9Sstevel@tonic-gate add_unitaddr_prop(picl_nodehdl_t nodeh, unitaddr_map_t *uamap, uint_t addrcells)
33007c478bd9Sstevel@tonic-gate {
33017c478bd9Sstevel@tonic-gate 	int			regproplen, err;
33027c478bd9Sstevel@tonic-gate 	uint32_t		*regbuf;
33037c478bd9Sstevel@tonic-gate 	picl_prophdl_t		regh;
33047c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
33057c478bd9Sstevel@tonic-gate 	char			unitaddr[MAX_UNIT_ADDRESS_LEN];
33067c478bd9Sstevel@tonic-gate 
33077c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(nodeh, OBP_REG, &regh);
33087c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
33097c478bd9Sstevel@tonic-gate 		return (err);
33107c478bd9Sstevel@tonic-gate 
33117c478bd9Sstevel@tonic-gate 	err = ptree_get_propinfo(regh, &pinfo);
33127c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
33137c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33147c478bd9Sstevel@tonic-gate 
33157c478bd9Sstevel@tonic-gate 	if (pinfo.piclinfo.size < (addrcells * sizeof (uint32_t)))
33167c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33177c478bd9Sstevel@tonic-gate 
33187c478bd9Sstevel@tonic-gate 	regproplen = pinfo.piclinfo.size;
33197c478bd9Sstevel@tonic-gate 	regbuf = alloca(regproplen);
33207c478bd9Sstevel@tonic-gate 	if (regbuf == NULL)
33217c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33227c478bd9Sstevel@tonic-gate 
33237c478bd9Sstevel@tonic-gate 	err = ptree_get_propval(regh, regbuf, regproplen);
33247c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS || uamap->func == NULL ||
33257c478bd9Sstevel@tonic-gate 	    (uamap->addrcellcnt && uamap->addrcellcnt != addrcells) ||
33267c478bd9Sstevel@tonic-gate 	    (uamap->func)(unitaddr, sizeof (unitaddr), regbuf,
33277c478bd9Sstevel@tonic-gate 	    addrcells) != 0) {
33287c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33297c478bd9Sstevel@tonic-gate 	}
33307c478bd9Sstevel@tonic-gate 
33317c478bd9Sstevel@tonic-gate 	err = ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
33327c478bd9Sstevel@tonic-gate 	    PICL_PTYPE_CHARSTRING, PICL_READ, strlen(unitaddr)+1,
33337c478bd9Sstevel@tonic-gate 	    PICL_PROP_UNIT_ADDRESS, NULL, NULL);
33347c478bd9Sstevel@tonic-gate 	if (err == PICL_SUCCESS)
33357c478bd9Sstevel@tonic-gate 		err = ptree_create_and_add_prop(nodeh, &pinfo, unitaddr, NULL);
33367c478bd9Sstevel@tonic-gate 
33377c478bd9Sstevel@tonic-gate 	return (err);
33387c478bd9Sstevel@tonic-gate }
33397c478bd9Sstevel@tonic-gate 
33407c478bd9Sstevel@tonic-gate /*
33417c478bd9Sstevel@tonic-gate  * work out UnitAddress property of the specified node
33427c478bd9Sstevel@tonic-gate  */
33437c478bd9Sstevel@tonic-gate static int
33447c478bd9Sstevel@tonic-gate get_unitaddr(picl_nodehdl_t parh, picl_nodehdl_t nodeh, char *unitaddr,
33457c478bd9Sstevel@tonic-gate     size_t ualen)
33467c478bd9Sstevel@tonic-gate {
33477c478bd9Sstevel@tonic-gate 	int			regproplen, err;
33487c478bd9Sstevel@tonic-gate 	uint32_t		*regbuf;
33497c478bd9Sstevel@tonic-gate 	picl_prophdl_t		regh;
33507c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
33517c478bd9Sstevel@tonic-gate 	unitaddr_map_t		*uamap;
33527c478bd9Sstevel@tonic-gate 	uint32_t		addrcells;
33537c478bd9Sstevel@tonic-gate 
33547c478bd9Sstevel@tonic-gate 	addrcells = get_addrcells_prop(parh);
33557c478bd9Sstevel@tonic-gate 	uamap = get_unitaddr_mapping(parh);
33567c478bd9Sstevel@tonic-gate 
33577c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(nodeh, OBP_REG, &regh);
33587c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
33597c478bd9Sstevel@tonic-gate 		return (err);
33607c478bd9Sstevel@tonic-gate 
33617c478bd9Sstevel@tonic-gate 	err = ptree_get_propinfo(regh, &pinfo);
33627c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
33637c478bd9Sstevel@tonic-gate 		return (err);
33647c478bd9Sstevel@tonic-gate 
33657c478bd9Sstevel@tonic-gate 	if (pinfo.piclinfo.size < (addrcells * sizeof (uint32_t)))
33667c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33677c478bd9Sstevel@tonic-gate 
33687c478bd9Sstevel@tonic-gate 	regproplen = pinfo.piclinfo.size;
33697c478bd9Sstevel@tonic-gate 	regbuf = alloca(regproplen);
33707c478bd9Sstevel@tonic-gate 	if (regbuf == NULL)
33717c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33727c478bd9Sstevel@tonic-gate 
33737c478bd9Sstevel@tonic-gate 	err = ptree_get_propval(regh, regbuf, regproplen);
33747c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS || uamap->func == NULL ||
33757c478bd9Sstevel@tonic-gate 	    (uamap->addrcellcnt && uamap->addrcellcnt != addrcells) ||
33767c478bd9Sstevel@tonic-gate 	    (uamap->func)(unitaddr, ualen, regbuf, addrcells) != 0) {
33777c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
33787c478bd9Sstevel@tonic-gate 	}
33797c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
33807c478bd9Sstevel@tonic-gate }
33817c478bd9Sstevel@tonic-gate 
33827c478bd9Sstevel@tonic-gate /*
33837c478bd9Sstevel@tonic-gate  * Add UnitAddress property to all children of the specified node
33847c478bd9Sstevel@tonic-gate  */
33857c478bd9Sstevel@tonic-gate static int
33867c478bd9Sstevel@tonic-gate add_unitaddr_prop_to_subtree(picl_nodehdl_t nodeh)
33877c478bd9Sstevel@tonic-gate {
33887c478bd9Sstevel@tonic-gate 	int			err;
33897c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		chdh;
33907c478bd9Sstevel@tonic-gate 	unitaddr_map_t		*uamap;
33917c478bd9Sstevel@tonic-gate 	uint32_t		addrcells;
33927c478bd9Sstevel@tonic-gate 
33937c478bd9Sstevel@tonic-gate 	/*
33947c478bd9Sstevel@tonic-gate 	 * Get #address-cells and unit address mapping entry for my
33957c478bd9Sstevel@tonic-gate 	 * node's class
33967c478bd9Sstevel@tonic-gate 	 */
33977c478bd9Sstevel@tonic-gate 	addrcells = get_addrcells_prop(nodeh);
33987c478bd9Sstevel@tonic-gate 	uamap = get_unitaddr_mapping(nodeh);
33997c478bd9Sstevel@tonic-gate 
34007c478bd9Sstevel@tonic-gate 	/*
34017c478bd9Sstevel@tonic-gate 	 * Add UnitAddress property to my children and their subtree
34027c478bd9Sstevel@tonic-gate 	 */
34037c478bd9Sstevel@tonic-gate 	err = ptree_get_propval_by_name(nodeh, PICL_PROP_CHILD, &chdh,
34047c478bd9Sstevel@tonic-gate 	    sizeof (picl_nodehdl_t));
34057c478bd9Sstevel@tonic-gate 
34067c478bd9Sstevel@tonic-gate 	while (err == PICL_SUCCESS) {
34077c478bd9Sstevel@tonic-gate 		(void) add_unitaddr_prop(chdh, uamap, addrcells);
34087c478bd9Sstevel@tonic-gate 		(void) add_unitaddr_prop_to_subtree(chdh);
34097c478bd9Sstevel@tonic-gate 
34107c478bd9Sstevel@tonic-gate 		err = ptree_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
34117c478bd9Sstevel@tonic-gate 		    sizeof (picl_nodehdl_t));
34127c478bd9Sstevel@tonic-gate 	}
34137c478bd9Sstevel@tonic-gate 
34147c478bd9Sstevel@tonic-gate 	return (PICL_SUCCESS);
34157c478bd9Sstevel@tonic-gate }
34167c478bd9Sstevel@tonic-gate 
34177c478bd9Sstevel@tonic-gate static int
34187c478bd9Sstevel@tonic-gate update_memory_size_prop(picl_nodehdl_t plafh)
34197c478bd9Sstevel@tonic-gate {
34207c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		memh;
34217c478bd9Sstevel@tonic-gate 	picl_prophdl_t		proph;
34227c478bd9Sstevel@tonic-gate 	ptree_propinfo_t	pinfo;
34237c478bd9Sstevel@tonic-gate 	int			err, nspecs, snum, pval;
34247c478bd9Sstevel@tonic-gate 	char			*regbuf;
34257c478bd9Sstevel@tonic-gate 	memspecs_t		*mspecs;
34267c478bd9Sstevel@tonic-gate 	uint64_t		memsize;
34277c478bd9Sstevel@tonic-gate 
34287c478bd9Sstevel@tonic-gate 	/*
34297c478bd9Sstevel@tonic-gate 	 * check if the #size-cells of the platform node is 2
34307c478bd9Sstevel@tonic-gate 	 */
34317c478bd9Sstevel@tonic-gate 	err = ptree_get_propval_by_name(plafh, OBP_PROP_SIZE_CELLS, &pval,
34325e3e415aSfw 	    sizeof (pval));
34337c478bd9Sstevel@tonic-gate 
34347c478bd9Sstevel@tonic-gate 	if (err == PICL_PROPNOTFOUND)
34357c478bd9Sstevel@tonic-gate 		pval = SUPPORTED_NUM_CELL_SIZE;
34367c478bd9Sstevel@tonic-gate 	else if (err != PICL_SUCCESS)
34377c478bd9Sstevel@tonic-gate 		return (err);
34387c478bd9Sstevel@tonic-gate 
34397c478bd9Sstevel@tonic-gate 	/*
34407c478bd9Sstevel@tonic-gate 	 * don't know how to handle other vals
34417c478bd9Sstevel@tonic-gate 	 */
34427c478bd9Sstevel@tonic-gate 	if (pval != SUPPORTED_NUM_CELL_SIZE)
34437c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
34447c478bd9Sstevel@tonic-gate 
34457c478bd9Sstevel@tonic-gate 	err = ptree_get_node_by_path(MEMORY_PATH, &memh);
34467c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
34477c478bd9Sstevel@tonic-gate 		return (err);
34487c478bd9Sstevel@tonic-gate 
34497c478bd9Sstevel@tonic-gate 	/*
34507c478bd9Sstevel@tonic-gate 	 * Get the REG property to calculate the size of memory
34517c478bd9Sstevel@tonic-gate 	 */
34527c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(memh, OBP_REG, &proph);
34537c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
34547c478bd9Sstevel@tonic-gate 		return (err);
34557c478bd9Sstevel@tonic-gate 
34567c478bd9Sstevel@tonic-gate 	err = ptree_get_propinfo(proph, &pinfo);
34577c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
34587c478bd9Sstevel@tonic-gate 		return (err);
34597c478bd9Sstevel@tonic-gate 
34607c478bd9Sstevel@tonic-gate 	regbuf = alloca(pinfo.piclinfo.size);
34617c478bd9Sstevel@tonic-gate 	if (regbuf == NULL)
34627c478bd9Sstevel@tonic-gate 		return (PICL_FAILURE);
34637c478bd9Sstevel@tonic-gate 
34647c478bd9Sstevel@tonic-gate 	err = ptree_get_propval(proph, regbuf, pinfo.piclinfo.size);
34657c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
34667c478bd9Sstevel@tonic-gate 		return (err);
34677c478bd9Sstevel@tonic-gate 
34687c478bd9Sstevel@tonic-gate 	mspecs = (memspecs_t *)regbuf;
34697c478bd9Sstevel@tonic-gate 	nspecs = pinfo.piclinfo.size / sizeof (memspecs_t);
34707c478bd9Sstevel@tonic-gate 
34717c478bd9Sstevel@tonic-gate 	memsize = 0;
34727c478bd9Sstevel@tonic-gate 	for (snum = 0; snum < nspecs; ++snum)
34737c478bd9Sstevel@tonic-gate 		memsize += mspecs[snum].size;
34747c478bd9Sstevel@tonic-gate 
34757c478bd9Sstevel@tonic-gate 	err = ptree_get_prop_by_name(memh, PICL_PROP_SIZE, &proph);
34767c478bd9Sstevel@tonic-gate 	if (err == PICL_SUCCESS) {
34777c478bd9Sstevel@tonic-gate 		err = ptree_update_propval(proph, &memsize, sizeof (memsize));
34787c478bd9Sstevel@tonic-gate 		return (err);
34797c478bd9Sstevel@tonic-gate 	}
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate 	/*
34827c478bd9Sstevel@tonic-gate 	 * Add the size property
34837c478bd9Sstevel@tonic-gate 	 */
34847c478bd9Sstevel@tonic-gate 	(void) ptree_init_propinfo(&pinfo, PTREE_PROPINFO_VERSION,
34855e3e415aSfw 	    PICL_PTYPE_UNSIGNED_INT, PICL_READ, sizeof (memsize),
34865e3e415aSfw 	    PICL_PROP_SIZE, NULL, NULL);
34877c478bd9Sstevel@tonic-gate 	err = ptree_create_and_add_prop(memh, &pinfo, &memsize, NULL);
34887c478bd9Sstevel@tonic-gate 	return (err);
34897c478bd9Sstevel@tonic-gate }
34907c478bd9Sstevel@tonic-gate 
34917c478bd9Sstevel@tonic-gate /*
34927c478bd9Sstevel@tonic-gate  * This function is executed as part of .init when the plugin is
34937c478bd9Sstevel@tonic-gate  * dlopen()ed
34947c478bd9Sstevel@tonic-gate  */
34957c478bd9Sstevel@tonic-gate static void
34967c478bd9Sstevel@tonic-gate picldevtree_register(void)
34977c478bd9Sstevel@tonic-gate {
34987c478bd9Sstevel@tonic-gate 	if (getenv(SUNW_PICLDEVTREE_PLUGIN_DEBUG))
34997c478bd9Sstevel@tonic-gate 		picldevtree_debug = 1;
35007c478bd9Sstevel@tonic-gate 	(void) picld_plugin_register(&my_reg_info);
35017c478bd9Sstevel@tonic-gate }
35027c478bd9Sstevel@tonic-gate 
35037c478bd9Sstevel@tonic-gate /*
35047c478bd9Sstevel@tonic-gate  * This function is the init entry point of the plugin.
35057c478bd9Sstevel@tonic-gate  * It initializes the /platform tree based on libdevinfo
35067c478bd9Sstevel@tonic-gate  */
35077c478bd9Sstevel@tonic-gate static void
35087c478bd9Sstevel@tonic-gate picldevtree_init(void)
35097c478bd9Sstevel@tonic-gate {
35107c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	rhdl;
35117c478bd9Sstevel@tonic-gate 	int		err;
35127c478bd9Sstevel@tonic-gate 	struct utsname	utsname;
35137c478bd9Sstevel@tonic-gate 	picl_nodehdl_t	plafh;
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 	if (uname(&utsname) < 0)
35167c478bd9Sstevel@tonic-gate 		return;
35177c478bd9Sstevel@tonic-gate 
35187c478bd9Sstevel@tonic-gate 	(void) strcpy(mach_name, utsname.machine);
35197c478bd9Sstevel@tonic-gate 
35207c478bd9Sstevel@tonic-gate 	if (strcmp(mach_name, "sun4u") == 0) {
35217c478bd9Sstevel@tonic-gate 		builtin_map_ptr = sun4u_map;
35220d63ce2bSvenki 		builtin_map_size = sizeof (sun4u_map) / sizeof (builtin_map_t);
35230d63ce2bSvenki 	} else if (strcmp(mach_name, "sun4v") == 0) {
35240d63ce2bSvenki 		builtin_map_ptr = sun4u_map;
35257c478bd9Sstevel@tonic-gate 		builtin_map_size = sizeof (sun4u_map) / sizeof (builtin_map_t);
35267c478bd9Sstevel@tonic-gate 	} else if (strcmp(mach_name, "i86pc") == 0) {
35277c478bd9Sstevel@tonic-gate 		builtin_map_ptr = i86pc_map;
35287c478bd9Sstevel@tonic-gate 		builtin_map_size = sizeof (i86pc_map) / sizeof (builtin_map_t);
35297c478bd9Sstevel@tonic-gate 	} else {
35307c478bd9Sstevel@tonic-gate 		builtin_map_ptr = NULL;
35317c478bd9Sstevel@tonic-gate 		builtin_map_size = 0;
35327c478bd9Sstevel@tonic-gate 	}
35337c478bd9Sstevel@tonic-gate 
35347c478bd9Sstevel@tonic-gate 	err = ptree_get_root(&rhdl);
35357c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS) {
35367c478bd9Sstevel@tonic-gate 		syslog(LOG_ERR, DEVINFO_PLUGIN_INIT_FAILED);
35377c478bd9Sstevel@tonic-gate 		return;
35387c478bd9Sstevel@tonic-gate 	}
35397c478bd9Sstevel@tonic-gate 
35407c478bd9Sstevel@tonic-gate 	process_devtree_conf_file();
35417c478bd9Sstevel@tonic-gate 
35427c478bd9Sstevel@tonic-gate 	if (libdevinfo_init(rhdl) != PICL_SUCCESS) {
35437c478bd9Sstevel@tonic-gate 		syslog(LOG_ERR, DEVINFO_PLUGIN_INIT_FAILED);
35447c478bd9Sstevel@tonic-gate 		return;
35457c478bd9Sstevel@tonic-gate 	}
35467c478bd9Sstevel@tonic-gate 
35477c478bd9Sstevel@tonic-gate 	err = ptree_get_node_by_path(PLATFORM_PATH, &plafh);
35487c478bd9Sstevel@tonic-gate 	if (err != PICL_SUCCESS)
35497c478bd9Sstevel@tonic-gate 		return;
35507c478bd9Sstevel@tonic-gate 
35517c478bd9Sstevel@tonic-gate 	(void) add_unitaddr_prop_to_subtree(plafh);
35527c478bd9Sstevel@tonic-gate 
35537c478bd9Sstevel@tonic-gate 	add_asr_nodes();
35547c478bd9Sstevel@tonic-gate 
35557c478bd9Sstevel@tonic-gate 	(void) update_memory_size_prop(plafh);
35567c478bd9Sstevel@tonic-gate 
35577c478bd9Sstevel@tonic-gate 	(void) setup_cpus(plafh);
35587c478bd9Sstevel@tonic-gate 
35597c478bd9Sstevel@tonic-gate 	(void) add_ffb_config_info(plafh);
35607c478bd9Sstevel@tonic-gate 
35617c478bd9Sstevel@tonic-gate 	(void) add_platform_info(plafh);
35627c478bd9Sstevel@tonic-gate 
35637ef4fcfbSvenki 	set_pci_pciex_deviceid(plafh);
35647c478bd9Sstevel@tonic-gate 
35657c478bd9Sstevel@tonic-gate 	(void) set_sbus_slot(plafh);
35667c478bd9Sstevel@tonic-gate 
35677c478bd9Sstevel@tonic-gate 	(void) ptree_register_handler(PICLEVENT_SYSEVENT_DEVICE_ADDED,
35687c478bd9Sstevel@tonic-gate 	    picldevtree_evhandler, NULL);
35697c478bd9Sstevel@tonic-gate 	(void) ptree_register_handler(PICLEVENT_SYSEVENT_DEVICE_REMOVED,
35707c478bd9Sstevel@tonic-gate 	    picldevtree_evhandler, NULL);
35715e3e415aSfw 	(void) ptree_register_handler(PICLEVENT_CPU_STATE_CHANGE,
35725e3e415aSfw 	    picldevtree_evhandler, NULL);
3573f4730842STrevor Thompson 	(void) ptree_register_handler(PICLEVENT_DR_AP_STATE_CHANGE,
3574f4730842STrevor Thompson 	    picldevtree_evhandler, NULL);
35757c478bd9Sstevel@tonic-gate }
35767c478bd9Sstevel@tonic-gate 
35777c478bd9Sstevel@tonic-gate /*
35787c478bd9Sstevel@tonic-gate  * This function is the fini entry point of the plugin
35797c478bd9Sstevel@tonic-gate  */
35807c478bd9Sstevel@tonic-gate static void
35817c478bd9Sstevel@tonic-gate picldevtree_fini(void)
35827c478bd9Sstevel@tonic-gate {
35837c478bd9Sstevel@tonic-gate 	/* First unregister the event handlers */
35847c478bd9Sstevel@tonic-gate 	(void) ptree_unregister_handler(PICLEVENT_SYSEVENT_DEVICE_ADDED,
35857c478bd9Sstevel@tonic-gate 	    picldevtree_evhandler, NULL);
35867c478bd9Sstevel@tonic-gate 	(void) ptree_unregister_handler(PICLEVENT_SYSEVENT_DEVICE_REMOVED,
35877c478bd9Sstevel@tonic-gate 	    picldevtree_evhandler, NULL);
35885e3e415aSfw 	(void) ptree_unregister_handler(PICLEVENT_CPU_STATE_CHANGE,
35895e3e415aSfw 	    picldevtree_evhandler, NULL);
3590f4730842STrevor Thompson 	(void) ptree_unregister_handler(PICLEVENT_DR_AP_STATE_CHANGE,
3591f4730842STrevor Thompson 	    picldevtree_evhandler, NULL);
35927c478bd9Sstevel@tonic-gate 
35937c478bd9Sstevel@tonic-gate 	conf_name_class_map = free_conf_entries(conf_name_class_map);
35947c478bd9Sstevel@tonic-gate }
35957c478bd9Sstevel@tonic-gate 
35967c478bd9Sstevel@tonic-gate /*
35977c478bd9Sstevel@tonic-gate  * This function is the event handler of this plug-in.
35987c478bd9Sstevel@tonic-gate  *
35997c478bd9Sstevel@tonic-gate  * It processes the following events:
36007c478bd9Sstevel@tonic-gate  *
36017c478bd9Sstevel@tonic-gate  *	PICLEVENT_SYSEVENT_DEVICE_ADDED
36027c478bd9Sstevel@tonic-gate  *	PICLEVENT_SYSEVENT_DEVICE_REMOVED
36035e3e415aSfw  *	PICLEVENT_CPU_STATE_CHANGE
3604f4730842STrevor Thompson  *	PICLEVENT_DR_AP_STATE_CHANGE
36057c478bd9Sstevel@tonic-gate  */
36067c478bd9Sstevel@tonic-gate /* ARGSUSED */
36077c478bd9Sstevel@tonic-gate static void
36087c478bd9Sstevel@tonic-gate picldevtree_evhandler(const char *ename, const void *earg, size_t size,
36097c478bd9Sstevel@tonic-gate     void *cookie)
36107c478bd9Sstevel@tonic-gate {
36117c478bd9Sstevel@tonic-gate 	char			*devfs_path;
36127c478bd9Sstevel@tonic-gate 	char			ptreepath[PATH_MAX];
36137c478bd9Sstevel@tonic-gate 	char			dipath[PATH_MAX];
36147c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		plafh;
36157c478bd9Sstevel@tonic-gate 	picl_nodehdl_t		nodeh;
36167c478bd9Sstevel@tonic-gate 	nvlist_t		*nvlp;
36177c478bd9Sstevel@tonic-gate 
3618f4730842STrevor Thompson 	if ((earg == NULL) ||
3619f4730842STrevor Thompson 	    (ptree_get_node_by_path(PLATFORM_PATH, &plafh) != PICL_SUCCESS))
36207c478bd9Sstevel@tonic-gate 		return;
36217c478bd9Sstevel@tonic-gate 
3622f4730842STrevor Thompson 	if (strcmp(ename, PICLEVENT_DR_AP_STATE_CHANGE) == 0) {
3623f4730842STrevor Thompson 		(void) setup_cpus(plafh);
3624f4730842STrevor Thompson 		if (picldevtree_debug > 1)
3625f4730842STrevor Thompson 			syslog(LOG_INFO, "picldevtree: event handler done\n");
3626f4730842STrevor Thompson 		return;
3627f4730842STrevor Thompson 	}
3628f4730842STrevor Thompson 
36297c478bd9Sstevel@tonic-gate 	nvlp = NULL;
3630f4730842STrevor Thompson 	if (nvlist_unpack((char *)earg, size, &nvlp, NULL) ||
36317c478bd9Sstevel@tonic-gate 	    nvlist_lookup_string(nvlp, PICLEVENTARG_DEVFS_PATH, &devfs_path) ||
36327c478bd9Sstevel@tonic-gate 	    strlen(devfs_path) > (PATH_MAX - sizeof (PLATFORM_PATH))) {
36337c478bd9Sstevel@tonic-gate 		syslog(LOG_INFO, PICL_EVENT_DROPPED, ename);
36347c478bd9Sstevel@tonic-gate 		if (nvlp)
36357c478bd9Sstevel@tonic-gate 			nvlist_free(nvlp);
36367c478bd9Sstevel@tonic-gate 		return;
36377c478bd9Sstevel@tonic-gate 	}
36387c478bd9Sstevel@tonic-gate 
36397c478bd9Sstevel@tonic-gate 	(void) strlcpy(ptreepath, PLATFORM_PATH, PATH_MAX);
36407c478bd9Sstevel@tonic-gate 	(void) strlcat(ptreepath, devfs_path, PATH_MAX);
36417c478bd9Sstevel@tonic-gate 	(void) strlcpy(dipath, devfs_path, PATH_MAX);
36427c478bd9Sstevel@tonic-gate 	nvlist_free(nvlp);
36437c478bd9Sstevel@tonic-gate 
36447c478bd9Sstevel@tonic-gate 	if (picldevtree_debug)
36457c478bd9Sstevel@tonic-gate 		syslog(LOG_INFO, "picldevtree: event handler invoked ename:%s "
36467c478bd9Sstevel@tonic-gate 		    "ptreepath:%s\n", ename, ptreepath);
36477c478bd9Sstevel@tonic-gate 
36485e3e415aSfw 	if (strcmp(ename, PICLEVENT_CPU_STATE_CHANGE) == 0) {
36495e3e415aSfw 		goto done;
36505e3e415aSfw 	}
36517c478bd9Sstevel@tonic-gate 	if (strcmp(ename, PICLEVENT_SYSEVENT_DEVICE_ADDED) == 0) {
36527c478bd9Sstevel@tonic-gate 		di_node_t		devnode;
36537c478bd9Sstevel@tonic-gate 		char		*strp;
36547c478bd9Sstevel@tonic-gate 		picl_nodehdl_t	parh;
36557c478bd9Sstevel@tonic-gate 		char		nodeclass[PICL_CLASSNAMELEN_MAX];
36567c478bd9Sstevel@tonic-gate 		char		*nodename;
36577c478bd9Sstevel@tonic-gate 		int		err;
36587c478bd9Sstevel@tonic-gate 
36597c478bd9Sstevel@tonic-gate 		/* If the node already exist, then nothing else to do here */
36607c478bd9Sstevel@tonic-gate 		if (ptree_get_node_by_path(ptreepath, &nodeh) == PICL_SUCCESS)
36617c478bd9Sstevel@tonic-gate 			return;
36627c478bd9Sstevel@tonic-gate 
36637c478bd9Sstevel@tonic-gate 		/* Skip if unable to find parent PICL node handle */
36647c478bd9Sstevel@tonic-gate 		parh = plafh;
36657c478bd9Sstevel@tonic-gate 		if (((strp = strrchr(ptreepath, '/')) != NULL) &&
36667c478bd9Sstevel@tonic-gate 		    (strp != strchr(ptreepath, '/'))) {
36677c478bd9Sstevel@tonic-gate 			*strp = '\0';
36687c478bd9Sstevel@tonic-gate 			if (ptree_get_node_by_path(ptreepath, &parh) !=
36697c478bd9Sstevel@tonic-gate 			    PICL_SUCCESS)
36707c478bd9Sstevel@tonic-gate 				return;
36717c478bd9Sstevel@tonic-gate 		}
36727c478bd9Sstevel@tonic-gate 
36737c478bd9Sstevel@tonic-gate 		/*
36747c478bd9Sstevel@tonic-gate 		 * If parent is the root node
36757c478bd9Sstevel@tonic-gate 		 */
36767c478bd9Sstevel@tonic-gate 		if (parh == plafh) {
36777c478bd9Sstevel@tonic-gate 			ph = di_prom_init();
36787c478bd9Sstevel@tonic-gate 			devnode = di_init(dipath, DINFOCPYALL);
36797c478bd9Sstevel@tonic-gate 			if (devnode == DI_NODE_NIL) {
36807c478bd9Sstevel@tonic-gate 				if (ph != NULL) {
36817c478bd9Sstevel@tonic-gate 					di_prom_fini(ph);
36827c478bd9Sstevel@tonic-gate 					ph = NULL;
36837c478bd9Sstevel@tonic-gate 				}
36847c478bd9Sstevel@tonic-gate 				return;
36857c478bd9Sstevel@tonic-gate 			}
36867c478bd9Sstevel@tonic-gate 			nodename = di_node_name(devnode);
36877c478bd9Sstevel@tonic-gate 			if (nodename == NULL) {
36887c478bd9Sstevel@tonic-gate 				di_fini(devnode);
36897c478bd9Sstevel@tonic-gate 				if (ph != NULL) {
36907c478bd9Sstevel@tonic-gate 					di_prom_fini(ph);
36917c478bd9Sstevel@tonic-gate 					ph = NULL;
36927c478bd9Sstevel@tonic-gate 				}
36937c478bd9Sstevel@tonic-gate 				return;
36947c478bd9Sstevel@tonic-gate 			}
36957c478bd9Sstevel@tonic-gate 
36967c478bd9Sstevel@tonic-gate 			err = get_node_class(nodeclass, devnode, nodename);
36977c478bd9Sstevel@tonic-gate 			if (err < 0) {
36987c478bd9Sstevel@tonic-gate 				di_fini(devnode);
36997c478bd9Sstevel@tonic-gate 				if (ph != NULL) {
37007c478bd9Sstevel@tonic-gate 					di_prom_fini(ph);
37017c478bd9Sstevel@tonic-gate 					ph = NULL;
37027c478bd9Sstevel@tonic-gate 				}
37037c478bd9Sstevel@tonic-gate 				return;
37047c478bd9Sstevel@tonic-gate 			}
37057c478bd9Sstevel@tonic-gate 			err = construct_devtype_node(plafh, nodename,
37067c478bd9Sstevel@tonic-gate 			    nodeclass, devnode, &nodeh);
37077c478bd9Sstevel@tonic-gate 			if (err != PICL_SUCCESS) {
37087c478bd9Sstevel@tonic-gate 				di_fini(devnode);
37097c478bd9Sstevel@tonic-gate 				if (ph != NULL) {
37107c478bd9Sstevel@tonic-gate 					di_prom_fini(ph);
37117c478bd9Sstevel@tonic-gate 					ph = NULL;
37127c478bd9Sstevel@tonic-gate 				}
37137c478bd9Sstevel@tonic-gate 				return;
37147c478bd9Sstevel@tonic-gate 			}
37157c478bd9Sstevel@tonic-gate 			(void) update_subtree(nodeh, devnode);
37167c478bd9Sstevel@tonic-gate 			(void) add_unitaddr_prop_to_subtree(nodeh);
37177c478bd9Sstevel@tonic-gate 			if (ph != NULL) {
37187c478bd9Sstevel@tonic-gate 				di_prom_fini(ph);
37197c478bd9Sstevel@tonic-gate 				ph = NULL;
37207c478bd9Sstevel@tonic-gate 			}
37217c478bd9Sstevel@tonic-gate 			di_fini(devnode);
37227c478bd9Sstevel@tonic-gate 			goto done;
37237c478bd9Sstevel@tonic-gate 		}
37247c478bd9Sstevel@tonic-gate 
37257c478bd9Sstevel@tonic-gate 		/* kludge ... try without bus-addr first */
37267c478bd9Sstevel@tonic-gate 		if ((strp = strrchr(dipath, '@')) != NULL) {
37277c478bd9Sstevel@tonic-gate 			char *p;
37287c478bd9Sstevel@tonic-gate 
37297c478bd9Sstevel@tonic-gate 			p = strrchr(dipath, '/');
37307c478bd9Sstevel@tonic-gate 			if (p != NULL && strp > p) {
37317c478bd9Sstevel@tonic-gate 				*strp = '\0';
37327c478bd9Sstevel@tonic-gate 				devnode = di_init(dipath, DINFOCPYALL);
37337c478bd9Sstevel@tonic-gate 				if (devnode != DI_NODE_NIL)
37347c478bd9Sstevel@tonic-gate 					di_fini(devnode);
37357c478bd9Sstevel@tonic-gate 				*strp = '@';
37367c478bd9Sstevel@tonic-gate 			}
37377c478bd9Sstevel@tonic-gate 		}
37387c478bd9Sstevel@tonic-gate 		/* Get parent devnode */
37397c478bd9Sstevel@tonic-gate 		if ((strp = strrchr(dipath, '/')) != NULL)
37407c478bd9Sstevel@tonic-gate 			*++strp = '\0';
37417c478bd9Sstevel@tonic-gate 		devnode = di_init(dipath, DINFOCPYALL);
37427c478bd9Sstevel@tonic-gate 		if (devnode == DI_NODE_NIL)
37437c478bd9Sstevel@tonic-gate 			return;
37447c478bd9Sstevel@tonic-gate 		ph = di_prom_init();
37457c478bd9Sstevel@tonic-gate 		(void) update_subtree(parh, devnode);
37467c478bd9Sstevel@tonic-gate 		(void) add_unitaddr_prop_to_subtree(parh);
37477c478bd9Sstevel@tonic-gate 		if (ph) {
37487c478bd9Sstevel@tonic-gate 			di_prom_fini(ph);
37497c478bd9Sstevel@tonic-gate 			ph = NULL;
37507c478bd9Sstevel@tonic-gate 		}
37517c478bd9Sstevel@tonic-gate 		di_fini(devnode);
37527c478bd9Sstevel@tonic-gate 	} else if (strcmp(ename, PICLEVENT_SYSEVENT_DEVICE_REMOVED) == 0) {
37537c478bd9Sstevel@tonic-gate 		char			delclass[PICL_CLASSNAMELEN_MAX];
37547c478bd9Sstevel@tonic-gate 		char		*strp;
37557c478bd9Sstevel@tonic-gate 
37567c478bd9Sstevel@tonic-gate 		/*
37577c478bd9Sstevel@tonic-gate 		 * if final element of path doesn't have a unit address
37587c478bd9Sstevel@tonic-gate 		 * then it is not uniquely identifiable - cannot remove
37597c478bd9Sstevel@tonic-gate 		 */
37607c478bd9Sstevel@tonic-gate 		if (((strp = strrchr(ptreepath, '/')) != NULL) &&
37617c478bd9Sstevel@tonic-gate 		    strchr(strp, '@') == NULL)
37627c478bd9Sstevel@tonic-gate 			return;
37637c478bd9Sstevel@tonic-gate 
37647c478bd9Sstevel@tonic-gate 		/* skip if can't find the node */
37657c478bd9Sstevel@tonic-gate 		if (ptree_get_node_by_path(ptreepath, &nodeh) != PICL_SUCCESS)
37667c478bd9Sstevel@tonic-gate 			return;
37677c478bd9Sstevel@tonic-gate 
37687c478bd9Sstevel@tonic-gate 		if (ptree_delete_node(nodeh) != PICL_SUCCESS)
37697c478bd9Sstevel@tonic-gate 			return;
37707c478bd9Sstevel@tonic-gate 
37717c478bd9Sstevel@tonic-gate 		if (picldevtree_debug)
37727c478bd9Sstevel@tonic-gate 			syslog(LOG_INFO,
37737c478bd9Sstevel@tonic-gate 			    "picldevtree: deleted node nodeh:%llx\n", nodeh);
37747c478bd9Sstevel@tonic-gate 		if ((ptree_get_propval_by_name(nodeh,
37757c478bd9Sstevel@tonic-gate 		    PICL_PROP_CLASSNAME, delclass, PICL_CLASSNAMELEN_MAX) ==
37767c478bd9Sstevel@tonic-gate 		    PICL_SUCCESS) && IS_MC(delclass)) {
37777c478bd9Sstevel@tonic-gate 			if (post_mc_event(PICLEVENT_MC_REMOVED, nodeh) !=
37787c478bd9Sstevel@tonic-gate 			    PICL_SUCCESS)
37797c478bd9Sstevel@tonic-gate 				syslog(LOG_WARNING, PICL_EVENT_DROPPED,
37807c478bd9Sstevel@tonic-gate 				    PICLEVENT_MC_REMOVED);
37817c478bd9Sstevel@tonic-gate 		} else
37827c478bd9Sstevel@tonic-gate 			(void) ptree_destroy_node(nodeh);
37837c478bd9Sstevel@tonic-gate 	}
37847c478bd9Sstevel@tonic-gate done:
37857c478bd9Sstevel@tonic-gate 	(void) setup_cpus(plafh);
37867c478bd9Sstevel@tonic-gate 	(void) add_ffb_config_info(plafh);
37877ef4fcfbSvenki 	set_pci_pciex_deviceid(plafh);
37887c478bd9Sstevel@tonic-gate 	(void) set_sbus_slot(plafh);
37897c478bd9Sstevel@tonic-gate 	if (picldevtree_debug > 1)
37907c478bd9Sstevel@tonic-gate 		syslog(LOG_INFO, "picldevtree: event handler done\n");
37917c478bd9Sstevel@tonic-gate }
3792