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 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 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 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 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 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 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 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 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 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 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 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 670*ce41cfb3SToomas 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 700*ce41cfb3SToomas Soome free(proprow); 701*ce41cfb3SToomas 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 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; 716*ce41cfb3SToomas 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 728*ce41cfb3SToomas 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)) 734*ce41cfb3SToomas Soome rv = 1; /* prop match */ 735*ce41cfb3SToomas Soome else 736*ce41cfb3SToomas Soome rv = 0; 7377c478bd9Sstevel@tonic-gate 738*ce41cfb3SToomas Soome free(pvalbuf); 739*ce41cfb3SToomas 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 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 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 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') { 852*ce41cfb3SToomas Soome strdat = malloc(retval + 1); 853*ce41cfb3SToomas Soome if (strdat != NULL) { 854*ce41cfb3SToomas Soome (void) memcpy(strdat, pdata, retval); 855*ce41cfb3SToomas Soome strdat[retval] = '\0'; 856*ce41cfb3SToomas Soome retval++; 857*ce41cfb3SToomas Soome } 8587c478bd9Sstevel@tonic-gate } else { 859*ce41cfb3SToomas Soome strdat = malloc(retval); 860*ce41cfb3SToomas Soome if (strdat != NULL) 861*ce41cfb3SToomas Soome (void) memcpy(strdat, pdata, retval); 8627c478bd9Sstevel@tonic-gate } 863*ce41cfb3SToomas Soome if (strdat == NULL) 864*ce41cfb3SToomas 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); 873*ce41cfb3SToomas Soome if (err != PICL_SUCCESS) { 874*ce41cfb3SToomas Soome free(strdat); 8757c478bd9Sstevel@tonic-gate return (err); 876*ce41cfb3SToomas 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); 882*ce41cfb3SToomas Soome if (err != PICL_SUCCESS) { 883*ce41cfb3SToomas Soome free(strdat); 8847c478bd9Sstevel@tonic-gate return (err); 885*ce41cfb3SToomas Soome } 8867c478bd9Sstevel@tonic-gate (void) ptree_create_and_add_prop(nodeh, &propinfo, 8877c478bd9Sstevel@tonic-gate strdat, NULL); 8887c478bd9Sstevel@tonic-gate } 889*ce41cfb3SToomas Soome 890*ce41cfb3SToomas 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 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 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 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 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 /* 1767bdee4892SMichael Bergknoff * Check for a stale OBP node. EINVAL is returned from the openprom(7D) driver 1768bdee4892SMichael Bergknoff * if the nodeid stored in the snapshot is not valid. 1769bdee4892SMichael Bergknoff */ 1770bdee4892SMichael Bergknoff static int 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 * 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 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 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 * 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 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 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 * 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 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 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 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 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 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); 2976*ce41cfb3SToomas 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); 2980*ce41cfb3SToomas Soome if (err == PICL_SUCCESS) 2981*ce41cfb3SToomas Soome *regval = *regbuf; /* get first 32-bit value */ 2982*ce41cfb3SToomas Soome free(regbuf); 2983*ce41cfb3SToomas 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 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; 3341*ce41cfb3SToomas 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) { 3350*ce41cfb3SToomas 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 3360*ce41cfb3SToomas 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 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; 3393*ce41cfb3SToomas 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) { 3401*ce41cfb3SToomas Soome free(regbuf); 34027c478bd9Sstevel@tonic-gate return (PICL_FAILURE); 34037c478bd9Sstevel@tonic-gate } 3404*ce41cfb3SToomas 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 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 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 3486*ce41cfb3SToomas 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); 3491*ce41cfb3SToomas Soome if (err != PICL_SUCCESS) { 3492*ce41cfb3SToomas Soome free(regbuf); 34937c478bd9Sstevel@tonic-gate return (err); 3494*ce41cfb3SToomas 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)); 3506*ce41cfb3SToomas 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); 3517*ce41cfb3SToomas 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 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 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 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 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