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